Springboot+SpringSecurity实现安全认证及原理

原创 于 2024-12-05 11:05:21 发布 · 1.1k 阅读 · 8 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#安全 #java #spring boot #后端

目录

一、简介

二、密码加密

三、RSA实现密码传输加密

        1.java后端

        2.web前端

四、安全认证及原理

五、总结

一、简介

        在Spring Security中，密码加密和密码传输加密是一个至关重要的安全措施。

二、密码加密

        在Spring Security中，密码加密的主要目的是保护用户密码的安全，防止在数据库泄露时，攻击者能够直接获取用户的明文密码。因此，我们需要对用户密码进行哈希处理，并使用强哈希算法（如BCrypt、SHA-256等）来确保密码的安全性。

        在Spring Security中，推荐使用BCrypt算法进行密码加密。BCrypt算法具有自适应的盐值（Salt）和多次哈希计算的特点，能够有效抵抗彩虹表攻击和暴力破解。

  代码如下：

/**
 * <p>
 * 自定义密码加密
 * </p>
 *
 * @author 刘易彦
 * @custom.date 2022/3/4 14:12
 */
@Slf4j
public class CustomEncoderPasswordUtils implements PasswordEncoder {

    /**
     * 建议使用security里的加密
     */
    private BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();

    @Override
    public String encode(CharSequence textPassword) {
        String encode = encoder.encode(textPassword);
        log.info("明文：[{}]，加过密后的密文：[{}]", textPassword, encode);
        return encode;
    }

    @Override
    public boolean matches(CharSequence rawPassword, String encodedPassword) {
        boolean matches = encoder.matches(rawPassword, encodedPassword);
        log.info("密码比对结果：{}", matches);
        return matches;
    }

    public static void main(String[] args) {
        String textPassword = "123456";
        BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();
        String encode = encoder.encode(textPassword);
        System.out.println(encode);
    }

}

在存储用户密码时候，调用加密方法（因为在自定义方法里面已经把PasswordEncoder注入bean了，所以我这里可以直接拿到此对象，不清楚的也可以直接把上面的工具类方法改成静态然后调用）：

代码如下：

    /**
     * 密码加密器
     */
    @Resource
    private PasswordEncoder passwordEncoder;

    @Override
    public LayUiAdminResultVo addUser(UserSp userSp) {
        userSp.setPassword(passwordEncoder.encode(userSp.getPassword()));
        int insert = this.userSpMapper.insert(userSp);
        if(insert==1){
            return LayUiAdminResultVo.ok("新增成功");
        }
        return LayUiAdminResultVo.fail("新增失败");
    }

三、RSA实现密码传输加密

        我们的系统一般都有用户、密码，用户登录向后端传送密码，明文传输过程中很容易被抓包盗取。所以这里我们自定义一个加密方式实现全流程加密传输。

        我们以非对称加密RSA为例（我这里的秘钥是存在文件里面的，追求完美的可以存到redis缓存里面）。

1.java后端

解密私钥存在java后端文件。

常量代码如下：

/**
 * @author lyy
 * @version V1.0.0
 * @Description 加解密相关常量
 * @date 2024年12月3日下午2:09:36
 */
public final class SecretConstants {

    /**
     * 数据加密RSA公钥
     */
    public static final String DATA_RSA_PUBLIC_KEY = PropertiesUtils.readProperty("secret.properties",
            "response_data_rsa_public_key");

    /**
     * 数据解密RSA私钥
     */
    public static final String DATA_RSA_PRIVATE_KEY = PropertiesUtils.readProperty("secret.properties",
            "request_data_rsa_private_key");

}

RSA工具类代码如下：

/**
 * @author lyy
 * @description RSA加解密工具类
 * @date 2024年12月3日 下午4:46:33
 */
@Slf4j
public class RSAUtils {

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

    public static final String RSA_ALGORITHM = "RSA";

