客户端安全传输密码至服务端的实现改进

最新推荐文章于 2024-01-30 11:26:04 发布
最新推荐文章于 2024-01-30 11:26:04 发布
阅读量419 收藏 3
点赞数 1
文章标签： 测试 java 前端 ViewUI
原文链接：http://www.cnblogs.com/linjisong/p/8748683.html
版权

两年前在做Java EE开发平台时，因为用户登录相关的模块是委托给另一位同事完成的，所以虽然知道大体概念，但是对客户端怎么安全传输密码到服务端的具体细节并不甚了解。然而这次在做4A系统（认证、授权、监控、审计）时，无论怎样都绕不过这一块内容了，于是在仔细研究了一下之前的方案，并参考网上的一些资料后，做了一些改进，特此记录一下。

总体方案

  1. 服务端生成RSA密钥对，并将公钥返回给客户端
  2. 客户端在提交登录时，将密码使用公钥加密，传输给服务端
  3. 服务端收到登录请求后，使用私钥解密，并进行下一步处理

方案很简单，也很容易理解，只需要知道非对称加密的一般概念即可，但是在具体的实现时还是有一些细节需要注意的。

原有的实现（实际上同事也是参考了网上的资料）

  1. 创建一个表BF_KEY_CFG（module，public_empoent，private_empoent VARCHAR(200)）
    这里需要对RSA的具体实现有一点点了解，知道模、公钥指数、私钥指数等概念。
  2. 引入加密工具包bouncycastle-1.0.jar，在系统每次启动的时候，利用该工具包生成密钥对（模、公钥指数、私钥指数）并保存到数据库
  3. 在客户端提交登录时，先从服务器获取公钥，然后再加密发送登录请求
  4. 服务端在进行密码验证前，先用私钥解密，然后再进行其他认证处理

这个实现有几个问题：

  1. 创建的表包含三个字段（模、公钥指数、私钥指数）并不那么容易理解，不像公钥、私钥那么大众化
  2. 需要额外引入第三方包
  3. 多个服务端节点时，启动时会有潜在的冲突
  4. 使用的JS加密算法，在服务端解密时，出现顺序颠倒的问题，因此也不能很好的处理中文等字符
  5. 在提交登录时，是重写了原来的密码表单域的值，导致不能记住密码（每次加密的公钥不相同）
  6. 在服务端，也不能很好的利用Spring MVC的表单校验，比如需要自己单独写逻辑判断密码长度不能大于16等

此外，网上的资料大都是你抄我、我抄你，一些基本的工具类代码都很丑陋，到处充斥着重复的代码。

改进后的实现

改进主要是针对上面提到的问题进行的。

  1. 首先，表字段只保留PUBLIC_KEY、PRIVATE_KEY
  2. 其次，使用JDK原生的加密provider
  3. 解决JS和JAVA加解密顺序颠倒的问题，从而也解决了中文加密问题
  4. 在前端设置一个隐藏域，提交登录表单时，先将隐藏域的值设置为加密后的密码，然后将密码域设置为disable（从而不会传送至后台），最后再提交登录表单，如果登录失败，重新返回登录页时，再启用密码域，这样可以解决记住密码，回退到登录页等许多问题
  5. 在Spring MVC绑定参数后，进行参数校验前，进行解密，从而可以利用Spring MVC的原生校验

这几个改进，前端使用JSEncrypt库配合jQuery非常容易实现，而我们是使用EasyUI，主要代码如下：

$form.form('submit', {
            url : '/login',
            onSubmit : function(param) {
                var isValid = $(this).form('validate');
                if (isValid) {
                    var value = $password.passwordbox('getValue');
                    $password.passwordbox('disable');
                    param.password = JSEncrypt.encrypt(value);
                    $.messager.progress(); // 显示进度条
                }
                return isValid; // 返回false终止表单提交
            },
            success : function(msg) {
                $password.passwordbox('enable');
                $.messager.progress('close'); // 如果提交成功则隐藏进度条
                var data = eval('(' + msg + ')');
                if (data.success){ 
                    if(data.data){
                        $consts.token.value = data.data.token || '';
                    }
                    // 加载主页面
                    require(['text!base/frame/main.html'], function(content) {
                        var $body = $('body');

                        $body.html(content);
                        $.parser.parse($body);
                    })  
                } else {
                    
                    $.messager.alert('登录提示','error','error');  
                }  
            }
        });

