数据传输加密非对称加密算法以及对称算法-RSA+AES

开放接口的安全验证方案(AES+RSA) 随着密码分析技术的提高,新的数据加密标准AES取代了过时的DES。文章在阐述AES/RSA加密算法的基础上,分别给出了利用AES/RSA实现客户端/服务器端网络数据传输的加密流程。最后在比较AES算法和RSA算法基础上,将AES与RSA相结合提出一种新的数据加密方案。基本需求及概念随着Internet网的广泛应用,信息安全问题日益突出,以数据加密技术为核心的信息安全技术也得到了极大的发展。目前的数据 阅读详情

转载:http://blog.youkuaiyun.com/chay_chan/article/details/58605605

源码:https://github.com/Javen205/IJPay

数据传输加密

  在开发应用过程中,客户端与服务端经常需要进行数据传输,涉及到重要隐私信息时,开发者自然会想到对其进行加密,即使传输过程中被“有心人”截取,也不会将信息泄露。对于加密算法,相信不少开发者也有所耳闻,比如MD5加密,Base64加密,DES加密,AES加密,RSA加密等等。在这里我主要向大家介绍一下我在开发过程中使用到的加密算法,RSA加密算法+AES加密算法。简单地介绍一下这两种算法吧。

RSA

  之所以叫RSA算法,是因为算法的三位发明者RSA是目前最有影响力的公钥加密算法,它能够抵抗到目前为止已知的绝大多数密码攻击,已被ISO推荐为公钥数据加密标准,主要的算法原理就不多加介绍,如果对此感兴趣的话,建议去百度一下RSA算法。需要了解的是RSA算法属于非对称加密算法,非对称加密算法需要两个密钥:公开密钥(publickey)和私有密钥(privatekey)。公开密钥与私有密钥是一对,如果用公开密钥对数据进行加密,只有用对应的私有密钥才能解密;如果用私有密钥对数据进行加密,那么只有用对应的公开密钥才能解密。因为加密和解密使用的是两个不同的密钥,所以这种算法叫作非对称加密算法。简单的说是“公钥加密,私钥解密;私钥加密,公钥解密”。

AES

  高级加密标准(英语:Advanced Encryption Standard,缩写:AES),在密码学中又称Rijndael加密法,是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES,已经被多方分析且广为全世界所使用。经过五年的甄选流程,高级加密标准由美国国家标准与技术研究院(NIST)于2001年11月26日发布于FIPS PUB 197,并在2002年5月26日成为有效的标准。2006年,高级加密标准已然成为对称密钥加密中最流行的算法之一。

为什么要结合使用这两种算法

  如果不清楚非对称算法和对称算法,也许你会问,为什么要结合使用这两种算法,单纯使用一种算法不行吗?这就要结合不同的场景和需求了。

客户端传输重要信息给服务端,服务端返回的信息不需加密的情况

  客户端传输重要信息给服务端,服务端返回的信息不需加密,例如绑定银行卡的时候,需要传递用户的银行卡号,手机号等重要信息,客户端这边就需要对这些重要信息进行加密,使用RSA公钥加密,服务端使用RSA解密,然后返回一些普通信息,比如状态码code,提示信息msg,提示操作是成功还是失败。这种场景下,仅仅使用RSA加密是可以的。

客户端传输重要信息给服务端,服务端返回的信息需加密的情况

  客户端传输重要信息给服务端,服务端返回的信息需加密,例如客户端登录的时候,传递用户名和密码等资料,需要进行加密,服务端验证登录信息后,返回令牌token需要进行加密,客户端解密后保存。此时就需要结合这两种算法了。至于整个流程是怎样的,在下面会慢慢通过例子向你介绍,因为如果一开始就这么多文字类的操作,可能会让读者感到一头雾水。

源码

public class RSAUtils { 

    /** RSA最大加密明文大小 */ 
    private static final int MAX_ENCRYPT_BLOCK = 117;

    /** RSA最大解密密文大小 */ 
    private static final int MAX_DECRYPT_BLOCK = 128;