    /**
     * @param keySize
     * @return Map<String, String>
     * @description 生成公钥和私钥
     */
    public static Map<String, String> createKeys(int keySize) {
        // 为RSA算法创建一个KeyPairGenerator对象
        KeyPairGenerator kpg;
        try {
            kpg = KeyPairGenerator.getInstance(RSA_ALGORITHM);
        } catch (NoSuchAlgorithmException e) {
            throw new IllegalArgumentException("No such algorithm-->[" + RSA_ALGORITHM + "]");
        }

        // 初始化KeyPairGenerator对象,密钥长度
        kpg.initialize(keySize);
        // 生成密匙对
        KeyPair keyPair = kpg.generateKeyPair();
        // 得到公钥
        Key publicKey = keyPair.getPublic();
        String publicKeyStr = Base64.encodeBase64URLSafeString(publicKey.getEncoded());
        // 得到私钥
        Key privateKey = keyPair.getPrivate();
        String privateKeyStr = Base64.encodeBase64URLSafeString(privateKey.getEncoded());
        Map<String, String> keyPairMap = new HashMap<String, String>();
        keyPairMap.put("publicKey", publicKeyStr);
        keyPairMap.put("privateKey", privateKeyStr);

        return keyPairMap;
    }

    /**
     * @param publicKey 密钥字符串（经过base64编码）
     * @return RSAPublicKey
     * @throws NoSuchAlgorithmException
     * @throws InvalidKeySpecException
     * @description 得到公钥
     */
    public static RSAPublicKey getPublicKey(String publicKey) throws NoSuchAlgorithmException, InvalidKeySpecException {
        // 通过X509编码的Key指令获得公钥对象
        KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(Base64.decodeBase64(publicKey));
        RSAPublicKey key = (RSAPublicKey) keyFactory.generatePublic(x509KeySpec);
        return key;
    }

    /**
     * @param privateKey 密钥字符串（经过base64编码）
     * @return RSAPrivateKey
     * @throws NoSuchAlgorithmException
     * @throws InvalidKeySpecException
     * @description 得到私钥
     */
    public static RSAPrivateKey getPrivateKey(String privateKey)
            throws NoSuchAlgorithmException, InvalidKeySpecException {
        // 通过PKCS#8编码的Key指令获得私钥对象
        KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(Base64.decodeBase64(privateKey));
        RSAPrivateKey key = (RSAPrivateKey) keyFactory.generatePrivate(pkcs8KeySpec);
        return key;
    }

    /**
     * @param data      数据
     * @param publicKey 公钥
     * @return String
     * @description 公钥加密
     */
    public static String publicEncrypt(String data, RSAPublicKey publicKey) {
        try {
            Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
            return Base64.encodeBase64URLSafeString(rsaSplitCodec(cipher, Cipher.ENCRYPT_MODE, data.getBytes(CHARSET),
                    publicKey.getModulus().bitLength()));
        } catch (Exception e) {
            throw new RuntimeException("加密字符串[" + data + "]时遇到异常", e);
        }
    }

    /**
     * @param data       数据
     * @param privateKey 私钥
     * @return String
     * @description 私钥解密
     */
    public static String privateDecrypt(String data, RSAPrivateKey privateKey) {
        try {
            Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
            return new String(rsaSplitCodec(cipher, Cipher.DECRYPT_MODE, Base64.decodeBase64(data),
                    privateKey.getModulus().bitLength()), CHARSET);
        } catch (Exception e) {
            throw new RuntimeException("解密字符串[" + data + "]时遇到异常", e);
        }
    }

    /**
     * @param data       数据
     * @param privateKey 私钥
     * @return String
     * @description 私钥加密
     */
    public static String privateEncrypt(String data, RSAPrivateKey privateKey) {
        try {
            Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
            cipher.init(Cipher.ENCRYPT_MODE, privateKey);
            return Base64.encodeBase64URLSafeString(rsaSplitCodec(cipher, Cipher.ENCRYPT_MODE, data.getBytes(CHARSET),
                    privateKey.getModulus().bitLength()));
        } catch (Exception e) {
            throw new RuntimeException("加密字符串[" + data + "]时遇到异常", e);
        }
    }

    /**
     * @param data      数据
     * @param publicKey 公钥
     * @return String
     * @description 公钥解密
     */
    public static String publicDecrypt(String data, RSAPublicKey publicKey) {
        try {
            Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
            cipher.init(Cipher.DECRYPT_MODE, publicKey);
            return new String(rsaSplitCodec(cipher, Cipher.DECRYPT_MODE, Base64.decodeBase64(data),
                    publicKey.getModulus().bitLength()), CHARSET);
        } catch (Exception e) {
            throw new RuntimeException("解密字符串[" + data + "]时遇到异常", e);
        }
    }