后端则主要包括两个部分：加密工具类、Spring MVC参数绑定后和参数校验前的处理逻辑插入

（1）加密工具类：

import java.security.NoSuchAlgorithmException;
import java.security.Provider;
import java.security.SecureRandom;

import javax.crypto.Cipher;
import javax.crypto.NoSuchPaddingException;

import org.springframework.util.Base64Utils;//在JDK8中可以直接使用JDK原生Base64工具类

/* package */ class CryptoUtils {

    protected static final SecureRandom random = new SecureRandom();

    /**
     * 获取Provider对象：注意单例
     * 
     * 方便使用其它的Provider
     * @return
     */
    protected static Provider getProvider() {
        return null;//provider;
    }

    /**
     * 字节转换为字符串
     * 
     * @param data
     * @return
     */
    protected static String encodeToString(byte[] data) {
        return Base64Utils.encodeToString(data);
    }

    /**
     * 字符串转换为字节
     * 
     * @param src
     * @return
     */
    protected static byte[] decodeFromString(String src) {
        return Base64Utils.decodeFromString(src);
    }

    /**
     * 获取Cipher对象
     * 
     * @param keyAlgorithm
     * @return
     */
    protected static Cipher getCipher(String keyAlgorithm) {
        try {
            Provider provider = getProvider();
            Cipher cipher = null;
            if (null == provider) {
                cipher = Cipher.getInstance(keyAlgorithm);
            } else {
                cipher = Cipher.getInstance(keyAlgorithm, provider);
            }
            return cipher;
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException(e);
        } catch (NoSuchPaddingException e) {
            throw new RuntimeException(e);
        }
    }
}
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.Serializable;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.Provider;
import java.security.PublicKey;
import java.security.Signature;
import java.security.SignatureException;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;

public class RSAUtils extends CryptoUtils {

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