    /** 加密算法RSA */ 
    private static final String KEY_ALGORITHM = "RSA";

    /** 
     * 生成公钥和私钥 
     *  
     * @throws Exception 
     *  
     */ 
    public static Map<String, String>  getKeys() throws Exception {
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
        keyPairGen.initialize(1024);
        KeyPair keyPair = keyPairGen.generateKeyPair();
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();

        String publicKeyStr = getPublicKeyStr(publicKey);
        String privateKeyStr = getPrivateKeyStr(privateKey);

        Map<String, String> map = new HashMap<String, String>();
        map.put("publicKey", publicKeyStr);
        map.put("privateKey", privateKeyStr);

        System.out.println("公钥\r\n" + publicKeyStr);
        System.out.println("私钥\r\n" + privateKeyStr);
        return map;
    } 

    /** 
     * 使用模和指数生成RSA公钥 
     * 注意:【此代码用了默认补位方式,为RSA/None/PKCS1Padding,不同JDK默认的补位方式可能不同,如Android默认是RSA 
     * /None/NoPadding】 
     *  
     * @param modulus 
     *            模 
     * @param exponent 
     *            公钥指数 
     * @return 
     */ 
    public static RSAPublicKey getPublicKey(String modulus, String exponent) {
        try { 
            BigInteger b1 = new BigInteger(modulus);
            BigInteger b2 = new BigInteger(exponent);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            RSAPublicKeySpec keySpec = new RSAPublicKeySpec(b1, b2);
            return (RSAPublicKey) keyFactory.generatePublic(keySpec);
        } catch (Exception e) {
            e.printStackTrace();
            return null; 
        } 
    } 

