sso单点登录、JWT、RSA、配置文件参数读取

最新推荐文章于 2024-03-01 15:21:28 发布
最新推荐文章于 2024-03-01 15:21:28 发布
阅读量563 收藏 1
点赞数
分类专栏： 工具 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jpcmshjs/article/details/107057675
版权

无状态登录

微服务集群中的每个服务，对外提供的都是Rest风格的接口。而Rest风格的一个最重要的规范就是：服务的无状态性，即：

  • 服务端不保存任何客户端请求者信息
  • 客户端的每次请求必须具备自描述信息，通过这些信息识别客户端身份

带来的好处是什么呢？

  • 客户端请求不依赖服务端的信息，任何多次请求不需要必须访问到同一台服务
  • 服务端的集群和状态对客户端透明
  • 服务端可以任意的迁移和伸缩
  • 减小服务端存储压力

无状态登录流程

无状态登录的流程：

  • 当客户端第一次请求服务时，服务端对用户进行信息认证（登录）
  • 认证通过，将用户信息进行加密形成token，返回给客户端，作为登录凭证
  • 以后每次请求，客户端都携带认证的token
  • 服务的对token进行解密，判断是否有效。
    在这里插入图片描述

token的安全性

token是识别客户端身份的唯一标示，如果加密不够严密，被人伪造那就完蛋了。

采用何种方式加密才是安全可靠的呢？

我们将采用JWT + RSA非对称加密

JWT，全称是Json Web Token， 是JSON风格轻量级的授权和身份认证规范，可实现无状态、分布式的Web应用授权；官网：https://jwt.io

GitHub上jwt的java客户端：https://github.com/jwtk/jjwt

JWT数据格式

JWT包含三部分数据：

  • Header：头部，通常头部有两部分信息：

    • token类型：JWT
    • 加密方式：base64（HS256）

  • Payload：载荷，就是有效数据，一般包含下面信息：

    • 用户身份信息（注意，这里因为采用base64编码，可解码，因此不要存放敏感信息）
    • 注册声明：如token的签发时间，过期时间，签发人等

    这部分也会采用base64编码，得到第二部分数据

  • Signature：签名，是整个数据的认证信息。根据前两步的数据，再加上指定的密钥（secret）（不要泄漏，最好周期性更换），通过base64编码生成。用于验证整个数据完整和可靠性

JWT交互流程

在这里插入图片描述
步骤翻译：

  • 1、用户登录
  • 2、服务的认证，通过后根据secret生成token
  • 3、将生成的token返回给浏览器
  • 4、用户每次请求携带token
  • 5、服务端利用公钥解读jwt签名，判断签名有效后，从Payload中获取用户信息
  • 6、处理请求，返回响应结果

因为JWT签发的token中已经包含了用户的身份信息，并且每次请求都会携带，这样服务的就无需保存用户信息，甚至无需去数据库查询，完全符合了Rest的无状态规范。

非对称加密

加密技术是对信息进行编码和解码的技术，编码是把原来可读信息（又称明文）译成代码形式（又称密文），其逆过程就是解码（解密），加密技术的要点是加密算法，加密算法可以分为三类：

  • 对称加密，如AES
    • 基本原理：将明文分成N个组，然后使用密钥对各个组进行加密，形成各自的密文，最后把所有的分组密文进行合并，形成最终的密文。
    • 优势：算法公开、计算量小、加密速度快、加密效率高
    • 缺陷：双方都使用同样密钥，安全性得不到保证
  • 非对称加密，如RSA
    命令行中输入ssh-keygen -t rsa 可生成秘钥
    • 基本原理：同时生成两把密钥：私钥和公钥，私钥隐秘保存，公钥可以下发给信任客户端
      • 私钥加密，持有公钥才可以解密
      • 公钥加密，持有私钥才可解密
    • 优点：安全，难以破解
    • 缺点：算法比较耗时
  • 不可逆加密，如MD5，SHA
    • 基本原理：加密过程中不需要使用密钥，输入明文后由系统直接经过加密算法处理成密文，这种加密后的数据是无法被解密的，无法根据密文推算出明文。

引入依赖