    /**
     * @param data       待签名数据
     * @param privateKey 私钥
     * @return String
     * @throws Exception
     * @description 签名
     */
    public static String sign(String data, PrivateKey privateKey) throws Exception {
        byte[] keyBytes = privateKey.getEncoded();
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
        PrivateKey key = keyFactory.generatePrivate(keySpec);
        Signature signature = Signature.getInstance("MD5withRSA");
        signature.initSign(key);
        signature.update(data.getBytes());
        return new String(Base64.encodeBase64(signature.sign()));
    }

    /**
     * @param srcData   原始字符串
     * @param publicKey 公钥
     * @param sign      签名
     * @return boolean 是否验签通过
     * @throws Exception
     * @description 验签
     */
    public static boolean verify(String srcData, PublicKey publicKey, String sign) throws Exception {
        byte[] keyBytes = publicKey.getEncoded();
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
        PublicKey key = keyFactory.generatePublic(keySpec);
        Signature signature = Signature.getInstance("MD5withRSA");
        signature.initVerify(key);
        signature.update(srcData.getBytes());
        return signature.verify(Base64.decodeBase64(sign.getBytes()));
    }

    private static byte[] rsaSplitCodec(Cipher cipher, int opmode, byte[] datas, int keySize) {
        int maxBlock = 0;
        if (opmode == Cipher.DECRYPT_MODE) {
            maxBlock = keySize / 8;
        } else {
            maxBlock = keySize / 8 - 11;
        }

        int offSet = 0;
        byte[] buff;
        byte[] resultDatas;
        int i = 0;
        try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {
            while (datas.length > offSet) {
                if (datas.length - offSet > maxBlock) {
                    buff = cipher.doFinal(datas, offSet, maxBlock);
                } else {
                    buff = cipher.doFinal(datas, offSet, datas.length - offSet);
                }
                out.write(buff, 0, buff.length);
                i++;
                offSet = i * maxBlock;
            }
            resultDatas = out.toByteArray();
        } catch (Exception e) {
            throw new RuntimeException("加解密阀值为[" + maxBlock + "]的数据时发生异常", e);
        }
        return resultDatas;
    }
}

读取文件秘钥的工具类代码如下：

/**
 * @author liuyiyan
 * @Description java读取.properties文件
 * @date 2024/12/04
 */
public class PropertiesUtils {

    private final static Logger LOGGER = LoggerFactory.getLogger(PropertiesUtils.class);

    /**
     * @date 2024/12/04
     * @author liuyiyan
     * @func 读取资源属性文件（properties），无缓存方式
     */
    public static String readPropertyNoCache(String filePath, String param) {
        try {
            String url = PropertiesUtils.class.getResource("/").getPath() + filePath;
            Properties prop = new Properties();
            InputStream in = new BufferedInputStream(new FileInputStream(url));
            // 将属性文件流装载到Properties对象中
            // prop.load(in);
            prop.load(new InputStreamReader(in, "utf-8"));
            return prop.getProperty(param);
        } catch (IOException e) {
            LOGGER.error("读properties属性文件异常！", e);
        }
        return null;
    }

    /**
     * @date 2024/12/04
     * @author liuyiyan
     * @func 读取资源属性文件（properties），用IO流的方式
     */
    public static String readProperty(String filePath, String param) {
        // 属性集合对象
        Properties properties = new Properties();
        // 获取路径并转换成流
        InputStream path = Thread.currentThread().getContextClassLoader().getResourceAsStream(filePath);
        try {
            // 将属性文件流装载到Properties对象中
            properties.load(path);
            return properties.getProperty(param);
        } catch (IOException e) {
            LOGGER.error("读properties属性文件异常！", e);
        }
        return null;
    }

    /**
     * @date 2024/12/04
     * @author liuyiyan
     * @func 读取资源属性文件（properties），然后根据.properties文件的名称信息（本地化信息）
     */
    public static String getProperty(String filePath, String param) {
        ResourceBundle resourceBundle = ResourceBundle.getBundle(filePath);
        return resourceBundle.getString(param);
    }

    /**
     * @param propertiesFile
     * @param param
     * @return map
     * @description 读取.properties配置文件的内容至Map中
     */
    public static Map<String, String> read2Map(String propertiesFile, String param) {
        ResourceBundle rb = ResourceBundle.getBundle(propertiesFile);
        Map<String, String> map = new HashMap<String, String>(16);
        Enumeration<String> enu = rb.getKeys();
        while (enu.hasMoreElements()) {
            String obj = enu.nextElement();
            // 传了参数
            if (StringUtils.isNotEmpty(param)) {
                if (obj.indexOf(param) != -1) {
                    String objv = rb.getString(obj);
                    map.put(obj, objv);
                }
            }
            // 没传参数
            else {
                String objv = rb.getString(obj);
                map.put(obj, objv);
            }
        }
        return map;
    }