    /** 
     * 使用模和指数生成RSA私钥 
     * 注意:【此代码用了默认补位方式,为RSA/None/PKCS1Padding,不同JDK默认的补位方式可能不同,如Android默认是RSA 
     * /None/NoPadding】 
     *  
     * @param modulus 
     *            模 
     * @param exponent 
     *            指数 
     * @return 
     */ 
    public static RSAPrivateKey getPrivateKey(String modulus, String exponent) {
        try { 
            BigInteger b1 = new BigInteger(modulus);
            BigInteger b2 = new BigInteger(exponent);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(b1, b2);
            return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);
        } catch (Exception e) {
            e.printStackTrace();
            return null; 
        } 
    } 

    /** 
     * 公钥加密 
     * @param data 
     * @param publicKey 
     * @return 
     * @throws Exception 
     */ 
    public static String encryptByPublicKey(String data,String publicKey) throws Exception {
        byte[] dataByte = data.getBytes();
        byte[] keyBytes = Base64Utils.decode(publicKey);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key publicK = keyFactory.generatePublic(x509KeySpec);
        // 对数据加密 
        // Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm()); 
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
        cipher.init(Cipher.ENCRYPT_MODE, publicK);
        int inputLen = dataByte.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段加密 
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                cache = cipher.doFinal(dataByte, offSet, MAX_ENCRYPT_BLOCK);
            } else { 
                cache = cipher.doFinal(dataByte, offSet, inputLen - offSet);
            } 
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_ENCRYPT_BLOCK;
        } 
        byte[] encryptedData = out.toByteArray();
        out.close();
        return Base64Utils.encode(encryptedData);
    } 

    /** 
     * 私钥解密 
     *  
     * @param data 
     * @return 
     * @throws Exception 
     */ 
    public static String decryptByPrivateKey(String data,String privateKey) throws Exception {
        byte[] encryptedData = Base64Utils.decode(data);
        byte[] keyBytes = Base64Utils.decode(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        // Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm()); 
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");

        cipher.init(Cipher.DECRYPT_MODE, privateK);
        int inputLen = encryptedData.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段解密 
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                cache = cipher
                        .doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
            } else { 
                cache = cipher
                        .doFinal(encryptedData, offSet, inputLen - offSet);
            } 
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_DECRYPT_BLOCK;
        } 
        byte[] decryptedData = out.toByteArray();
        out.close();
        return new String(decryptedData);
    } 

    /** 
     * 获取模数和密钥 
     *  
     * @return 
     */ 
    public static Map<String, String> getModulusAndKeys() {

        Map<String, String> map = new HashMap<String, String>();

        try { 
            InputStream in = RSAUtils.class
                    .getResourceAsStream("/rsa.properties");
            Properties prop = new Properties();
            prop.load(in);

            String modulus = prop.getProperty("modulus");
            String publicKey = prop.getProperty("publicKey");
            String privateKey = prop.getProperty("privateKey");

            in.close();

            map.put("modulus", modulus);
            map.put("publicKey", publicKey);
            map.put("privateKey", privateKey);

        } catch (IOException e) {
            e.printStackTrace();
        } 

        return map;
    } 

    /** 
     * 从字符串中加载公钥 
     *  
     * @param publicKeyStr 
     *            公钥数据字符串 
     * @throws Exception 
     *             加载公钥时产生的异常 
     */ 
    public static PublicKey loadPublicKey(String publicKeyStr) throws Exception {
        try { 
            byte[] buffer = Base64Utils.decode(publicKeyStr);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);
            return (RSAPublicKey) keyFactory.generatePublic(keySpec);
        } catch (NoSuchAlgorithmException e) {
            throw new Exception("无此算法");
        } catch (InvalidKeySpecException e) {
            throw new Exception("公钥非法");
        } catch (NullPointerException e) {
            throw new Exception("公钥数据为空");
        } 
    } 

    /** 
     * 从字符串中加载私钥<br> 
     * 加载时使用的是PKCS8EncodedKeySpec(PKCS#8编码的Key指令)。 
     *  
     * @param privateKeyStr 
     * @return 
     * @throws Exception 
     */ 
    public static PrivateKey loadPrivateKey(String privateKeyStr)
            throws Exception {
        try { 
            byte[] buffer = Base64Utils.decode(privateKeyStr);
            // X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer); 
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(buffer);
            KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
            return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);
        } catch (NoSuchAlgorithmException e) {
            throw new Exception("无此算法");
        } catch (InvalidKeySpecException e) {
            throw new Exception("私钥非法");
        } catch (NullPointerException e) {
            throw new Exception("私钥数据为空");
        } 
    } 

    public static String getPrivateKeyStr(PrivateKey privateKey)
            throws Exception {
        return new String(Base64Utils.encode(privateKey.getEncoded()));
    } 

    public static String getPublicKeyStr(PublicKey publicKey) throws Exception {
        return new String(Base64Utils.encode(publicKey.getEncoded()));
    } 

    public static void main(String[] args) throws Exception {
        Map<String, String> keys = getKeys();
        String publicKey = keys.get("publicKey");
        String privateKey = keys.get("privateKey");
        String content = "我是Javen,I am Javen";
        String encrypt = encryptByPublicKey(content, publicKey);
        String decrypt = decryptByPrivateKey(encrypt, privateKey);
        System.out.println("加密之后:"+encrypt);
        System.out.println("解密之后:"+decrypt);
    } 
} 
/** 
 * AES工具类,密钥必须是16位字符串 
 */ 
public class AESUtils { 

    /**偏移量,必须是16位字符串*/ 
    private static final String IV_STRING = "16-Bytes--String";

    /** 
     * 默认的密钥 
     */ 
    public static final String DEFAULT_KEY = "1bd83b249a414036";

    /** 
     * 产生随机密钥(这里产生密钥必须是16位) 
     */ 
    public static String generateKey() {
        String key = UUID.randomUUID().toString();
        key = key.replace("-", "").substring(0, 16);// 替换掉-号
        return key;
    } 

