精华内容
下载资源
问答
  • 本文实例讲述了Java编程实现非对称加密的方法。分享给大家供大家参考,具体如下:对称加密...是一种 高级的双保险加密方式,一般的实现加密方式有DH密钥交换算法,RSA基于因子分解算法,ElGamal离散对数算法及ECC...

    本文实例讲述了Java编程实现非对称加密的方法。分享给大家供大家参考,具体如下:

    对称加密算法在加密和解密时使用的是同一个秘钥;而非对称加密算法需要两个密钥来进行加密和解密,这两个秘钥是公开密钥(public key,简称公钥)和私有密钥(private key,简称私钥)。

    是一种 高级的双保险加密方式,一般的实现加密方式有DH密钥交换算法,RSA基于因子分解算法,ElGamal离散对数算法及ECC椭圆曲线加密等。

    DH加密解密

    /**

    * 非对称加密之:DH加密

    * 非对称DH,是安全性基于在有限域中计算离散对数的难度的一种加密算法。

    * 可用于密钥分发,但不能用于加/解密报文。DH即Diffie-Hellman算法的简写,也缩写为D-H算法。

    * D-H加密算法的核心思想就是大素数不可分解质因数的数学理论方法。

    * @description:

    * @date 2015-10-29 上午9:08:14

    */

    public class EncryptDH {

    private static String dhStr = "encrypt test by DH";

    public static void main(String[] args) {

    jdkDh();

    }

    private static void jdkDh() {

    try {

    // 初始化发送方密钥

    KeyPairGenerator senderKeyPairGenerator = KeyPairGenerator.getInstance("DH");

    senderKeyPairGenerator.initialize(512);

    KeyPair senderKeyPair = senderKeyPairGenerator.generateKeyPair();

    byte[] senderPublicKeyEnc = senderKeyPair.getPublic().getEncoded();// 发送方的公钥,发送给接受方,发送方式多种,比如文件,网络等

    // 初始化接受方密钥

    KeyFactory receiverKeyFactory = KeyFactory.getInstance("DH");

    X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(senderPublicKeyEnc);

    PublicKey receiverPublicKey = receiverKeyFactory.generatePublic(x509EncodedKeySpec);

    DHParameterSpec dhParameterSpec = ((DHPublicKey) receiverPublicKey).getParams();

    KeyPairGenerator receiverKeyPairGenerator = KeyPairGenerator.getInstance("DH");

    receiverKeyPairGenerator.initialize(dhParameterSpec);

    KeyPair receiveKeyPair = receiverKeyPairGenerator.generateKeyPair();

    PrivateKey receiverPrivateKey = receiveKeyPair.getPrivate();

    byte[] receiverPublicKeyEnc = receiveKeyPair.getPublic().getEncoded();

    // 密钥构建

    KeyAgreement receiverKeyAgreement = KeyAgreement.getInstance("DH");

    receiverKeyAgreement.init(receiverPrivateKey);

    receiverKeyAgreement.doPhase(receiverPublicKey, true);

    SecretKey receiverSecretKey = receiverKeyAgreement.generateSecret("DES");

    KeyFactory senderKeyFactory = KeyFactory.getInstance("DH");

    x509EncodedKeySpec = new X509EncodedKeySpec(receiverPublicKeyEnc);

    PublicKey senderPublicKey = senderKeyFactory.generatePublic(x509EncodedKeySpec);

    KeyAgreement senderKeyAgreement = KeyAgreement.getInstance("DH");

    senderKeyAgreement.init(senderKeyPair.getPrivate());

    senderKeyAgreement.doPhase(senderPublicKey, true);

    SecretKey snederSecretKey = senderKeyAgreement.generateSecret("DES");

    if (Objects.equals(receiverSecretKey, snederSecretKey)) {

    System.out.println("双方密钥相同");

    }

    // 加密

    Cipher cipher = Cipher.getInstance("DES");

    cipher.init(Cipher.ENCRYPT_MODE, snederSecretKey);

    byte[] result = cipher.doFinal(dhStr.getBytes());

    System.out.println("DH加密后为:" + Base64.encode(result));

    // 解密

    cipher.init(Cipher.DECRYPT_MODE, receiverSecretKey);

    result = cipher.doFinal(result);

    System.out.println("DH解密后为:" + new String(result));

    }

    catch (Exception e) {

    e.printStackTrace();

    }

    }

    }

    RSA加密解密

    /**

    * 非对称加密之:RSA加密

    * @description:

    * RSA公钥加密算法是1977年由罗纳德·李维斯特(Ron Rivest)、阿迪·萨莫尔(Adi Shamir)和伦纳德·阿德曼(Leonard Adleman)一起提出的。

    * 1987年首次公布,当时他们三人都在麻省理工学院工作。RSA就是他们三人姓氏开头字母拼在一起组成的。

    * RSA是目前最有影响力的公钥加密算法,它能够抵抗到目前为止已知的绝大多数密码攻击,已被ISO推荐为公钥数据加密标准。

    * 今天只有短的RSA钥匙才可能被强力方式解破。到2008年为止,世界上还没有任何可靠的攻击RSA算法的方式。只要其钥匙的长度足够长,用RSA加密的信息实际上是不能被解破的。

    * 但在分布式计算和量子计算机理论日趋成熟的今天,RSA加密安全性受到了挑战。

    * RSA算法基于一个十分简单的数论事实:将两个大素数相乘十分容易,但是想要对其乘积进行因式分解却极其困难,因此可以将乘积公开作为加密密钥。

    * @date 2015-10-29 上午9:08:14

    */

    public class EncryptRSA {

    private static String rsaStr = "encrypt test by ElGamal";

    public static void main(String[] args) {

    jdkRSA();

    }

    private static void jdkRSA() {

    try {

    // 初始化密钥

    KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");

    keyPairGenerator.initialize(512);

    KeyPair keyPair = keyPairGenerator.generateKeyPair();

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

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

    System.out.println("RSA公钥:" + Base64.encode(rsaPublicKey.getEncoded()));

    System.out.println("RSA私钥:" + Base64.encode(rsaPrivateKey.getEncoded()));

    // 私钥加密,公钥解密--加密

    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);

    byte[] result = cipher.doFinal(rsaStr.getBytes());

    System.out.println("RSA私钥加密,公钥解密--加密:" + Base64.encode(result));

    // 私钥加密,公钥解密--解密

    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);

    result = cipher.doFinal(result);

    System.out.println("RSA私钥加密,公钥解密--解密:" + new String(result));

    // 公钥加密,私钥解密--加密

    x509EncodedKeySpec = new X509EncodedKeySpec(rsaPublicKey.getEncoded());

    keyFactory = KeyFactory.getInstance("RSA");

    publicKey = keyFactory.generatePublic(x509EncodedKeySpec);

    cipher = Cipher.getInstance("RSA");

    cipher.init(Cipher.ENCRYPT_MODE, publicKey);

    result = cipher.doFinal(rsaStr.getBytes());

    System.out.println("公钥加密,私钥解密--加密:" + Base64.encode(result));

    // 公钥加密,私钥解密--解密

    pkcs8EncodedKeySpec=new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());

    keyFactory = KeyFactory.getInstance("RSA");

    privateKey= keyFactory.generatePrivate(pkcs8EncodedKeySpec);

    cipher = Cipher.getInstance("RSA");

    cipher.init(Cipher.DECRYPT_MODE, privateKey);

    result = cipher.doFinal(result);

    System.out.println("公钥加密,私钥解密--解密:" + new String(result));

    }

    catch (Exception e) {

    e.printStackTrace();

    }

    }

    }

    ElGamal加密

    /**

    * 非对称加密之:ElGamal加密

    * @description:

    * ElGamal算法,是一种较为常见的加密算法,它是基于1984年提出的公钥密码体制和椭圆曲线加密体系。

    * 既能用于数据加密也能用于数字签名,其安全性依赖于计算有限域上离散对数这一难题。

    * 在加密过程中,生成的密文长度是明文的两倍,且每次加密后都会在密文中生成一个随机数K,

    * 在密码中主要应用离散对数问题的几个性质:求解离散对数(可能)是困难的,而其逆运算指数运算可以应用平方-乘的方法有效地计算。

    * 也就是说,在适当的群G中,指数函数是单向函数。

    * @date 2015-10-29 上午9:08:14

    */

    public class EncrypElGamal {

    private static String rsaStr = "encrypt test by ElGamal";

    public static void main(String[] args) {

    jdkRSA();

    }

    private static void jdkRSA() {

    try {

    // 公钥加密,私钥解密

    // Security.addProvider(new BouncyCastleProvider());//需要添加bouncycastleprovider jar

    //初始化密钥

    AlgorithmParameterGenerator algorithmParameterGenerator=AlgorithmParameterGenerator.getInstance("ElGamal");

    algorithmParameterGenerator.init(256);

    AlgorithmParameters algorithmParameters=algorithmParameterGenerator.generateParameters();

    DHParameterSpec dhParameterSpec=algorithmParameters.getParameterSpec(DHParameterSpec.class);

    KeyPairGenerator keyPairGenerator=KeyPairGenerator.getInstance("ElGamal");

    keyPairGenerator.initialize(dhParameterSpec,new SecureRandom());

    KeyPair keyPair=keyPairGenerator.generateKeyPair();

    PublicKey publicKey=keyPair.getPublic();

    PrivateKey privateKey=keyPair.getPrivate();

    System.out.println("ElGamal加密公钥:"+Base64.encode(publicKey.getEncoded()));

    System.out.println("ElGamal加密私钥:"+Base64.encode(privateKey.getEncoded()));

    //加密解密同Rsa是一样的

    }

    catch (Exception e) {

    e.printStackTrace();

    }

    }

    }

    Ecc加密可以参考:http://www.pediy.com/kssd/pediy06/pediy6014.htm等。

    PS:关于加密解密感兴趣的朋友还可以参考本站在线工具:

    在线MD5/hash/SHA-1/SHA-2/SHA-256/SHA-512/SHA-3/RIPEMD-160加密工具:http://tools.jb51.net/password/hash_md5_sha

    希望本文所述对大家java程序设计有所帮助。

    展开全文
  • 1.1 为什么要对API接口进行加密? ...1.2 常见的接口加密方式有哪些? 使用https协议(相比较与http协议,https协议加入了ssl证书,并且https是基于ssl的密文传输方式)、参数加密使用对称加密或非

    1.1 为什么要对API接口进行加密?

    在这里插入图片描述
    因为http协议是明文传输,它是不够安全的,比如进行get请求的时候,请求参数会直接附加在URL后边,即使是post请求其实也是不够安全的,如果用户连接了不安全的网络,这个时候黑客可能可以通过抓包工具直接获取请求信息,并且黑客可能对请求参数进行非法篡改,所以API接口加密就显得至关重要了!

    1.2 常见的接口加密方式有哪些?

    使用https协议(相比较与http协议,https协议加入了ssl证书,并且https是基于ssl的密文传输方式)、参数加密使用对称加密或非对称加密。

    1.3 URL特殊字符转码

    1.3.1 什么是URL特殊字符?使用这些字符在请求参数中会照成什么问题?

    比如\、?、+、#等一些特殊字符都是URL特殊字符,当这些字符用在请求参数中,可能会导致后端获取到的请求参数与原始值不一致。
    在这里插入图片描述
    如上图中,请求参数userName是1+1,后端参数接收实际上为1 1(1空格1)

    1.3.2 在Java中如何实现URL特殊字符转码与解码?

    在Java中要实现URL的转码特别简单,可以直接使用javax.net包中的,URLEncoder进行编码,使用URLDeCoder可以实现URL特殊编码的解码,当然也可以借助其他第三方的解码类库。

    1.3.2.1 使用javax.net.URLEncoder进行URL特殊字符编码

    @Test
    public void urlEncoderTest(){    
        String userName="xiao+ming";    
        System.out.println("编码前:"+userName);    
        try {        
            userName=URLEncoder.encode(userName,"utf-8");        
            System.out.println("编码后:"+userName);    
        } catch (UnsupportedEncodingException e) {        
        e.printStackTrace();    }
    }
    
    
    

    控制台输出结果:
    在这里插入图片描述

    1.3.2.2 使用javax.net.URLDecoder进行URL特殊字符解码

        public void urlEncoderTest(){
            String userName="xiao+ming";
    
            System.out.println("编码前:"+userName);
    
            try {
                userName=URLEncoder.encode(userName,"utf-8");
    
                System.out.println("编码后:"+userName);
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
    
            try {
                userName= URLDecoder.decode(userName,"utf-8");
    
                System.out.println("解码后:"+userName);
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        }
    

    控制台打印结果:

    在这里插入图片描述

    1.4 什么是对称加密?

    对称加密指的是,加密与解密的密钥是一致的,也就是说通过什么密钥进行加密就使用什么密钥解密,常见的对称加密算法有AES、DES
    在这里插入图片描述

    1.4.1 对称加密的使用场景

    服务端与服务端的通信可以采用对称加密,因为这种场景相对安全,不会将密钥保存在客户端所以其他人无法对数据进行解密,也就无法非法获取数据。

    1.4.2 对称加密的缺点

    不适合用于,客户端与服务器端交互的加密,因为他人可能通过反编译客户端源码的方式获取到加密密钥。

    1.5 什么是非对称加密?

    非对称加密,指的就是加密使用的密钥与解密使用的密钥是不一致的,也就是我们常说的公钥与私钥,非对称加密的典型算法是RSA。
    在这里插入图片描述

    1.5.1 通过工具类生成公钥和私钥

    package com.muzili.demo.demo0628.util;
    
    import sun.misc.BASE64Decoder;
    import sun.misc.BASE64Encoder;
    
    import javax.crypto.Cipher;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.security.*;
    import java.security.spec.PKCS8EncodedKeySpec;
    import java.security.spec.X509EncodedKeySpec;
    
    /**
     * RSA加密,支持分片加密
     * <pre>
     * BCD码(Binary-Coded Decimal)亦称二进码十进数或二-十进制代码。
     * 用4位二进制数来表示1位十进制数中的0~9这10个数码。
     * 是一种二进制的数字编码形式,用二进制编码的十进制代码。
     * 注:日常所说的BCD码大都是指8421BCD码形式
     * @author muzili
     * 
     */
    public class RSAUtil {
    	/** 指定加密算法为RSA */
    	private static String ALGORITHM = "RSA";
    	/** 指定key的大小 */
    	private static int KEYSIZE = 1024;
    	/** 指定公钥存放文件 */
    	private static String PUBLIC_KEY_FILE = "PublicKey.key";
    	/** 指定私钥存放文件 */
    	private static String PRIVATE_KEY_FILE = "PrivateKey.key";
     
    	public static final String KEY_ALGORITHM = "RSA";
    	public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
     
    	/**
    	 * 生成密钥对
    	 */
    	public static void generateKeyPair() throws Exception {
    		if (getpublickey() == null || getprivatekey() == null) {
    			/** RSA算法要求有一个可信任的随机数源 */
    			SecureRandom sr = new SecureRandom();
    			/** 为RSA算法创建一个KeyPairGenerator对象 */
    			KeyPairGenerator kpg = KeyPairGenerator.getInstance(ALGORITHM);
    			/** 利用上面的随机数据源初始化这个KeyPairGenerator对象 */
    			kpg.initialize(KEYSIZE, sr);
    			/** 生成密匙对 */
    			KeyPair kp = kpg.generateKeyPair();
    			/** 得到公钥 */
    			Key publicKey = kp.getPublic();
    			/** 得到私钥 */
    			Key privateKey = kp.getPrivate();
    
    			System.out.println("公钥:"+encryptBASE64(publicKey.getEncoded()));
    			System.out.println("私钥:"+encryptBASE64(privateKey.getEncoded()));
    
    			/** 用对象流将生成的密钥写入文件 */
    			ObjectOutputStream oos1 = new ObjectOutputStream(new FileOutputStream(PUBLIC_KEY_FILE));
    			ObjectOutputStream oos2 = new ObjectOutputStream(new FileOutputStream(PRIVATE_KEY_FILE));
    			oos1.writeObject(publicKey);
    			oos2.writeObject(privateKey);
    			/** 清空缓存,关闭文件输出流 */
    			oos1.close();
    			oos2.close();
    		}
     
    	}
     
    	/**
    	 * 产生签名
    	 * 
    	 * @param data
    	 * @param privateKey
    	 * @return
    	 * @throws Exception
    	 */
    	public static String sign(byte[] data, String privateKey) throws Exception {
    		// 解密由base64编码的私钥
    		byte[] keyBytes = decryptBASE64(privateKey);
     
    		// 构造PKCS8EncodedKeySpec对象
    		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
     
    		// KEY_ALGORITHM 指定的加密算法
    		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
     
    		// 取私钥对象
    		PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);
     
    		// 用私钥对信息生成数字签名
    		Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
    		signature.initSign(priKey);
    		signature.update(data);
     
    		return encryptBASE64(signature.sign());
    	}
     
    	/**
    	 * 验证签名
    	 * 
    	 * @param data
    	 * @param publicKey
    	 * @param sign
    	 * @return
    	 * @throws Exception
    	 */
    	public static boolean verify(byte[] data, String publicKey, String sign) throws Exception {
     
    		// 解密由base64编码的公钥
    		byte[] keyBytes = decryptBASE64(publicKey);
     
    		// 构造X509EncodedKeySpec对象
    		X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
     
    		// KEY_ALGORITHM 指定的加密算法
    		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
     
    		// 取公钥对象
    		PublicKey pubKey = keyFactory.generatePublic(keySpec);
     
    		Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
    		signature.initVerify(pubKey);
    		signature.update(data);
     
    		// 验证签名是否有效
    		return signature.verify(decryptBASE64(sign));
    	}
     
    	/**
    	 * BASE64解密
    	 * 
    	 * @param key
    	 * @return
    	 * @throws Exception
    	 */
    	public static byte[] decryptBASE64(String key) throws Exception {
    		return (new BASE64Decoder()).decodeBuffer(key);
    	}
     
    	/**
    	 * BASE64加密
    	 * 
    	 * @param key
    	 * @return
    	 * @throws Exception
    	 */
    	public static String encryptBASE64(byte[] key) throws Exception {
    		return (new BASE64Encoder()).encodeBuffer(key);
    	}
     
    	/**
    	 * 加密方法 source: 源数据
    	 */
    	public static String encrypt(String source) throws Exception {
    		generateKeyPair();
    		/** 将文件中的公钥对象读出 */
    		ObjectInputStream ois = new ObjectInputStream(new FileInputStream(PUBLIC_KEY_FILE));
    		Key key = (Key) ois.readObject();
    		ois.close();
    		/** 得到Cipher对象来实现对源数据的RSA加密 */
    		Cipher cipher = Cipher.getInstance(ALGORITHM);
    		cipher.init(Cipher.ENCRYPT_MODE, key);
    		int MaxBlockSize = KEYSIZE / 8;
    		int len = (MaxBlockSize - 11) / 8;
    		String[] datas = splitString(source, len);
    		StringBuffer mi = new StringBuffer();
    		for (String s : datas) {
    			mi.append(bcd2Str(cipher.doFinal(s.getBytes())));
    		}
    		return mi.toString();
     
    	}
     
    	/**
    	 * 字符串分片
    	 * 
    	 * @param string
    	 *            源字符串
    	 * @param len
    	 *            单片的长度(keysize/8)
    	 * @return
    	 */
    	public static String[] splitString(String string, int len) {
    		int x = string.length() / len;
    		int y = string.length() % len;
    		int z = 0;
    		if (y != 0) {
    			z = 1;
    		}
    		String[] strings = new String[x + z];
    		String str = "";
    		for (int i = 0; i < x + z; i++) {
    			if (i == x + z - 1 && y != 0) {
    				str = string.substring(i * len, i * len + y);
    			} else {
    				str = string.substring(i * len, i * len + len);
    			}
    			strings[i] = str;
    		}
    		return strings;
    	}
     
    	/**
    	 * bcd 转 Str
    	 * 
    	 * @param bytes
    	 * @return
    	 */
    	public static String bcd2Str(byte[] bytes) {
    		char temp[] = new char[bytes.length * 2], val;
    		for (int i = 0; i < bytes.length; i++) {
    			val = (char) (((bytes[i] & 0xf0) >> 4) & 0x0f);
    			temp[i * 2] = (char) (val > 9 ? val + 'A' - 10 : val + '0');
     
    			val = (char) (bytes[i] & 0x0f);
    			temp[i * 2 + 1] = (char) (val > 9 ? val + 'A' - 10 : val + '0');
    		}
    		return new String(temp);
    	}
     
    	/**
    	 * 解密
    	 * 
    	 * @param cryptograph
    	 *            :密文
    	 * @return 解密后的明文
    	 * @throws Exception
    	 */
    	public static String decrypt(String cryptograph) throws Exception {
    		generateKeyPair();
    		/** 将文件中的私钥对象读出 */
    		@SuppressWarnings("resource")
    		ObjectInputStream ois = new ObjectInputStream(new FileInputStream(PRIVATE_KEY_FILE));
    		Key key = (Key) ois.readObject();
    		/** 得到Cipher对象对已用公钥加密的数据进行RSA解密 */
    		Cipher cipher = Cipher.getInstance(ALGORITHM);
    		cipher.init(Cipher.DECRYPT_MODE, key);
    		int key_len = KEYSIZE / 8;
    		byte[] bytes = cryptograph.getBytes();
    		byte[] bcd = ASCII2BCD(bytes, bytes.length);
    		StringBuffer sBuffer = new StringBuffer();
    		byte[][] arrays = splitArray(bcd, key_len);
    		for (byte[] arr : arrays) {
    			sBuffer.append(new String(cipher.doFinal(arr)));
    		}
    		return sBuffer.toString();
    	}
     
    	/**
    	 * ASCII 转 BCD
    	 * 
    	 * @param ascii
    	 * @param asc_len
    	 * @return
    	 */
    	public static byte[] ASCII2BCD(byte[] ascii, int asc_len) {
    		byte[] bcd = new byte[asc_len / 2];
    		int j = 0;
    		for (int i = 0; i < (asc_len + 1) / 2; i++) {
    			bcd[i] = asc2bcd(ascii[j++]);
    			bcd[i] = (byte) (((j >= asc_len) ? 0x00 : asc2bcd(ascii[j++])) + (bcd[i] << 4));
    		}
    		return bcd;
    	}
     
    	/**
    	 * asc转bcd
    	 * 
    	 * @param asc
    	 * @return
    	 */
    	public static byte asc2bcd(byte asc) {
    		byte bcd;
     
    		if ((asc >= '0') && (asc <= '9'))
    			bcd = (byte) (asc - '0');
    		else if ((asc >= 'A') && (asc <= 'F'))
    			bcd = (byte) (asc - 'A' + 10);
    		else if ((asc >= 'a') && (asc <= 'f'))
    			bcd = (byte) (asc - 'a' + 10);
    		else
    			bcd = (byte) (asc - 48);
    		return bcd;
    	}
     
    	/**
    	 * 字节数组分片
    	 * 
    	 * @param data
    	 * @param len
    	 * @return
    	 */
    	public static byte[][] splitArray(byte[] data, int len) {
    		int x = data.length / len;
    		int y = data.length % len;
    		int z = 0;
    		if (y != 0) {
    			z = 1;
    		}
    		byte[][] arrays = new byte[x + z][];
    		byte[] arr;
    		for (int i = 0; i < x + z; i++) {
    			arr = new byte[len];
    			if (i == x + z - 1 && y != 0) {
    				System.arraycopy(data, i * len, arr, 0, y);
    			} else {
    				System.arraycopy(data, i * len, arr, 0, len);
    			}
    			arrays[i] = arr;
    		}
    		return arrays;
    	}
     
    	/** 将文件中的公钥对象读出 */
    	public static String getpublickey() {
     
    		try {
    			@SuppressWarnings("resource")
    			ObjectInputStream ois = new ObjectInputStream(new FileInputStream(PUBLIC_KEY_FILE));
    			Key key = (Key) ois.readObject();
    			String publickey = encryptBASE64(key.getEncoded());
    			return publickey;
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    		return null;
    	}
     
    	/** 将文件中的私钥对象读出 */
    	public static String getprivatekey() {
    		try {
    			@SuppressWarnings("resource")
    			ObjectInputStream ois = new ObjectInputStream(new FileInputStream(PRIVATE_KEY_FILE));
    			Key key = (Key) ois.readObject();
    			String privatekey = encryptBASE64(key.getEncoded());
    			return privatekey;
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    		return null;
    	}
     
    	public static void main(String[] args) {
    		try {
    			generateKeyPair();
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    		try {
    			String s = encrypt("天天舞苑");
    			System.out.println("加密:"+s);
    			System.out.println("解密:"+decrypt(s));
     
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    }
    

    控制台打印:
    在这里插入图片描述

    展开全文
  • 加密,解密的话,分为,对称加密,和非对称加密。 像 des,aes 就是对称加密 非对称 RSA,DSA,等。 对称和非对称是指,加密和解密的时候,是不是需要同一个秘钥。非对称加密,使用私钥和公钥两种秘钥。 支付宝...

    md5   base64  都不属于加密。

    md5 叫做 信息摘要   简单来讲就是 一个 映射关系。

    base64 是一种编码方式。

    加密,解密的话,分为,对称加密,和非对称加密。

    像 des,aes 就是对称加密 

    非对称 RSA,DSA,等。

    对称和非对称是指,加密和解密的时候,是不是需要同一个秘钥。非对称加密,使用私钥和公钥两种秘钥。

    支付宝接口对接的时候,基本都是 使用的RSA 方式。

    SSL 里,就得选择 用哪种加密方式。

    展开全文
  •   某一天你认识了一个小姐姐,她没有给你联系方式,你只知道她的上班地址和姓名,回到家中你日思夜想,非常想念这位小姐姐,于是你就开始给她写信,那么写信有哪些问题?   我在给她写信的时候,中间有一个邪恶...

    引言

      某一天你认识了一个小姐姐,她没有给你联系方式,你只知道她的上班地址和姓名,回到家中你日思夜想,非常想念这位小姐姐,于是你就开始给她写信,那么写信有哪些问题?
      我在给她写信的时候,中间有一个邪恶的邮递员(超邪恶 )他总想把我和小姐姐拆了,我们在讨论信息传送安全的问题,需要注意那些问题呢
        1.消息可能会被伪造(邪恶的邮递员用我的口吻给小姐姐写一封信:你一点也不漂亮,然后小姐姐从此再也不理我了
        2.消息可能被修改(邪恶的邮递员在我的信中随便改动)
        3.消息可能被监听(小姐姐能够成功看到信息,但是邮递员也看到了,他就可以通过一些信息对我进行诈骗、勒索)
    在这里插入图片描述
      那么怎么解决这个问题?

    对称加密算法

      于是你想到了在消息上面进行加密,你可以提前给小姐姐说好,我写的消息每个字母都会往后移动三位,比如你写 abc 那么它的实际内容就是 def,这样邮递员就看不懂我们写的什么内容了,这就是对称加密算法:对称加密(也叫私钥加密)指加密和解密使用相同密钥的加密算法,就是你写信的时候不会写实际内容,而是写的实际内容加密后的内容,然后小姐姐通过你的加密方法反解出真实的内容。
    在这里插入图片描述
    常见的对称加密算法及对比
      1、DES 已破解,不再安全,基本没有企业在用了是对称加密算法的基石,具有学习价值密钥长度56(JDK)、56/64(BC)
      2、DESede(三重DES)早于AES出现来替代DES计算密钥时间太长、加密效率不高,所以也基本上不用密钥长度112/168(JDK)、128/192(BC)
      3、AES最常用的对称加密算法密钥建立时间短、灵敏性好、内存需求低(不管怎样,反正就是好)实际使用中,使用工作模式为CTR(最好用BC去实现),此工作模式需要引入IV参数(16位的字节数组)密钥长度128/192/256,其中192与256需要配置无政策限制权限文件(JDK6)填充模式最常用的两种PKCS5Padding和PKCS7Padding,其中后者只有BC独有。
      4、IDEA常用的电子邮件加密算法工作模式只有ECB密钥长度128位
      5、PBE综合了消息摘要算法和对称加密算法,最常见的是PBEWithMD5AndDES工作模式只有CBC(已丧失安全性,不推荐使用),所以PBE也不推荐使用了

    非对称加密算法

    但是邮递员可以对我们的内容进行修改,虽然我读不懂,但是就是想要搞你!!!!(就很棒),还有一个问题就是你如何让小姐姐知道你的加密方法,显然是不可能通过写信的方式告诉小姐姐,那么你就可以通过非对称加密来进行传输信息,非对称加密有一个口诀:公钥加密私钥解,私钥加密公钥解
    在这里插入图片描述
    A0通过公钥加密变成A1,A1通过私钥解密就可以还原A0

    那么我怎么和小姐姐通信?我们可以先写一封信告诉小姐姐你的公钥是多少,小姐姐告诉了我她的公钥,我通过她的公钥进行加密我的信,然后小姐姐通过她的私钥就可以拿到我所写信的真实内容。
    在这里插入图片描述
    这就成功解决了被监听的问题,但是还是不能解决被伪造了问题,因为邮递员也拿到了小姐姐的公钥,他也可以通过这个公钥给小姐姐发送信息,说我每天都在撩其他小姐姐
    之前说过,公钥加密私钥解,私钥加密公钥解,我可以先写一封信告诉小姐姐我的公钥是xx,然后小姐姐说好的我知道了,然后我通过我的私钥进行加密,然后发送给小姐姐,小姐姐也能正常的看到信息,因为邮递员没有我的私钥所以就避免了伪造,但是邮递员能知道我的公钥,那么他也能读取我的内容,好像单纯考非对称加密也解决不了问题。在这里插入图片描述
    聪明的你可能想到了你已经学过了对称加密算法
    1.先给小姐姐写信问她的公钥
    2.小姐姐告诉了你的公钥
    3.使用公钥将对称加密算法psk进行加密(假设是:123456),并告诉小姐姐我们接下来要使用对称加密算法了
    4.由于邮递员没有小姐姐的密钥,所以他看不到我写的内容,一旦我和小姐姐都有了psk的密钥,我们就可以通信了,这就有效的防止了监听、伪造、修改的所有问题。
    在这里插入图片描述
    当然还有一个最重要的问题还没有解决,就是如何确定写信的人是我,或者收信的人是小姐姐勒?
    在这里插入图片描述
    万一收信的是一个大胡子猛男怎么办,这就涉及到数字签名,聪明的你知道吗hhh

    展开全文
  • 一. 什么是加密 加密,是以某种特殊的算法改变原有的信息数据,使得未授权的用户即使获得了已加密的信息,但因不知解密的方法,...加密方式有哪些,具体怎么加密 (一).双向加密 1 .对称秘钥加密 对称秘钥加密,...
  • 加密的本质

    2019-10-08 14:13:15
    1.加密方式有哪些? 明文:未加密的信息 加密秘钥:给明文加密的参数 密文:加密后的信息 解密秘钥:把密文解密成明文的参数 加密和解密的本质都是转换! 加密的本质就是用某种规则A把明文内容转换成另一...
  • 区块链技术特点都有哪些??

    千次阅读 2019-01-15 18:14:57
    想知道更多区块链技术知识,请百度【链客区块链技术问答社区】 ...数据层数据区块, 链式结构, 时间戳, 非对称加密, 哈希函数, Merkle树。网络层P2P网络, 传播机制, 验证机制共识层PoW, PoS, ...
  • (1)、常用的对称加解密有哪些? (2)、加解密的模式 【ecb】这种模式是将整个明文分成若干段相同的小段,然后对每一小段进行加密 【cbc】这种模式是先将明文切分成若干小段,然后每一小段与初始块或者上一段的...
  • 我们在上一篇文章《WEB开发中常见的加密方式有哪些》中介绍了非对称加密RSA2算法,它适合加密少量数据,比如支付数据等安全要求高的场景。 我们首先要生成公钥和私钥文件: openssl genrsa -out private_key.pem ...
  • 1.对称加密和非对称加密的优缺点,为什么这么做?RSA 2.线程池线程的提交方式和优缺点。 3.Protobuff和msgpack的优缺点还有坑在哪里? 4.对JVM的了解和观测,什么时候进行full gc? 5.MySQL的索引有什么用?都...
  • 可信计算复习

    2021-01-10 20:48:07
    3.常见的对称加密算法和非对称加密算法有哪些,特色和应用场景? 4.为什么需要PKI,证书和公私密钥对的关系? 5.可信计算的基本属性? 6.为什么说TPM曾加对称加密算法的支持不会给PC系统提供更高的安全性? 7.TRM1.0和1.2...
  • 对称加密和非对称加密的算法有哪些?3DES为什么叫3DES? 是否单例,为什么是单例。 如何在基于Java的Web项目中实现文件上传和下载? 缓存的优点? 说说MVC的各个部分都有那些技术来实现?如何实现? 什么是DAO模式? ...
  • 对称加密与非对称加密区别。 图的的数据结构是什么?如何表示。 session 与 cookie。 锁有哪些 说说 epoll 模型。 面试官上来一个问题,你的优点是什么 进程和线程,进程通信方式,线程通信方式 有10条线程...
  • https中哪里用了对称加密,哪里用了非对称加密,对加密算法(如RSA)等是否了解? http,https什么不同,如何进行加密,各种加密算法的性能; 你知道的几种网络请求方式,get和post什么区别,性能比较; 三...
  • 对称加密对称加密? 什么是同源策略? cookie存在哪里?可以打开吗 xss如何盗取cookie? tcp、udp的区别及tcp三次握手,syn攻击? 证书要考哪些? DVWA是如何搭建的? 渗透测试的流程是什么 xss如何防御 ...
  • 前言: 与其每天浑水摸鱼、浑浑噩噩,不如多进阶学习,提升自己的竞争力。 Android中高级必会知识点: 一、性能优化 1、APP稳定性优化 1.做过哪些稳定性方面的优化...腾讯—什么是对称加密,什么是非对称加密,公钥与私
  • 先说下这东西干嘛的。 这东西就是解决http不安全的问题,那么http有哪些不安全的问题呢...简单说下:https是通过共享密钥加密(对称加密)和公开密钥加密的混合方式进行的 通过公开密钥的方式确定采用什么样的共享...
  • 因此 KCP 的方式是把协议栈 “拆开”,让大家可以根据项目需求进行灵活的调整和组装,你可以下面加一层 reed solomon 的纠删码做 FEC,上面加一层类 RC4/Salsa20 做流加密,握手处再设计一套非对称密钥交换,底层 ...
  • 第一次观看我文章的朋友,可以关注、点赞、转发一下,每天分享各种干货技术和程序猿趣事 由于涉及到的面试题较多导致篇幅较长,我根据这些...tsl的握手和具体的非对称加密算法。非对称名称 3:handler的post(Runnab.
  • 【秋招面经分享】字节八面终上岸

    千次阅读 2020-11-02 21:04:15
    Redis的数据结构,它有哪些复杂数据结构? 3. Http与Https的区别,详细描述加密非对称加密的过程 4. 线程与进程的区别? 5. IO多路复用 6. redis服务端是多进程还是单进程,多线程还是单线程 7. top load...
  • 正文 从我个人的角度写写30多岁码工的感受:的确是受年龄压力开始增大了。比如二十多岁的小年轻,可能什么都懂,对组里的东西很熟悉。...tsl的握手和具体的非对称加密算法。非对称名称 3:handler的post(Runnabl
  • 一、背景介绍 从实用角度梳理一篇能够帮大家快速扫盲的CMake基础教程,也是对我目前负责项目的一次学习总结。...tsl的握手和具体的非对称加密算法。非对称名称 3:handler的post(Runnable)如何实现的。callback,runnab
  • 摘要 说在前面,面试时最好不要虚报工资。本来字节跳动是很想去的,几轮面试也通过了,最后没offer,自己只想到几个原因:1、虚报工资,...tsl的握手和具体的非对称加密算法。非对称名称 3.handler的post(Runnable)...
  • 说在前面,面试时最好不要虚报工资。本来字节跳动是很想去的,几轮面试也通过了,最后没offer,自己只想到几个原因:1、虚报...tsl的握手和具体的非对称加密算法。非对称名称 3.handler的post(Runnable)如何实现的。
  • 面试问题笔记

    2020-04-27 23:25:17
    计算机网络 OSI参考模型(怎么封装解封的,每层重点...对称密钥/非对称密钥加密方式,什么时候应用 操作系统 进程和线程 常见调度算法 死锁的产生和解决 虚拟内存(概念、为什么会产生虚拟内存),页面置换算...
  • 1.开篇 ...密码学算法背后有哪些神奇的数学理论?3何时比9大?计算可逆性错觉究竟是如何在数学领域被打破?...以加密通信为例,主人公小华要向他的朋友美丽通过加密方式发送一份电子邮件,可以先找...
  • 前言 最近,同学参加阿里云的面试,被问到:如果是MySQL引起的CPU消耗过大,你会如何优化?他说,这个问题他第一次遇到,当时一头雾水,不知道该如何回答,还好他当时机制,说MySQL...tsl的握手和具体的非对称加密
  • 前言 想要成為一名優秀的Android開發,你需要一份完備的 知識體系,在這裏,讓我們一起成長為自己所想的那樣。 金九银十是大家的換工作潮,在這波浪潮裡沉浮的我經歷過快...tsl的握手和具体的非对称加密算法。非对称名
  • Http和Https

    2020-12-23 21:38:39
    文章目录一、HTTP1、常用的HTTP方法有哪些?2、GET方法与POST方法的区别3、HTTP请求报文与响应报文格式4、常见的HTTP相应状态码5、HTTP1.1版本新特性6.Http协议实现的原理机制二、Https1、HTTP的缺点与HTTPS2、HTTPS...

空空如也

空空如也

1 2
收藏数 40
精华内容 16
关键字:

对称加密方式有哪些