<!--jwt依赖-->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt-api</artifactId>
            <version>0.11.2</version>
        </dependency>
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt-impl</artifactId>
            <version>0.11.2</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt-jackson</artifactId> <!-- or jjwt-gson if Gson is preferred -->
            <version>0.11.2</version>
            <scope>runtime</scope>
        </dependency>
        <!--时间操作组件-->
        <dependency>
            <groupId>joda-time</groupId>
            <artifactId>joda-time</artifactId>
            <version>2.9.9</version>
        </dependency>
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-core</artifactId>
            <version>9.0.29</version>
        </dependency>

RSA工具类

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

public class RsaUtils {
    /**
     * 从文件中读取公钥
     *
     * @param filename 公钥保存路径，相对于classpath
     * @return 公钥对象
     * @throws Exception
     */
    public static PublicKey getPublicKey(String filename) throws Exception {
        byte[] bytes = readFile(filename);
        return getPublicKey(bytes);
    }

    /**
     * 从文件中读取密钥
     *
     * @param filename 私钥保存路径，相对于classpath
     * @return 私钥对象
     * @throws Exception
     */
    public static PrivateKey getPrivateKey(String filename) throws Exception {
        byte[] bytes = readFile(filename);
        return getPrivateKey(bytes);
    }

    /**
     * 获取公钥
     *
     * @param bytes 公钥的字节形式
     * @return
     * @throws Exception
     */
    public static PublicKey getPublicKey(byte[] bytes) throws Exception {
        X509EncodedKeySpec spec = new X509EncodedKeySpec(bytes);
        KeyFactory factory = KeyFactory.getInstance("RSA");
        return factory.generatePublic(spec);
    }

    /**
     * 获取密钥
     *
     * @param bytes 私钥的字节形式
     * @return
     * @throws Exception
     */
    public static PrivateKey getPrivateKey(byte[] bytes) throws Exception {
        PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(bytes);
        KeyFactory factory = KeyFactory.getInstance("RSA");
        return factory.generatePrivate(spec);
    }

    /**
     * 根据密文，生存rsa公钥和私钥,并写入指定文件
     *
     * @param publicKeyFilename  公钥文件路径
     * @param privateKeyFilename 私钥文件路径
     * @param secret             生成密钥的密文
     * @throws IOException
     * @throws NoSuchAlgorithmException
     */
    public static void generateKey(String publicKeyFilename, String privateKeyFilename, String secret) throws Exception {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        SecureRandom secureRandom = new SecureRandom(secret.getBytes());
        keyPairGenerator.initialize(2048, secureRandom);
        KeyPair keyPair = keyPairGenerator.genKeyPair();
        // 获取公钥并写出
        byte[] publicKeyBytes = keyPair.getPublic().getEncoded();
        writeFile(publicKeyFilename, publicKeyBytes);
        // 获取私钥并写出
        byte[] privateKeyBytes = keyPair.getPrivate().getEncoded();
        writeFile(privateKeyFilename, privateKeyBytes);
    }

    private static byte[] readFile(String fileName) throws Exception {
        return Files.readAllBytes(new File(fileName).toPath());
    }

    private static void writeFile(String destPath, byte[] bytes) throws IOException {
        File dest = new File(destPath);
        if (!dest.exists()) {
            dest.createNewFile();
        }
        Files.write(dest.toPath(), bytes);
    }
}

JWT工具类

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jws;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.joda.time.DateTime;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.util.Map;

public class JwtUtils {
    /**
     * 私钥加密token
     *
     * @param map           载荷中的数据
     * @param expireMinutes 过期时间，单位秒
     * @return
     * @throws Exception
     */
    public static String generateToken(Map<String, Object> map, PrivateKey key, int expireMinutes) throws Exception {
        return Jwts.builder()
                .setClaims(map)
                .setExpiration(DateTime.now().plusMinutes(expireMinutes).toDate())
                .signWith(key, SignatureAlgorithm.RS256)
                .compact();
    }

    /**
     * 公钥解析token
     *
     * @param token  用户请求中的token
     * @return
     * @throws Exception
     */
    private static Jws<Claims> parserToken(String token, PublicKey key) {
        return Jwts.parser().setSigningKey(key).parseClaimsJws(token);
    }

    /**
     * 获取token中的用户信息
     *
     * @param token  用户请求中的令牌
     * @return 用户信息
     * @throws Exception
     */
    public static Map<String, Object> getInfoFromToken(String token, PublicKey key) throws Exception {
        Jws<Claims> claimsJws = parserToken(token, key);
        return claimsJws.getBody();
    }

}

cookie工具类

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.net.URLEncoder;

/**
 * 
 * Cookie 工具类
 *
 */