    public static String encryptData(String key, String content) {
        byte[] encryptedBytes = new byte[0];
        try { 
            byte[] byteContent = content.getBytes("UTF-8");
            // 注意,为了能与 iOS 统一 
            // 这里的 key 不可以使用 KeyGenerator、SecureRandom、SecretKey 生成 
            byte[] enCodeFormat = key.getBytes();
            SecretKeySpec secretKeySpec = new SecretKeySpec(enCodeFormat, "AES");
            byte[] initParam = IV_STRING.getBytes();
            IvParameterSpec ivParameterSpec = new IvParameterSpec(initParam);
            // 指定加密的算法、工作模式和填充方式 
            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
            cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec, ivParameterSpec);
            encryptedBytes = cipher.doFinal(byteContent);
            // 同样对加密后数据进行 base64 编码 
//            return Base64.encodeBase64String(encryptedBytes); 
            return Base64Utils.encode(encryptedBytes);
        } catch (Exception e) {
            e.printStackTrace();
        } 
        return null; 
    } 

    public static String decryptData(String key, String content) {
        try { 
            // base64 解码 
            byte[] encryptedBytes = Base64Utils.decode(content);
//            byte[] encryptedBytes = Base64.decodeBase64(content); 
            byte[] enCodeFormat = key.getBytes();
            SecretKeySpec secretKey = new SecretKeySpec(enCodeFormat, "AES");
            byte[] initParam = IV_STRING.getBytes();
            IvParameterSpec ivParameterSpec = new IvParameterSpec(initParam);
            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
            cipher.init(Cipher.DECRYPT_MODE, secretKey, ivParameterSpec);
            byte[] result = cipher.doFinal(encryptedBytes);
            return new String(result, "UTF-8");
        } catch (Exception e) {
            e.printStackTrace();
        } 
        return null; 
    } 

    public static void main(String[] args) {
        try { 

            Map<String, String> keys = RSAUtils.getKeys();
            String publicKey = keys.get("publicKey");
            String privateKey = keys.get("privateKey");

            String key = generateKey();
            System.out.println("aes密钥:"+key);
            String plainText = "I am Javen -By 我是Javen";
            plainText = encryptData(key, plainText);
            System.out.println("aes加密后: " + plainText );
            plainText = decryptData(key, plainText);
            System.out.println("aes解密后: " + plainText );
            String encrypt = RSAUtils.encryptByPublicKey(key,publicKey);
            System.out.println("RSA加密:"+encrypt);
            System.out.println("RSA解密:"+RSAUtils.decryptByPrivateKey(encrypt,privateKey));
        } catch (Exception e) {
            e.printStackTrace();
        } 
    } 

} 
/** */ 
/** 
 * <p> 
 * BASE64编码解码工具包 
 * </p> 
 * <p> 
 * 依赖javabase64-1.3.1.jar 
 * </p> 
 */ 
public class Base64Utils { 

    /** */ 
    /** 
     * 文件读取缓冲区大小 
     */ 
    private static final int CACHE_SIZE = 1024;

    /** */ 
    /** 
     * <p> 
     * BASE64字符串解码为二进制数据 
     * </p> 
     *  
     * @param base64 
     * @return 
     * @throws Exception 
     */ 
    public static byte[] decode(String base64) throws Exception {
        return Base64.decode(base64.getBytes());
    } 

    public static String decode(byte[] b) {
        return new String(Base64.decode(b));
    } 

    /** */ 
    /** 
     * <p> 
     * 二进制数据编码为BASE64字符串 
     * </p> 
     *  
     * @param bytes 
     * @return 
     * @throws Exception 
     */ 
    public static String encode(byte[] bytes) throws Exception {
        return new String(Base64.encode(bytes));
    } 

    /** */ 
    /** 
     * <p> 
     * 将文件编码为BASE64字符串 
     * </p> 
     * <p> 
     * 大文件慎用,可能会导致内存溢出 
     * </p> 
     *  
     * @param filePath 
     *            文件绝对路径 
     * @return 
     * @throws Exception 
     */ 
    public static String encodeFile(String filePath) throws Exception {
        byte[] bytes = fileToByte(filePath);
        return encode(bytes);
    } 