    /**
     * 生成RSA密钥对
     */
    public static RsaKeyPair getRsaKeyPair() {
        try {
            KeyPairGenerator keyPairGen = null;
            Provider provider = getProvider();
            if (null == provider) {
                keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
            } else {
                keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM, provider);
            }
            keyPairGen.initialize(1024, random);
            KeyPair keyPair = keyPairGen.generateKeyPair();
            String privateKey = encodeToString(keyPair.getPrivate().getEncoded());
            String publicKey = encodeToString(keyPair.getPublic().getEncoded());
            return new RsaKeyPair(publicKey, privateKey);
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 获取公钥
     * 
     * @param publicKey
     * @return
     */
    public static PublicKey getPublicKey(String publicKey) {
        try {
            byte[] bytes = decodeFromString(publicKey);
            X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(bytes);
            PublicKey pk = getKeyFactory().generatePublic(x509KeySpec);
            return pk;
        } catch (InvalidKeySpecException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 获取私钥
     * 
     * @param privateKey
     * @return
     */
    public static PrivateKey getPrivateKey(String privateKey) {
        try {
            byte[] bytes = decodeFromString(privateKey);
            PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(bytes);
            PrivateKey pk = getKeyFactory().generatePrivate(pkcs8KeySpec);
            return pk;
        } catch (InvalidKeySpecException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 公钥加密
     * 
     * @param plainText
     * @param publicKey
     * @return
     */
    public static String encryptByPublicKey(String plainText, String publicKey) {
        Cipher cipher = getCipher(true, publicKey, true);
        byte[] src = plainText.getBytes();
        byte[] datas = cipherData(cipher, src, 117);
        return encodeToString(datas);
    }

    /**
     * 私钥加密
     * 
     * @param plainText
     * @param privateKey
     * @return
     */
    public static String encryptByPrivateKey(String plainText, String privateKey) {
        Cipher cipher = getCipher(true, privateKey, false);
        byte[] src = plainText.getBytes();
        byte[] datas = cipherData(cipher, src, 117);
        return encodeToString(datas);
    }

    /**
     * 公钥解密
     * 
     * @param plainText
     * @param publicKey
     * @return
     */
    public static String decryptByPublicKey(String encryptText, String publicKey) {
        Cipher cipher = getCipher(false, publicKey, true);
        byte[] src = decodeFromString(encryptText);
        byte[] datas = cipherData(cipher, src, 128);
        return new String(datas);
    }

    /**
     * 私钥解密
     * 
     * @param encryptText
     * @param privateKey
     * @return
     */
    public static String decryptByPrivateKey(String encryptText, String privateKey) {
        Cipher cipher = getCipher(false, privateKey, false);
        byte[] src = decodeFromString(encryptText);
        byte[] datas = cipherData(cipher, src, 128);
        return new String(datas);
    }

    /**
     * 获取KeyFactory对象
     * 
     * @return
     */
    private static KeyFactory getKeyFactory() {
        try {
            Provider provider = getProvider();
            if (null == provider) {
                return KeyFactory.getInstance(KEY_ALGORITHM);
            } else {
                return KeyFactory.getInstance(KEY_ALGORITHM, provider);
            }
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 获取Cipher对象
     * 
     * @param encode
     * @param keyString
     * @param isPublicKey
     * @return
     */
    private static Cipher getCipher(boolean encode, String keyString, boolean isPublicKey) {
        try {
            Key key = isPublicKey ? getPublicKey(keyString) : getPrivateKey(keyString);
            Cipher cipher = getCipher(KEY_ALGORITHM);
            cipher.init(encode ? Cipher.ENCRYPT_MODE : Cipher.DECRYPT_MODE, key);
            return cipher;
        } catch (InvalidKeyException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 加解密数据
     * 
     * @param cipher
     * @param src
     * @param blockSize
     * @return
     */
    private static byte[] cipherData(Cipher cipher, byte[] src, int blockSize) {
        ByteArrayOutputStream out = null;
        try {
            int inputLen = src.length;
            out = new ByteArrayOutputStream();
            int offSet = 0;
            byte[] cache;
            int i = 0;
            while (inputLen - offSet > 0) {
                if (inputLen - offSet > blockSize) {
                    cache = cipher.doFinal(src, offSet, blockSize);
                } else {
                    cache = cipher.doFinal(src, offSet, inputLen - offSet);
                }
                out.write(cache, 0, cache.length);
                i++;
                offSet = i * blockSize;
            }
            return out.toByteArray();
        } catch (IllegalBlockSizeException e) {
            throw new RuntimeException(e);
        } catch (BadPaddingException e) {
            throw new RuntimeException(e);
        } finally {
            if (null != out) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * RSA密钥对象
     */
    public static class RsaKeyPair implements Serializable {

        private static final long serialVersionUID = 2130689702406754025L;

        /**
         * 公钥
         */
        private String publicKey;

        /**
         * 私钥
         */
        private String privateKey;

        public RsaKeyPair() {}

        public RsaKeyPair(String publicKey, String privateKey) {
            this.publicKey = publicKey;
            this.privateKey = privateKey;
        }

        public String getPublicKey() {
            return publicKey;
        }

        public void setPublicKey(String publicKey) {
            this.publicKey = publicKey;
        }

        public String getPrivateKey() {
            return privateKey;
        }

        public void setPrivateKey(String privateKey) {
            this.privateKey = privateKey;
        }
    }
}

（2）参数绑定后、校验前的逻辑插入

实际上只要跟踪调试一下，就可以发现关键在于ExtendedServletRequestDataBinder，覆盖两个方法即可：

import javax.servlet.ServletRequest;

import org.springframework.beans.MutablePropertyValues;
import org.springframework.validation.AbstractPropertyBindingResult;
import org.springframework.web.servlet.mvc.method.annotation.ExtendedServletRequestDataBinder;

/* package */ class RelaxedServletRequestDataBinder extends ExtendedServletRequestDataBinder {

    public RelaxedServletRequestDataBinder(Object target) {
        super(target);
    }

    public RelaxedServletRequestDataBinder(Object target, String objectName) {
        super(target, objectName);
    }

    /**
     * 添加属性值提供器的相关处理
     */
    @Override
    protected void addBindValues(MutablePropertyValues mpvs, ServletRequest request) {
        super.addBindValues(mpvs, request);
        PropertyValuesProviders.addBindValues(mpvs, request, getTarget(), getObjectName());
    }

    /**
     * 常规绑定之后的处理
     */
    @Override
    public void bind(ServletRequest request) {
        super.bind(request);
        PropertyValuesProviders.afterBindValues(getPropertyAccessor(), request, getTarget(), getObjectName());
    }

    @Override
    protected AbstractPropertyBindingResult createBeanPropertyBindingResult() {
        return new RelaxedBeanPropertyBindingResult(getTarget(), getObjectName(), isAutoGrowNestedPaths(), getAutoGrowCollectionLimit());
    }
}

这个类只是提供一个入口，真正的逻辑委托给了PropertyValuesProviders处理。在我的实现中，这里提取了一个接口：

import javax.servlet.ServletRequest;

import org.springframework.beans.MutablePropertyValues;
import org.springframework.beans.PropertyAccessor;

public interface IPropertyValuesProvider {//感谢JDK8中的默认实现

    default void addBindValues(MutablePropertyValues mpvs, ServletRequest request, Object target, String name) {};

    default void afterBindValues(PropertyAccessor accessor, ServletRequest request, Object target, String name) {};
}

import java.util.List;

import javax.servlet.ServletRequest;

import org.springframework.beans.MutablePropertyValues;
import org.springframework.beans.PropertyAccessor;
import org.springframework.beans.factory.annotation.Autowired;

public class PropertyValuesProviders {

    private static List<IPropertyValuesProvider> providers;

    @Autowired(required = false)
    public void setProviders(List<IPropertyValuesProvider> providers) {
        if (providers != null) {
            PropertyValuesProviders.providers = providers;
        }
    }

    public static void addBindValues(MutablePropertyValues mpvs, ServletRequest request, Object target, String name) {
        if (null != providers) {
            for (IPropertyValuesProvider provider : providers) {
                provider.addBindValues(mpvs, request, target, name);
            }
        }
    }

    public static void afterBindValues(PropertyAccessor accessor, ServletRequest request, Object target, String name) {
        if (null != providers) {
            for (IPropertyValuesProvider provider : providers) {
                provider.afterBindValues(accessor, request, target, name);
            }
        }
    }
}

然后添加RSA解密的实现：

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import javax.servlet.ServletRequest;

import org.springframework.beans.PropertyAccessor;

import com.autumn.platform.core.crypto.RSAUtils;
import com.autumn.platform.core.crypto.RSAUtils.RsaKeyPair;
import com.autumn.platform.core.logger.Logs;
import com.autumn.platform.web.annotation.RsaDecrypt;

public abstract class AbstractRsaDecryptPropertyValuesProvider implements IPropertyValuesProvider {

    private Map<Class<?>, List<Field>> cache = new ConcurrentHashMap<Class<?>, List<Field>>();

    @Override
    public void afterBindValues(PropertyAccessor accessor, ServletRequest request, Object target, String name) {
        RsaKeyPair pair = this.getRsaKeyPair(accessor, request, target, name);
        if (null == pair) {
            return;
        }
        for (Class<?> cls = target.getClass(); !cls.equals(Object.class); cls = cls.getSuperclass()) {
            List<Field> fields = resolveFields(cls);
            if (null != fields && !fields.isEmpty()) {
                for (Field field : fields) {
                    setDecryptValue(target, pair, field);
                }
            }
        }
    }

    abstract protected RsaKeyPair getRsaKeyPair(PropertyAccessor accessor, ServletRequest request, Object target, String name);

    private void setDecryptValue(Object target, RsaKeyPair pair, Field field) {
        try {
            Object value = field.get(target);
            if (value instanceof String) {
                String text = RSAUtils.decryptByPrivateKey((String) value, pair.getPrivateKey());
                field.set(target, text);
            }
        } catch (Exception e) {
            Logs.error("解密" + field + "的值时出现异常", e);
        }
    }

    private List<Field> resolveFields(Class<?> cls) {
        List<Field> fieldList = cache.get(cls);
        if (null == fieldList) {
            fieldList = new ArrayList<Field>();
            Field[] fields = cls.getDeclaredFields();
            if (null != fields) {
                for (Field field : fields) {
                    if (field.isAnnotationPresent(RsaDecrypt.class)) {
                        if (!field.isAccessible()) {
                            field.setAccessible(true);
                        }
                        fieldList.add(field);
                    }
                }
            }
            if (fieldList.isEmpty()) {
                fieldList = Collections.emptyList();
            }
            cache.put(cls, fieldList);
        }
        return fieldList;
    }
}

其中@RsaDecrypt注解是自定义的，用于表示这个表单字段在接受参数时，需要先使用RSA解密。

转载于:https://www.cnblogs.com/linjisong/p/8748683.html

a540010
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
安全文件传输 客户端
12-25
Linux平台下的安全文件传输系统客户端，无图形界面，线程池处理
安全文件传输客户端
01-09
可建立远程登录会话链接，将本地资源上传至服务器。用于更新服务器资源。
App安全之网络传输安全
weixin_33905756的博客
04-18 1199
移动端App安全如果按CS结构来划分的话，主要涉及客户端本身数据安全，Client到Server网络传输的安全，客户端本身安全又包括代码安全和数据存储安全。所以当我们谈论App安全问题的时候一般来说在以下三类范畴当中。 App代码安全，包括代码混淆，加密或者app加壳。 App数据存储安全，主要指在磁盘做数据持久化的时候所做的加密。 App网络传输安全，指对数据从客户端传输到Server...
使用scp在服务端和客户端之间进行文件安全传输
webmater2320的博客
06-16 482
因为我是想从服务端下载文件，所以： 客户端：Debian 服务端：macOS 首先在
js 服务器用户名密码登录,javascript – Web身份验证 – 如何安全地将用户名/密码从客户端传输到服务器...
weixin_30877689的博客
07-30 461
我有一个我试图启动的Web应用程序(Java).用户需要登录系统才能使用这些功能.所以这个应用程序有两个部分：1)用户注册2)登录我担心的是我将用户名/密码数据从Web浏览器传输到服务器的方法是多么安全.注册由于我不确定如何安全地将数据从Web浏览器发送到服务器,因此我很遗憾.登录我有以下设置：&LT&LT客户>> ————————————————– —-&LT...
网即通unMSG客户端(普及版)
11-07
远程控制自定义获取图像时间间隔，并可以设置密码控制，无需交互即可实现控制 4.增加服务器设置选项 5.兼容飞鸽传书，并可与飞鸽用户进行文字交流 改进： 1.远程控制图像质量速度改进，比先前版本有较大提升，并...
TCP聊天+传输文件服务器服务器套接字v2.6 - 登录注册界面更新 - loading界面应用
06-04
4. 两大堡垒 (客户端与服务端两次堡垒， 防止更改客户端数据直接发送的[`不符合规范的json数据包`], 所以在服务端在识别[`用户是否存在`] + [`账户密码是否正确`]的前提下 又增加了[`检测用户名密码长度`]的规则) ...
基于HTTP协议的服务器程序分析.docx
10-05
实现服务端的登录、密码验证、文件传输等功能；根据实际需要，对服务端程序进行优化和改进。 基于FTP协议的文件传输服务器被广泛应用于以下场景：企业内部文件共享：企业可以通过FTP服务器来共享内部文件，方便员工...
java源码包---java 源码 大量 实例
04-18
util实现Java图片水印添加功能，有添加图片水印和文字水印，可以设置水印位置，透明度、设置对线段锯齿状边缘处理、水印图片的路径，水印一般格式是gif，png,这种图片可以设置透明度、水印旋转等，可以参考代码加以...
易语言NetDB数据库操作中间件
03-26
3、**服务端增加 置解密密码（）、客户端增加 置加密密码（）、尽量复杂些，这个即使是开发者也无法知道你设置的密码，注意的是，客户端设置了密码，服务端必须写入密码，否则无法访问数据库。 4、**服务端增加超时...
JDK 17 踩坑记录
最新发布
weixin_42277430的博客
01-30 585
详见IssueOracle JDK 17.0.10 已修复。
java 安全（一）
changewang的专栏
09-15 856
 Java语言本身嵌入了安全特性。比如 java 的类装载机制，就使得外部定义的可疑的与jdk 内置的类同名的类是不被加载的。这里主要是看了下java官方的安全性教程，记录下过程。通过使用 jdk本身提供的tools 和 api 接口来做 数字签名、证书、已经定义密匙库等 已达到安全校验的目的。使得远程加载的 jar包 和 文档 是可信任的。假设，susan 是提供放，ray 是接受方
关于【cn.hutool.crypto.CryptoException: SecurityException: JCE cannot authenticate the provider BC】报错问题
qq_41984644的博客
05-13 7123
版权声明：本文为CSDN博主「一个超赞的名字」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。原文链接：https://blog.csdn.net/qq_36963762/article/details/122338213。2.使用openjdk。open jdk是不会去验签的，所以直接把oracle jdk改成open jdk。ps:这个方法没有尝试过，是后面补充的,可以试试。3.直接强制关闭Bouncy Castle。
Java SunEC实现JWT JWK ES256 导入导出PEM
JunyeeJunZuo的博客
10-11 1963
Java实现基于EC非对称加密，签名算法及实现ES256/ES512等JWT签名算法的大多使用BC(BouncyCastle)来实现。闲着无聊就用JDK自带的SunEC来实现了这些，请忽略英文注释。这文章主要用来记一下ES/PEM用java SunEC怎么写的。免的以后找不到 同时支持PKCS8格式的openssl pem的导入导出，工程是基于Spring Boot的，主要是想用它的一些工具类，当然可以不用spring boot，将其中的工具类换成其他的，也可以自己写。 不废话，代码如下： 首先给
java中的X509EncodedKeySpec类
热门推荐
孤云博客
01-04 3万+
随时随地阅读更多技术实战干货，获取项目源码、学习资料，请关注源代码社区公众号(ydmsq666) 一、概述 类结构 java.lang.Object java.security.spec.EncodedKeySpec java.security.spec.X509EncodedKey...
Hutool工具类和工具方法
青春不散场的专栏
11-02 3465
基础工具类： StrUtil/StringUtils -字符串工具类 添加移除：addXXX/appendXXX/removeXXX 判断:containsXXX/startWithXXX/endWithXXX/indexOfXXX/lastIndexOfXXX/ordinalIndexOf/ isAllCharMatchisBlankIfStr/isBlankOrUndefined/isNullOrUndefined/hasBlank/hasEmpty/ isEmpty/isNotE
谈谈密码安全：服务端密码保存
daiyudong2020的博客
01-12 4539
现在有越来越多的网络服务，基本都需要注册才能使用，注册需填写账号和密码。账号基本是邮箱或者手机号，普通人基本上只有一两个邮箱和手机号，而普通人记得的密码也只是一两个。因此很多人会很自然地在不同的网络服务中使用相同的账号和密码。 这样就出现安全隐患。一旦某个服务的账号密码被泄露，其它的服务安全就受到牵连。 密码安全，应该分两部分讨论： 作为账号系统的设计者，如何对用户负责，更安全地保存密码
密码传输问题
ws_cs_dn的专栏
06-24 690
说了 密码的存储 问题，接下来再聊聊密码的传输问题。 对于在线系统，密码的传输要经过下面几个步骤： 用户在浏览器中输入原始密码：键盘 ——> 操作系统 ——> 浏览器内存程序对原始密码进行转换：内存中的原始密码 ——> 内存中的转换后的密码转换后的密码在线上传输：内存中转换后的密码 ——> 网络 ——> 系统 这其中每一步都可能泄露原始密码，当然也有相应的保护措施。 密
客户端数据如何传输到服务端
03-24
ChitGPT: 一般情况下，客户端发送数据到服务端的过程是先将数据序列化为二进制，然后通过网络传输，接收端再将数据反序列化，并进行处理。常用的传输协议有 TCP、UDP 等。在使用二进制传输时，还需要考虑端序、数据长度等因素，以保证数据的正确传输。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值