public final class CookieUtils {

	static final Logger logger = LoggerFactory.getLogger(CookieUtils.class);

	/**
	 * 得到Cookie的值, 不编码
	 * 
	 * @param request
	 * @param cookieName
	 * @return
	 */
	public static String getCookieValue(HttpServletRequest request, String cookieName) {
		return getCookieValue(request, cookieName, false);
	}

	/**
	 * 得到Cookie的值,
	 * 
	 * @param request
	 * @param cookieName
	 * @return
	 */
	public static String getCookieValue(HttpServletRequest request, String cookieName, boolean isDecoder) {
		Cookie[] cookieList = request.getCookies();
		if (cookieList == null || cookieName == null){
			return null;			
		}
		String retValue = null;
		try {
			for (int i = 0; i < cookieList.length; i++) {
				if (cookieList[i].getName().equals(cookieName)) {
					if (isDecoder) {
						retValue = URLDecoder.decode(cookieList[i].getValue(), "UTF-8");
					} else {
						retValue = cookieList[i].getValue();
					}
					break;
				}
			}
		} catch (UnsupportedEncodingException e) {
			logger.error("Cookie Decode Error.", e);
		}
		return retValue;
	}

	/**
	 * 得到Cookie的值,
	 * 
	 * @param request
	 * @param cookieName
	 * @return
	 */
	public static String getCookieValue(HttpServletRequest request, String cookieName, String encodeString) {
		Cookie[] cookieList = request.getCookies();
		if (cookieList == null || cookieName == null){
			return null;			
		}
		String retValue = null;
		try {
			for (int i = 0; i < cookieList.length; i++) {
				if (cookieList[i].getName().equals(cookieName)) {
					retValue = URLDecoder.decode(cookieList[i].getValue(), encodeString);
					break;
				}
			}
		} catch (UnsupportedEncodingException e) {
			logger.error("Cookie Decode Error.", e);
		}
		return retValue;
	}

	/**
	 * 生成cookie，并指定编码
	 * @param request 请求
	 * @param response 响应
	 * @param cookieName name
	 * @param cookieValue value
	 * @param encodeString 编码
	 */
	public static final void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName, String cookieValue, String encodeString) {
		setCookie(request,response,cookieName,cookieValue,null,encodeString, null);
	}

	/**
	 * 生成cookie，并指定生存时间
	 * @param request 请求
	 * @param response 响应
	 * @param cookieName name
	 * @param cookieValue value
	 * @param cookieMaxAge 生存时间
	 */
	public static final void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName, String cookieValue, Integer cookieMaxAge) {
		setCookie(request,response,cookieName,cookieValue,cookieMaxAge,null, null);
	}

	/**
	 * 设置cookie，不指定httpOnly属性
	 */
	public static final void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName, String cookieValue, Integer cookieMaxAge, String encodeString) {
		setCookie(request,response,cookieName,cookieValue,cookieMaxAge,encodeString, null);
	}

	/**
	 * 设置Cookie的值，并使其在指定时间内生效
	 * 
	 * @param cookieMaxAge
	 *            cookie生效的最大秒数
	 */
	public static final void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName, String cookieValue, Integer cookieMaxAge, String encodeString, Boolean httpOnly) {
		try {
			if(StringUtils.isBlank(encodeString)) {
				encodeString = "utf-8";
			}

			if (cookieValue == null) {
				cookieValue = "";
			} else {
				cookieValue = URLEncoder.encode(cookieValue, encodeString);
			}
			Cookie cookie = new Cookie(cookieName, cookieValue);
			if (cookieMaxAge != null && cookieMaxAge > 0)
				cookie.setMaxAge(cookieMaxAge);
			if (null != request)// 设置域名的cookie
				cookie.setDomain(getDomainName(request));
			cookie.setPath("/");

			if(httpOnly != null) {
				cookie.setHttpOnly(httpOnly);
			}
			response.addCookie(cookie);
		} catch (Exception e) {
			logger.error("Cookie Encode Error.", e);
		}
	}

	/**
	 * 得到cookie的域名
	 */
	private static final String getDomainName(HttpServletRequest request) {
		String domainName = null;

		String serverName = request.getRequestURL().toString();
		if (serverName == null || serverName.equals("")) {
			domainName = "";
		} else {
			serverName = serverName.toLowerCase();
			serverName = serverName.substring(7);
			final int end = serverName.indexOf("/");
			serverName = serverName.substring(0, end);
			final String[] domains = serverName.split("\\.");
			int len = domains.length;
			if (len > 3) {
				// www.xxx.com.cn
				domainName = domains[len - 3] + "." + domains[len - 2] + "." + domains[len - 1];
			} else if (len <= 3 && len > 1) {
				// xxx.com or xxx.cn
				domainName = domains[len - 2] + "." + domains[len - 1];
			} else {
				domainName = serverName;
			}
		}

		if (domainName != null && domainName.indexOf(":") > 0) {
			String[] ary = domainName.split("\\:");
			domainName = ary[0];
		}
		return domainName;
	}

}