    /** */ 
    /** 
     * <p> 
     * BASE64字符串转回文件 
     * </p> 
     *  
     * @param filePath 
     *            文件绝对路径 
     * @param base64 
     *            编码字符串 
     * @throws Exception 
     */ 
    public static void decodeToFile(String filePath, String base64)
            throws Exception {
        byte[] bytes = decode(base64);
        byteArrayToFile(bytes, filePath);
    } 

    /** */ 
    /** 
     * <p> 
     * 文件转换为二进制数组 
     * </p> 
     *  
     * @param filePath 
     *            文件路径 
     * @return 
     * @throws Exception 
     */ 
    public static byte[] fileToByte(String filePath) throws Exception {
        byte[] data = new byte[0];
        File file = new File(filePath);
        if (file.exists()) {
            FileInputStream in = new FileInputStream(file);
            ByteArrayOutputStream out = new ByteArrayOutputStream(2048);
            byte[] cache = new byte[CACHE_SIZE];
            int nRead = 0;
            while ((nRead = in.read(cache)) != -1) {
                out.write(cache, 0, nRead);
                out.flush();
            } 
            out.close();
            in.close();
            data = out.toByteArray();
        } 
        return data;
    } 

    /** */ 
    /** 
     * <p> 
     * 二进制数据写文件 
     * </p> 
     *  
     * @param bytes 
     *            二进制数据 
     * @param filePath 
     *            文件生成目录 
     */ 
    public static void byteArrayToFile(byte[] bytes, String filePath)
            throws Exception {
        InputStream in = new ByteArrayInputStream(bytes);
        File destFile = new File(filePath);
        if (!destFile.getParentFile().exists()) {
            destFile.getParentFile().mkdirs();
        } 
        destFile.createNewFile();
        OutputStream out = new FileOutputStream(destFile);
        byte[] cache = new byte[CACHE_SIZE];
        int nRead = 0;
        while ((nRead = in.read(cache)) != -1) {
            out.write(cache, 0, nRead);
            out.flush();
        } 
        out.close();
        in.close();
    } 

} 
/** 
 * des加密、解密 
 */ 
public class DESUtils { 

    // 指定DES加密解密所用的密钥 
    private static Key key;

    /** 
     * 加密key为空, 默认为类名 
     */ 
    public DESUtils() { 
        setkey(this.getClass().getName());
    } 

    /** 
     * 设置加密key 
     *  
     * @param keyStr 
     *            加密key值 
     */ 
    public DESUtils(String keyStr) {
        setkey(keyStr);
    } 

    /** 
     * 设置加密的校验码 
     */ 
    private void setkey(String keyStr) {
        try { 
            // L.cm 2015-01-20 将加密的密匙Base64 
            // fix Caused by: java.security.InvalidKeyException: Wrong key size 
            String desKey = Base64.encodeBase64String(keyStr.getBytes("UTF-8"));
            DESKeySpec objDesKeySpec = new DESKeySpec(desKey.getBytes("UTF-8"));
            SecretKeyFactory objKeyFactory = SecretKeyFactory.getInstance("DES");
            key = objKeyFactory.generateSecret(objDesKeySpec);
        } catch (Exception e) {
            throw new RuntimeException(e);
        } 
    } 

    /** 
     * 对字符串进行DES加密,返回BASE64编码的加密字符串 
     * @param str 
     * @return 
     */ 
    public final String encryptString(String str) {
        byte[] bytes = str.getBytes();
        try { 
            Cipher cipher = Cipher.getInstance("DES");
            cipher.init(Cipher.ENCRYPT_MODE, key);
            byte[] encryptStrBytes = cipher.doFinal(bytes);
            return Base64.encodeBase64URLSafeString(encryptStrBytes);
        } catch (Exception e) {
            throw new RuntimeException(e);
        } 
    } 