    /**
     * @param filePath
     * @param pKey
     * @param pValue
     * @func 写properties文件
     */
    public static boolean writeProperties(String filePath, String pKey, String pValue) {
        try {
            String url = PropertiesUtils.class.getResource("/").getPath() + filePath;
            Properties prop = new Properties();
            InputStream in = new BufferedInputStream(new FileInputStream(url));
            // 将属性文件流装载到Properties对象中
            prop.load(in);
            // 调用 Hashtable 的方法 put。使用 getProperty 方法提供并行性。
            // 强制要求为属性的键和值使用字符串。返回值是 Hashtable 调用 put 的结果。
            OutputStream out = new FileOutputStream(url);
            prop.setProperty(pKey, pValue);
            // 以适合使用 load 方法加载到 Properties 表中的格式，
            // 将此 Properties 表中的属性列表（键和元素对）写入输出流
            prop.store(out, "Update " + pKey + " name");
            return true;
        } catch (Exception e) {
            LOGGER.error("写properties属性文件异常！", e);
            return false;
        }
    }
}

2.web前端

加密的公钥存在web前端。然后使用jsencrypt.min.js进行rsa加密。

资源链接：https://download.csdn.net/download/milk_yan/90085095

加密代码如下：

        /**
         * 对字符串进行RSA加密
         * @param str 待加密字符串
         * @returns {null|string|undefined|PromiseLike<ArrayBuffer>|*}
         */
        rsaEncrypt: function (str) {
            try {
                let publicKey = '-----BEGIN PUBLIC KEY-----' + obj.webConst.RSA_DATA_ENCRYPT_PUBLIC_KEY + '-----END PUBLIC KEY-----';
                let encrypt = new JSEncrypt();
                encrypt.setPublicKey(publicKey);
                return encrypt.encrypt(str);
            } catch (e) {
                console.error(e.name + '，' + e.message);
                alert(e.name + '，' + e.message);
                throw e;
            }
        },

四、安全认证及原理

       因为springsecurity的加密是单向的无法进行解密，所以在认证的时候需要将前端传来的密码进行同步加密然后和库里加过密的密码交给springsecurity进行匹配对比（我这里的代码是自定义的认证方式）。

代码如下：

/**
 * <p>
 * 自定义springSecurity认证。
 * </p>
 *
 * @author 刘易彦
 * @custom.date 2024/6/21 17:23
 */
@Component
public class CustomAuthenticationProvider extends AbstractUserDetailsAuthenticationProvider {

    @Resource
    private IUserService userService;

    /**
     * 密码加密器
     */
    @Resource
    private PasswordEncoder passwordEncoder;

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    @SneakyThrows
    @Override
    protected void additionalAuthenticationChecks(UserDetails userDetails, UsernamePasswordAuthenticationToken authentication) throws AuthenticationException {
        Object principal = authentication.getPrincipal();
        Object credentials = authentication.getCredentials();
        if (principal == null || credentials == null) {
            throw new BadCredentialsException("账号或密码不能为空！");
        }
        String account;
        String password;
        try {
            // 解密账号
            account = RSAUtils.privateDecrypt(String.valueOf(principal), RSAUtils.getPrivateKey(SecretConstants.DATA_RSA_PRIVATE_KEY));
            // 解密密码
            password = RSAUtils.privateDecrypt(String.valueOf(credentials), RSAUtils.getPrivateKey(SecretConstants.DATA_RSA_PRIVATE_KEY));
        } catch (Exception e) {
            throw new BadCredentialsException("账号或密码解密错误！");
        }
        // 拿到后端查询到的账号密码信息进行比较
        if (!StringUtils.equals(account, userDetails.getUsername())) {
            throw new BadCredentialsException("账号或密码错误！");
        }
        if (!passwordEncoder.matches(password, userDetails.getPassword())) {
            throw new BadCredentialsException("账号或密码错误！");
        }
    }