配置文件参数读取

属性类
@ConfigurationProperties(prefix = “auth.jwt”)使得参数读取更加灵活

加了此注解的类中的属性，会自动读取配置文件中规定前缀属性的值，并赋值给类中的属性

注意：

  • 类的字段必须有公共 setter 方法
  • 在属性使用时要激活属性，在类上加 @EnableConfigurationProperties(JwtProperties.class)

配置文件

auth:
  jwt:
    secret: sf3423jsdf#3$@FDS32
    pubKeyPath: C:\rsa\rsa.pub
    priKeyPath: C:\rsa\rsa.pri
    expire: 30
    cookieName: TOKEN

属性类

@Data
@Slf4j
@ConfigurationProperties(prefix = "auth.jwt")
public class JwtProperties {
    private String secret; // 密钥

    private String pubKeyPath;// 公钥

    private String priKeyPath;// 私钥

    private int expire;// token过期时间

    private PublicKey publicKey; // 公钥

    private PrivateKey privateKey; // 私钥

    private String cookieName; // cookie名称
    /**
     * @PostContruct：在构造方法执行之后执行该方法
     */
    @PostConstruct
    public void init() {
        try {
            File pubKey = new File(pubKeyPath);
            File priKey = new File(priKeyPath);
            if (!pubKey.exists() || !priKey.exists()) {
                // 生成公钥和私钥
                RsaUtils.generateKey(pubKeyPath, priKeyPath, secret);
            }
            // 获取公钥和私钥
            this.publicKey = RsaUtils.getPublicKey(pubKeyPath);
            this.privateKey = RsaUtils.getPrivateKey(priKeyPath);
        } catch (Exception e) {
            log.error("初始化公钥和私钥失败！", e);
            throw new RuntimeException();
        }
    }
}

授权中心

Controller

@RestController
@RequestMapping("auth")
public class AuthController {
    @Autowired
    private AuthService authService;
    @Autowired
    private JwtProperties jwtProperties;
    @PostMapping("accredit")
    public String accredit(@RequestParam("username")String username, @RequestParam("password")String password
    , HttpServletRequest request, HttpServletResponse response){
        String token = authService.accredit(username, password);
        if (StringUtils.isNotBlank(token)){
            //放入cookie中
            CookieUtils.setCookie(request,response,jwtProperties.getCookieName(),token,jwtProperties.getExpire());
            return "登录成功";
        }
        return "登录失败";
    }
}

service