    /** 
     * 对BASE64编码的加密字符串进行解密,返回解密后的字符串 
     * @param str 
     * @return 
     */ 
    public final String decryptString(String str) {
        try { 
            byte[] bytes = Base64.decodeBase64(str);
            Cipher cipher = Cipher.getInstance("DES");
            cipher.init(Cipher.DECRYPT_MODE, key);
            bytes = cipher.doFinal(bytes);
            return new String(bytes);
        } catch (Exception e) {
            throw new RuntimeException(e);
        } 
    } 

    public static void main(String[] args) {
        String keyStr="9cc9b11a7a0747d4b19d30a324a84dc5";
        System.out.println("keyStr:"+keyStr);
        DESUtils desUtils=new DESUtils(keyStr);
        String sourceStr="12345678";
        System.out.println("加密前的Str:"+sourceStr);
        String encryptString = desUtils.encryptString(sourceStr);
        System.out.println("加密之后:"+encryptString);
         String decryptString = desUtils.decryptString(encryptString);
        System.out.println("解密之后:"+decryptString);
    } 
} 
PHP语言的加密算法 加密是将明文信息转变为不可识别的密文信息的过程。在这一过程中,只有拥有特定密钥的人才能将密文还原为明文。加密的主要目的是保护信息的机密性和完整性。 阅读详情

相关推荐

web前端常见的加密算法介绍

在信息安全越来越受重视的今天,前端的各种加密也变得更加重要。通常跟服务器的交互中,为保障数据传输的安全性,避免被人抓包篡改数据,除了 https 的应用,还需要对传输数据进行加解密。目前常见的加密算法可以分成三类对称加密算法:AES、...非对称加密算法:RSA、...Hash 算法:MD5、...在业务 http 请求中,AES 的密钥在前端随机生成,从服务器获取 RSA 的公钥,对 AES 的密钥进行非对称加密,把加密后的密钥在请求头中传给服务器,用 AES 对 body 进行加密。

m0_68271787的博客 1736

RSA+AES 混合加密

非对称加密,使用公钥和私钥加密和解密,加密速度慢。

qq798280904的博客 4099

论文分享|ECCV2022,PATnet,Cross-Domain Few-Shot Semantic Segmentation,CDFSS新基准,文末有复现教程

这篇论文提出的跨域小样本语义分割(CD-FSS)任务,旨在将源域学习的分割能力迁移到目标域,仅需少量标注样本。针对传统小样本分割方法在跨域场景性能下降的问题,作者提出了基于金字塔锚点变换的网络(PATNet),通过将域相关特征转换为域无关特征,并引入任务自适应微调推理(TFI)提升目标域适应能力。实验表明,PATNet在1-shot和5-shot设置下分别比现有方法提升8.49%和10.61%的准确率。同时,作者构建了CD-FSS基准并设计了任务难度评估指标。代码和数据集已开源,复现难度中等。

m0_74277350的博客 1098

RSA+AES实现混合加密

RSA+AES实现混合加密

wzw_wwl的博客 9100

手把手教你用Docker快速部署ZLMediaKit流媒体服务器(含WebRTC配置)

本文详细介绍了如何使用Docker快速部署ZLMediaKit流媒体服务器,并配置WebRTC功能。通过容器化部署,实现环境一致性、资源隔离和快速扩展,同时提供WebRTC专项配置、多协议推拉流实战测试及生产环境优化建议,帮助开发者高效搭建企业级流媒体平台。

agile9scrum的博客 204

MediaPipe实战:从零构建人脸关键点检测应用

本文详细介绍了如何使用Google的MediaPipe框架从零构建一个实时人脸关键点检测应用。文章深入剖析了MediaPipe的三段式检测流水线,提供了Android平台的完整实战教程,包括环境配置、模型加载、摄像头集成、关键点绘制以及性能调优指南,帮助开发者快速实现高效、跨平台的人脸AR特效与交互功能。

weixin_29100927的博客 346

RSA + AES加密原理,一线大厂主流的加密手段,流程浅析,有十分详细的测试Demo

既利用了 RSA 的灵活性,可以随时改动 AES 的密钥;又利用了 AES 的高效性,可以高效传输数据。

Java Punk 2万+