    @Override
    protected UserDetails retrieveUser(String username, UsernamePasswordAuthenticationToken authentication) throws AuthenticationException {
        try {
            username = RSAUtils.privateDecrypt(username, RSAUtils.getPrivateKey(SecretConstants.DATA_RSA_PRIVATE_KEY));
            //查询用户角色权限
            UserDetails userDetails = userService.loadUserByUsername(username);
            if (userDetails == null) {
                throw new InternalAuthenticationServiceException(
                        "UserDetailsService returned null, which is an interface contract violation");
            }
            return userDetails;
        } catch (UsernameNotFoundException | InternalAuthenticationServiceException ex) {
            throw ex;
        } catch (Exception ex) {
            throw new InternalAuthenticationServiceException(ex.getMessage(), ex);
        }
    }
}

五、总结

        经过以上安全加密保证系统的安全性。

SpringBoot整合SpringSecurity实现一个简单的认证与授权应用
pan_junbiao的博客
11-23 1180
Spring Security 是一个功能强大且高度可定制的身份验证和访问控制框架，它是 Spring 项目组中用来提供安全认证服务的框架，能够为基于 Sprin g的企业应用系统提供声明式的安全访问控制解决方案。Spring Security 的前身是 Acegi Security。它是一个能够为基于 Spring 的企业应用系统提供声明式的安全访问控制解决方案的安全框架。Spring Security 采用了 AOP（面向切面编程）思想，并基于 Servlet 过滤器实现。
Springboot与SpringSecurity使用（1）：介绍、登录验证
游王子og的博客
07-28 2854
Spring 是非常流行和成功的 Java 应用开发框架，Spring Security 正是 Spring 家族中的成员。Spring Security 基于 Spring 框架，提供了一套 Web 应用安全性的完整解决方案。Web 应用的安全性包括用户认证（Authentication）和用户授权（Authorization）两个部分，这两点也是 SpringSecurity 重要核心功能。Spring Security进行认证和鉴权的时候,就是利用的一系列的Filter来进行拦截的。
SpringBoot整合Spring Security + JWT实现用户认证
leveretz的博客
07-13 2085
SpringBoot整合Spring Security + JWT实现用户认证
Spring Security（二）自定义用户名密码认证
Lyndon的专栏
10-23 8278
SpringBoot整合Spring Security实现ajax登录
SpringBoot - 安全管理框架Spring Security使用详解(9)-密码加密配置
Andy's Blog
06-06 978
在之前的文章中密码都是使用明文的方式进行存储，但这样会有很大的安全隐患。所以正常做系统时，密码都要加密处理。而在Spring Boot中配置密码加密非常容易，下面通过样例进行演示。 九、密码加密配置 1，样例代码 （1）要配置密码加密只需要修改两个地方。首先要修改HttpSecurity配置中的PasswordEncoder这个Bean的实现，这里我们采用BCryptPasswordEncoder加密方案。 Spring Security提供了多种密码加密方案，官方推荐使用...
SpringBoot + SpringSecurity 短信验证码登录功能实现
08-27
SpringBoot + SpringSecurity 短信验证码登录功能实现 本文主要介绍了 SpringBoot + SpringSecurity 短信验证码登录功能实现的详细过程，该功能可以使用户通过手机短信验证码登录系统，而不是传统的用户名密码登录...
Springboot+Spring-Security+JWT 实现用户登录和权限认证
最新发布
yuwinter的博客
10-10 3905
Spring Boot 项目初始化：利用 Spring Initializr 创建项目，并添加必要依赖（Spring Web、Spring Security、JWT、JPA 等）。 用户登录和注册接口：实现 AuthController，处理用户登录请求，并返回 JWT。 Spring Security 配置：通过扩展 WebSecurityConfigurerAdapter 来配置 Spring Security，设置无状态的会话管理、JWT 过滤器、受保护的资源路径等。 JWT 生成和解析：实现。
SpringBoot+Spring Security+JWT（三更草堂）
Roc的博客
09-12 8336
Springsecurity是Spring家族中的一个安全管理框架。相比与另外一个安全框架shiro，它提供了更丰富的功能，社区资源也比Shiro丰富。一般来说中大型的项目都是使用来做安全框架。小项目有Shiro的比较多，因为相比与SpringSecurity，Shiro的上手更加的简单。—般Web应用的需要进行认证和授权。认证：验证当前访问系统的是不是本系统的用户，并且要确认具体是哪个用户授权：经过认证后判断当前用户是否有权限进行某个操作而认证和授权也是SpringSecurity作为安全框架的核心功能。
基于springboot+springSecurity+jwt实现的基于token的权限管理的一个demo，适合新手
03-05
本Demo以SpringBoot为核心框架，结合SpringSecurity进行安全控制，并利用JWT（JSON Web Token）进行令牌验证，为新手提供了一个学习和实践的基础平台。下面我们将详细探讨这些技术的使用和整合。 **1. SpringBoot**...
SpringBoot+SpringSecurity+JWT权限管理练习项目
01-16
总的来说，"SpringBoot+SpringSecurity+JWT权限管理练习项目"是一个全面而实用的学习资源，它将帮助初学者系统地掌握现代Web应用中的安全设计和实现。通过实际操作，学习者能够更好地理解这些技术的内在联系，从而在...
spring-security 登录,权限管理,密码加密-开箱即用
10-26
SpringBoot2.0+Security+Tomcat9+JDK8+Mybatis+Maven 项目启动后有HTML模板，进入后先进入的主页没有进行任何的拦截，后点击Join us 进入登录或者注册页面进行注册，数据库脚本的话可以自己根据实体类或者sqlMap文件进行自己添加，比较简单
Spring security 自定义密码加密方式的使用范例。
09-15
Spring security的完整使用范例，支持自定义密码的加密方式，以及成功，失败的处理。是一个完整可运行的工程，码云似乎还要注册。后期考虑下用码云
SpringBoot集成SpringSecurity（二）加密方法和静态用户权限配置
xinshengdelei的专栏
03-31 451
撒
Spring Boot 中密码加密的两种姿势！
keyoukewude的博客
04-18 1969
所以，这里我先来给大家介绍下 commons-codec 的用法。首先我们需要引入 commons-codec 的依赖：1.11然后自定义一个 PasswordEncoder：@Component@Override@Override在 Spring Security 中，PasswordEncoder 专门用来处理密码的加密与比对工作，我们自定义 MyPasswordEncoder 并实现 PasswordEncoder 接口，还需要实现该接口中的两个方法：
Spring Security入门（三）：密码加密
热门推荐
程序猿DD
01-17 2万+
前文导读- Spring Security入门（一）：登录与退出- Spring Security入门（二）：基于数据库验证Github 地址https://github.com/ChinaSilence/any-spring-security 本文对应 security-login-db-encryptPWD摘要解决2个问题：注册时密码加密后存入数据库登录时密码加密校验运行程序1、clone 代
spring security 基本原理
weixin_47460834的博客
06-27 1378
spring security本质上就是一个过滤器链（javaweb），由很多个过滤器组成，大概有十几个；其中比较典型的过滤器：其实spring security出现得比springboot还要早，但是自从有了spirngboot之后，springboot对spring security提供了自动化配置方案，可以使用更少配置来使用。虽然有springboor，还是要了解spring security过滤器加载过程:在spring security应用中会用到两个重要的接口： 在实际项目中，账号和
SpringSecurity（七）【密码加密】
Vinjcent
11-10 2529
bcrypt 方式加密在测试类中，对我们输入的明文密码进行加密并输出// 参数是用户输入的明文 String encode = bCryptPasswordEncoder . encode("123");
Spring Security加密解密
程序员一博
08-03 8632
我们开发时进行密码加密，可用的加密手段有很多，比如对称加密、非对称加密、信息摘要等。在一般的项目里，常用的就是信息摘要算法，也可以被称为散列加密函数，或者称为散列算法、哈希函数。这是一种可以从任何数据中创建数字“指纹”的方法，常用的散列函数有 MD5 消息摘要算法、安全散列算法(Secure Hash Algorithm)等。散列函数通过把消息或数据压缩成摘要信息，使得数据量变小，将数据的格式固定下来，然后将数据打乱混合，再重新创建成一个散列值，从而达到加密的目的。散列值通常用一个短的随机字母和数字组成的字
Spring Security系列教程22--Spring Security中的密码加密
一一哥
10-24 4318
前言 截止到现在，一一哥 已经带各位学习了很多关于Spring Security的知识点，但是Spring Security作为一个安全框架，其中必然就应该带有安全加密方面的内容，所以本篇文章，一一哥 就带各位来学习Spring Security中的密码加密机制。 Lets go！ 一. 密码加密简介 1. 散列加密概述 我们开发时进行密码加密，可用的加密手段有很多，比如对称加密、非对称加密、信息摘要等。在一般的项目里，常用的就是信息摘要算法，也可以被称为散列加密函数，或者称为散列算法、哈希函数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值