@Service
@EnableConfigurationProperties(JwtProperties.class)
public class AuthService {
    @Autowired
    private JwtProperties jwtProperties;
    public String accredit(String username, String password) {
        //校验用户名和密码
        if(username == null || password == null){
            throw new RuntimeException("请填写用户名和密码");
        }
        if(username.equals("young") && password.equals("young")){
            User user = new User();
            user.setAge(26);
            user.setUsername("young");
            //制作jwt
            Map<String,Object> map = new HashMap<>();
            map.put("username",user.getUsername());
            map.put("age",user.getAge());
            try {
                String token = JwtUtils.generateToken(map, jwtProperties.getPrivateKey(), jwtProperties.getExpire());
                return token;
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    return null;
    }
}
jpcmshjs
关注
专栏目录
jsrsasign：“ jsrsasign”（RSA-Sign JavaScript库）是一个免费的开源加密库，支持RSARSAPSSECDSADSA签名验证，ASN.1，PKCS＃158私钥，X.509证书，CRL，OCSP，CMS SignedData，TimeStamp，CAdES JSON Web纯JavaScript中的SignatureToken
02-14
jsrsasign “ jsrsasign”（RSA-Sign JavaScript库）是一个免费的开源加密库，支持RSA / RSAPSS / ECDSA / DSA签名/验证，ASN.1，PKCS＃1/5/8私钥/公钥，X.509证书，纯JavaScript中的CRL，OCSP，CMS SignedData，TimeStamp，CAdES JSON Web签名/令牌/密钥。 公开页面是 。 我们始终欢迎您的错误修正和请求请求贡献:) 消息 2020年10月5日：jsrsasign赢得了 。 谢谢Google。 2020年9月23日：发布了与CMS SignedData相关的类的10.0.0，包括时间戳和CAdES体系结构更新 2020年8月24日：发布到新的CRL API的9.1.0与证书保持一致 2020年8月19日：发布9.0.0版，用于证书和CSR生成和解析的主要更新，而
CAS单点登录（SSO）服务器配置
随风逐亚的专栏
10-12 688
一、单点登录的概念       单点登录（SSO）英文全称Single Sign On，单点登录。SSO是在多个应用系统中，用户只需要登录一次就可以访问所有相互信任的应用系统。它包括可以将这次主要的登录映射到其他应用中用于同一个用户的登录的机制。它是目前比较流行的企业业务整合的解决方案之一。      简单的 SSO 的体系中，会有下面三种角色：    1 、 User （多个）    2 、
sso单点登陆实现
a623982022的博客
01-28 418
Sso系统工程搭建 服务接口实现： 用户登录: 功能分析: 请求的url：/user/login 请求的方法：POST 参数：username、password，表单提交的数据。可以使用方法的形参接收。 返回值：json数据，使用result包含一个token。 登录的业务流程： 登录的处理流程： 1、登录页面提交用户名密码。 2、登录成功后生成tok
SSO单点登录原理详解
Yilong18的博客
12-06 3134
sso单点登录
单点登录 cas 设置回调地址_单点登录（SSO）看这一篇就够了
weixin_39875629的博客
11-21 1327
背景在企业发展初期，企业使用的系统很少，通常一个或者两个，每个系统都有自己的登录模块，运营人员每天用自己的账号登录，很方便。但随着企业的发展，用到的系统随之增多，运营人员在操作不同的系统时，需要多次登录，而且每个系统的账号都不一样，这对于运营人员来说，很不方便。于是，就想到是不是可以在一个系统登录，其他系统就不用登录了呢？这就是单点登录要解决的问题。单点登录英文全称Single Sign On，简...
SSO单点登录
JavaBoy的博客
03-01 304
原文链接：mp.weixin.qq.com 概念 SSO 英文全称 Single Sign On，单点登录。 在多个应用系统中，只需要登录一次，就可以访问其他相互信任的应用系统。 比如：淘宝网（www.taobao.com），天猫网（www.tmall.com），聚划算（ju.taobao.com），飞猪网（www.fliggy.com）等，这些都是阿里巴巴集团的网站。在这些网站中，我们在其中一个...
基于JWT实现SSO单点登录流程图解
08-18
基于JWT实现SSO单点登录流程图解 基于JWT实现SSO单点登录流程图解是指使用JSON Web Token（JWT）来实现单点登录（SSO）的机制。在这种机制中，用户只需要登录一次，就可以访问多个应用服务器上的资源，而不需要再次...
Spring Security基于JWT实现SSO单点登录详解
08-25
Spring Security 基于 JWT 实现 SSO 单点登录详解 基于 Spring Security 框架和 JWT（JSON Web Token）技术，可以实现 SSO（Single Sign-On）单点登录系统。SSO 是一种常见的身份验证机制，允许用户使用同一个...
PHP 使用TP5.0 实现SSO单点登录
07-28
因为公司要实现SSO单点登录的效果，最近在网上找了一些资料，但是都没有好用的， 所以自己用PHP 使用TP5.0 实现了SSO单点登录，可以跨多个域名。 下载后在本地配置好 A,B,C 3个网站，就可以模拟效果了。
jwt手写SSO单点登录框架zip
07-02
在这个"jwt手写SSO单点登录框架zip"中，开发者手动实现了基于JWT的SSO解决方案。这个实践项目旨在帮助我们理解SSO的工作原理，并通过实际操作加深对JWT和cookie的运用。 首先，我们需要了解JWT的基本结构。JWT由三...
js实现RSA加密
08-27
js实现的RSA算法，将这个js文件引入jsp文件，即可使用。 var encryptionExponent ="XXX"; var modulus = "XXX"; var key = RSAUtils.getKeyPair(encryptionExponent ,"",modulus ); console.log("key:"+key );
sso单点登录ppt.ppt
10-30
sso单点登录ppt.ppt
单点登录（SSO）看这一篇就够了
weixin_33725807的博客
09-06 3832
背景 在企业发展初期，企业使用的系统很少，通常一个或者两个，每个系统都有自己的登录模块，运营人员每天用自己的账号登录，很方便。但随着企业的发展，用到的系统随之增多，运营人员在操作不同的系统时，需要多次登录，而且每个系统的账号都不一样，这对于运营人员来说，很不方便。于是，就想到是不是可以在一个系统登录，其他系统就不用登录了呢？这就是单点登录要解决的问题。 ...
单点登录(SSO)实战，基于非对称加密双向RSA + AES加密
weixin_44951037的博客
11-15 2930
文章目录前言非对称性加密，双向加密(RSA+AES)单点登录(SSO)解决方案 前言 关于单点登录(SSO)网上也有很多帖子，但是以我个人的角度来看，大多都是一知半解，看完一圈也还是懵的，而且基本上都是理念，实实在在的去实践的基本上没有，而且内容基本上就是一模一样，这篇文章给大家也是提供一个单点登录的解决方案，至少看完和实践完之后，你知道大概怎么去实现，我这种实现方案也只适用于两个服务之间的通信登录，但是我认为哪有那么多的大型服务通信，又不是人人项目皆淘宝 非对称性加密，双向加密(RSA+AES) 本文
用CAS实现SSO（单点登录）+数据库读取
ZQUSwansea的博客
09-07 1691
用CAS实现SSO（单点登录）+数据库读取1.什么是SSO，什么是CAS. SSO即单点登录的意思，而CAS 是 Yale 大学发起的一个开源项目，旨在为 Web 应用系统提供一种可靠的单点登录方法。2.CAS认证原理。 从结构上看，CAS 包含两个部分： CAS Server 和 CAS Client。CAS Server 需要独立部署，主要负责对用户的认证工作；CAS Cli
springcloud gateway集成JWT——实现登录鉴权
tang_seven的博客
10-24 8221
springcloud gateway基于jwt token，实现用户登录鉴权功能
jsrsasign 前端 RSA加密/解密、加签/验签 详解
热门推荐
忙碌的菠萝
12-03 1万+
RSA概述 1978年出现了著名的RSA算法，它通常是先生成一对RSA密钥，其中之一是保密密钥，由用户保存；另一个为公开密钥，可对外公开，甚至可在网络服务器中注册。为提高保密强度，RSA密钥至少为500位长，一般推荐使用1024位。 RSA允许你选择公钥的大小。512位的密钥被视为不安全的；768位的密钥不用担心受到除了国家安全管理（NSA）外的其他事物的危害；1024位的密钥几乎是安全的。RSA在一些主要产品内部都有嵌入，像 Windows、网景 Navigator、 Quicken和 Lotus Not
前端使用jsrsasign签名和验签，加密解密
最新发布
qq_41539461的博客
03-01 1202
/ 传入key实例, 初始化signature实例。// 方式1: 先建立 key 对象。// 创建 Signature 对象。// 签名, 得到16进制字符结果。
前端js使用jsrsasign，生成RSA秘钥，获取一系列信息（公钥，私钥，模数，指数等）进行加密解密
weixin_44655037的博客
09-07 6764
之前的项目里用的RSA加解密的时候是生成固定的公钥（模数，指数）和私钥放在代码里进行数据的解密。现在要修改成前端自己生成（模数和指数）传给后台。后面查了很多，开始的window.crypto里的方法可以生成公钥和私钥，但是这个只能在浏览器中使用，没办法在小程序中使用。所以选择使用这个了。n 是 计算n的欧拉函数φ(n)的得到的数，也被我们称为模数。上面是根据我这边的需要的需求的格式进行获取的。如果你的需要和这不一样的话，进行数据转换即可。简单的来说生成秘钥的过程中，生成到的几个数。rsa的简单的知识介绍。
Spring Security JWT教程：SSO单点登录实战演示
本文将深入解析Spring Security如何结合JWT（JSON Web Tokens）实现Single Sign-On (SSO) 单点登录功能。首先，让我们了解一下什么是SSO。SSO是一种用户管理技术，允许用户在一个应用或系统中进行身份验证后，在其他...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值