手机OIS马达拆解:从苹果的悬丝到三星的滚珠,不同方案如何影响你的拍照体验?

本文深度解析手机OIS马达技术,对比苹果悬丝式、三星滚珠式和LG记忆合金式三种主流方案的机械原理与成像体验差异。通过详实的数据和测试结果,揭示不同OIS技术如何影响防抖性能、模组厚度及长期可靠性,为摄影爱好者和技术爱好者提供实用选购建议。

weixin_42554408的博客 310

数据传输加密——非对称加密算法RSA+对称算法AES(适用于java,android和Web)

转载请注明出处:http://blog.youkuaiyun.com/chay_chan/article/details/58605605 数据传输加密   在开发应用过程中,客户端与服务端经常需要进行数据传输,涉及到重要隐私信息时,开发者自然会想到对其进行加密,即使传输过程中被“有心人”截取,也不会将信息泄露。对于加密算法,相信不少开发者也有所耳闻,比如MD5加密,Base64加密,DES加密,

zengdejie123的博客 1154

扫地机器人视觉+IMU融合导航路径规划技术详解

本文介绍了基于视觉-惯性里程计(VIO)的扫地机器人自主导航系统。系统硬件由RGB摄像头、IMU传感器和编码器组成,软件架构采用分层设计,包括传感器数据采集层、数据融合层、SLAM定位层和路径规划层。核心技术包括:1)融合视觉特征提取(ORB算法)与IMU预积分的VIO;2)基于栅格地图的SLAM构建;3)结合A*全局规划和动态窗口法(DWA)局部避障的路径规划。文章提供了完整的Python实现代码,涵盖传感器数据融合、特征匹配和运动估计等关键功能模块。该系统实现了扫地机器人的精准定位和环境感知能力。

电脑管家 1469

【UG/NX二次开发】记录在二次开发中遇到的坑

【UG/NX二次开发】记录在二次开发中遇到的坑

Trust_MJ的博客 2709

数据传输加密:RSA+AES

首先:我们先了解一下什么是RSA和AES 1、什么是RSA? 2、什么是AES? 通过上面,我们了解到。AES是目前主流的对称加密算法,而RSA是非对称加密算法。 什么是对称算法AES? 对称算法:请求发起方与接收方拥有相同的密钥。 发起流程: 1、请求方用密钥加密密文,发送给接收方。 2、接收方用密钥对密文进行解密。 问题:一旦密钥被坏人知道,密文的安全性将得不到保证。 什么...

weixin_37765511的博客 1044

真随机数与伪随机数

前面我们学习了LFSR,这个玩意落地到具体的应用是什么呢?没错是寄存器,这里在网络找到了几个回答,这里做个记录,下面一起来学习一下吧。

叫好与叫座虽然不是对立面,但想在同一个作品中达到双重效果很难。 1063

Scala语言的加密算法

加密算法是一种将明文转换为密文的算法,其目的是保障数据的机密性和完整性。加密算法通常分为两大类:对称加密和非对称加密。本文介绍了Scala语言中加密算法的基本概念、实现方法以及应用场景。通过使用Java的Cipher类和Bouncy Castle库,我们展示了如何在Scala中实现对称加密(AES)和非对称加密(RSA)。随着数据安全要求的不断提升,加密算法将在未来继续发挥更加重要的作用。在实际开发中,选择适当的加密算法并正确实施是保障数据安全的关键。

2501_91502884的博客 536

推荐11个顶级的Claude Code Skills

ClaudeCode的Skills系统为程序员提供了11个强大的AI辅助工具,包括代码审查、重构建议、单元测试生成、API文档自动生成、性能分析、安全扫描、数据库迁移脚本生成、CI/CD配置、依赖管理、ER图生成和日志分析等功能。这些"技能包"可大幅提升开发效率,从代码质量到协作沟通全方位优化工作流程。用户可根据需求选择2-3个核心功能开始尝试,熟练后还可自定义Skills。该系统需要配合Anthropic的API使用,建议先在小型项目测试再应用于核心业务。

分享AI、区块链技术及应用,未来已来 1859

霍尼韦尔SoftMaster使用说明

霍尼韦尔SoftMaster使用说明

安全功能,加密相关,密码杂凑函数(aes,rsa,ECC , sha1,sha256,md5,HMAC)

Vault HashiCorp Vault是一个私密信息管理工具(A tool for managing secrets),提供键值的方式保存私密信息。 vault - 安装及启动 https://blog.youkuaiyun.com/zrk1000/article/details/72670037 数据传输加密:RSA+AES https://www.jianshu.com/p/1de40d21...............

sun007700的专栏 5103

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

浅谈基本加密算法以及使用

1.加密算法 (1)对称加密算法 对称加密算法中,加密用的密钥和解密用的密钥是一样的,也就是说,加密和解密使用同一个密钥,密钥的保存和安全交换是一个问题。对称加密算法有DES(data encryption standard)数据加密标准,3DES(DESede),AES(Advanced encryption standard)高级加密标准。 (2)单向加密算法 MD4,MD5,SHA192,SHA256,SHA512单向的不可逆的摘要算法,用于验证数据的完整性。摘要算法的输出是固定的,192,256指的

EEEEEEcho的博客 1203

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

数据传输混合加密

方案说明1.        数据传输过程中需要用可逆加密算法,对数据进行加密和解密,可逆加密算法有对称加密和非对称加密;2.        对称加密,加密与解密使用的是同样的密钥,所以速度快,但由于需要将密钥在网络传输,所以安全性不高;3.        非对称加密使用了一对密钥,公钥与私钥,所以安全性高,但加密与解密速度慢;4.        解决的办法是将对称加密的密钥使用非对称加密的公钥进行...

erdongritian的专栏 1147

加密算法

数据传输加密  在开发应用过程中,客户端与服务端经常需要进行数据传输,涉及到重要隐私信息时,开发者自然会想到对其进行加密,即使传输过程中被“有心人”截取,也不会将信息泄露。对于加密算法,相信不少开发者也有所耳闻,比如MD5加密,Base64加密,DES加密,AES加密,RSA加密等等。在这里我主要向大家介绍一下我在开发过程中使用到的加密算法,RSA加密算法+AES加密算法。简单地介绍一下这两种算法吧

晴小天 1561

加密算法用途,特点,场景举例

简述了算法的用途,算法分类,算法特点,使用场景,使用举例

qq_44845473的博客 1165

常用加密算法整理

AES 高级加密标准(AES,Advanced Encryption Standard)为最常见的对称加密算法(微信小程序加密传输就是用这个加密算法的)。对称加密算法也就是加密和解密用相同的密钥,具体的加密流程如下图: RSA RSA 加密算法是一种典型的非对称加密算法,它基于大数的因式分解数学难题,它也是应用最广泛的非对称加密算法。非对称加密是通过两个密钥(公钥-私钥)来实现对数据的加密和解密的。公钥用于加密,私钥用于解密: RSA: CRC: 循环冗余校验(Cyclic...

qq_28403781的博客 613

【加密算法】RSA和AES在项目中的使用

除了客户端发送信息要加密外,服务端返回数据也要加密。客户端要解密必须使用私钥,如果只使用RSA加密解密,那么私钥就要保存在客户端,很容易泄密。密码不能明文传输,所有要在客户端对密码加密,在服务端对密码进行解密。客户端用公钥加密,在服务端用私钥解密。AES:高级加密标准(Advanced Encryption Standard)为最常见的对称加密算法(微信小程序加密传输就是用这个加密算法的)。注:就算截取了加密后的key也没有用,因为没有RSA私钥,无法解密。通过key用AES加密数据,并返回给客户端。

心生的小鱼专栏 1857
上一篇: 图解HTTPS
下一篇: IDE中显示 *.properties 为中文
酷玩时刻
酷玩时刻 领域专家: 操作系统技术领域 领域专家: 操作系统技术领域
博客等级 码龄15年 842粉丝 97原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值