单点登录——无状态登录JWT+RSA+遇到的坑

蔚落 2024-04-17 05:58 62阅读 0赞

## 先说有状态登录 ##

tomcat中，把用户的登录信息保存在服务端的session中，再给用户一个cookie值。记录对应的session值，下次客户端带cookie来访问时，再识别对应的session找到用户的信息。  
**缺点：**

*  服务器的负荷变大，保存大量的session数据。
 *  搭建集群，跨服务将无法识别身份。

## 无状态登录 ##

服务器不保存用户的登录信息，由客户端请求携带自己的身份信息。服务器不再保存用户的登录信息，多次请求不用访问回到同一台服务，服务器可以弹性伸缩，减小服务端压力，缺点一旦JWT签发，在有效期内将会一直有效。

## 流程： ##

*  第一次请求访问时候，由服务器对用户进行身份验证
 *  验证通过，将身份信息加密进程token，返回给客户端，作为其访问其他服务器集群的身份凭证。
 *  每次请求携带token，服务器对其进行解密判断有效性。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Zpdmlicm8_size_16_color_FFFFFF_t_70]

### 安全问题 ###

token必须安全可靠，采用JWT + RSA非对称加密

## JWT ##

json web token轻量级的授权和身份认证规范.  
JWT包含三部分  
Header: base64加密可解密加密，不要存放关键信息

1.  声明类型:“tpy”:“JWT”,
2.  加密算法:“alg”:“RS256”

PayLoad:存放有效数据，不写死，base64加密可解密加密,根据需要来写。  
举例：

*  用户名信息 “name”:“zhangsan”,
 *  权限信息 “admin”：“true”
 *  签发时间 “iat”:“1516239022”
 *  iss：发行人
 *  exp：到期时间
 *  sub：主题
 *  aud：用户
 *  nbf：在此之前不可用
 *  jti：JWT ID用于标识该JWT

Signature：签名 RSA非对称加密，无密钥无法解密，只能验证。  
RSASHA256(baseUrlEncode(header)+"."+base64UrlEncode(payload),秘钥)  
先对原header及payload信息有效性进行加密。

## 无RSA加密![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Zpdmlicm8_size_16_color_FFFFFF_t_70 1] ##

## RSA加密 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Zpdmlicm8_size_16_color_FFFFFF_t_70 2]

如果通过md5加密，网关需要每次访问授权中心去通信验证，微服务需要多次访问授权中心去解密jwt，网络请求频率高，授权中心压力过大。而通过非对称加密则不存在这个问题。用公钥即可解密header与payload。

--------------------

token放入cookie跨域的问题：  
在setcookie时候，domain会将RequestUrl截取，并设定为token的域。  
因为反向代理的缘故，nginx会自动将原请求，转发到网关Zuul上，网关再转发到服务上。所以这里有两次修改Host。  
解决方法：  
1.更改nginx配置，让它不要修改我们的host：\`proxy\_set\_header Host $host;  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Zpdmlicm8_size_16_color_FFFFFF_t_70 3]  
2.Zuul还会有一次转发，所以要去修改网关的配置

add-host-header: true #携带请求本身的header信息

此时响应中就会有set-cookie这一项  
再来Zuul会过滤，铭感词  
sensitive-headers设置为空。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Zpdmlicm8_size_16_color_FFFFFF_t_70 4]  
每次解析token的时候，给页面重新setcookie，防止使用时过期。  
退出登陆的实现可直接由前端删除对应token。  
加密解密代码：

public class JwtUtils {
    
    
        /**
         * 私钥加密成token
         *
         * @param userInfo      载荷中的数据
         * @param privateKey    私钥
         * @param expireMinutes 过期时间，单位秒
         * @return
         * @throws Exception
         */
        public static String generateToken(UserInfo userInfo, PrivateKey privateKey, int expireMinutes) throws Exception {
            return Jwts.builder()
                    .claim(JwtConstans.JWT_KEY_ID, userInfo.getId())
                    .claim(JwtConstans.JWT_KEY_USER_NAME, userInfo.getUsername())
                    .setExpiration(DateTime.now().plusDays(expireMinutes).toDate())
                    .signWith(SignatureAlgorithm.RS256, privateKey)
                    .compact();
        }
    
        /**
         * 私钥加密token
         *
         * @param userInfo      载荷中的数据
         * @param privateKey    私钥字节数组
         * @param expireMinutes 过期时间，单位秒
         * @return
         * @throws Exception
         */
        public static String generateToken(UserInfo userInfo, byte[] privateKey, int expireMinutes) throws Exception {
            return Jwts.builder()
                    .claim(JwtConstans.JWT_KEY_ID, userInfo.getId())
                    .claim(JwtConstans.JWT_KEY_USER_NAME, userInfo.getUsername())
                    .setExpiration(DateTime.now().plusMinutes(expireMinutes).toDate())
                    .signWith(SignatureAlgorithm.RS256, RsaUtils.getPrivateKey(privateKey))
                    .compact();
        }
        /**
         * 公钥解析token
         *
         * @param token     用户请求中的token
         * @param publicKey 公钥
         * @return
         * @throws Exception
         */
        private static Jws<Claims> parserToken(String token, PublicKey publicKey) {
            return Jwts.parser().setSigningKey(publicKey).parseClaimsJws(token);
        }
    
        /**
         * 公钥解析token
         *
         * @param token     用户请求中的token
         * @param publicKey 公钥字节数组
         * @return
         * @throws Exception
         */
        private static Jws<Claims> parserToken(String token, byte[] publicKey) throws Exception {
            return Jwts.parser().setSigningKey(RsaUtils.getPublicKey(publicKey))
                    .parseClaimsJws(token);
        }
    
        /**
         * 获取token中的用户信息
         *
         * @param token     用户请求中的令牌
         * @param publicKey 公钥
         * @return 用户信息
         * @throws Exception
         */
        public static UserInfo getInfoFromToken(String token, PublicKey publicKey) throws Exception {
            Jws<Claims> claimsJws = parserToken(token, publicKey);
            Claims body = claimsJws.getBody();
            return new UserInfo(
                    ObjectUtils.toLong(body.get(JwtConstans.JWT_KEY_ID)),
                    ObjectUtils.toString(body.get(JwtConstans.JWT_KEY_USER_NAME))
            );
        }
    
        /**
         * 获取token中的用户信息
         *
         * @param token     用户请求中的令牌
         * @param publicKey 公钥
         * @return 用户信息
         * @throws Exception
         */
        public static UserInfo getInfoFromToken(String token, byte[] publicKey) throws Exception {
            Jws<Claims> claimsJws = parserToken(token, publicKey);
            Claims body = claimsJws.getBody();
            return new UserInfo(
                    ObjectUtils.toLong(body.get(JwtConstans.JWT_KEY_ID)),
                    ObjectUtils.toString(body.get(JwtConstans.JWT_KEY_USER_NAME))
            );
        }
    
    
        public abstract class JwtConstans {
            public static final String JWT_KEY_ID = "id";
            public static final String JWT_KEY_USER_NAME = "username";
        }
    }

公钥私钥的生成与获取

package com.vivi.utils;
    
    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：公钥的字节形式
         * @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(1024, 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);
        }
    }

载荷工具类

public class ObjectUtils {
    
        public static String toString(Object obj) {
            if (obj == null) {
                return null;
            }
            return obj.toString();
        }
    
        public static Long toLong(Object obj) {
            if (obj == null) {
                return 0L;
            }
            if (obj instanceof Double || obj instanceof Float) {
                return Long.valueOf(StringUtils.substringBefore(obj.toString(), "."));
            }
            if (obj instanceof Number) {
                return Long.valueOf(obj.toString());
            }
            if (obj instanceof String) {
                return Long.valueOf(obj.toString());
            } else {
                return 0L;
            }
        }
    
        public static Integer toInt(Object obj) {
            return toLong(obj).intValue();
        }
    }

登录授权以及验证token

/**
         * 登录授权功能
         * @param username
         * @param password
         * @return
         */
        @PostMapping("login")
        public ResponseEntity<Void> login(@RequestParam("username")String username,
                                          @RequestParam("password")String password,
                                          HttpServletResponse response, HttpServletRequest request){
    //        生成token
            String token = authService.login(username,password);
            if (StringUtils.isBlank(token)) {
                return new ResponseEntity<>(HttpStatus.UNAUTHORIZED);
            }
    //        写入cookie token
            CookieUtils.setCookie(request, response,prop.getCookieName() , token, false);
    //        response.addCookie(new Cookie("DG_TOKEN",token));
            return ResponseEntity.status(HttpStatus.OK).build();
        }
    
        /**
         * 验证token信息，并更新token时效。
         * @param token
         * @return
         */
        @GetMapping("verify")
        public ResponseEntity<UserInfo> verifyUser(@CookieValue("DG_TOKEN")String token,
                                                   HttpServletRequest request,
                                                   HttpServletResponse response){
            try {
                UserInfo userInfo = JwtUtils.getInfoFromToken(token, prop.getPublicKey());
                // 解析成功要重新生成token
                String newToken = JwtUtils.generateToken(userInfo, prop.getPrivateKey(), prop.getExpire());
                // 更新cookie中的token
                CookieUtils.setCookie(request, response, prop.getCookieName(), newToken,false);
                return ResponseEntity.ok(userInfo);
            }catch (Exception e){
                throw new DgException(ExceptionEnum.UNAUTHORIZED);
            }
        }

cookie工具类

package com.vivi.common.utils;
    
    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 {
    
    	protected 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的值 不设置生效时间默认浏览器关闭即失效,也不编码
    	 */
    	public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName, String cookieValue) {
    		setCookie(request, response, cookieName, cookieValue, -1);
    	}
    
    	/**
    	 * 设置Cookie的值 在指定时间内生效,但不编码
    	 */
    	public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName, String cookieValue, int cookieMaxage) {
    		setCookie(request, response, cookieName, cookieValue, cookieMaxage, false);
    	}
    
    	/**
    	 * 设置Cookie的值 不设置生效时间,但编码
    	 */
    	public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName, String cookieValue, boolean isEncode) {
    		setCookie(request, response, cookieName, cookieValue, -1, isEncode);
    	}
    
    	/**
    	 * 设置Cookie的值 在指定时间内生效, 编码参数
    	 */
    	public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName, String cookieValue, int cookieMaxage, boolean isEncode) {
    		doSetCookie(request, response, cookieName, cookieValue, cookieMaxage, isEncode);
    	}
    
    	/**
    	 * 设置Cookie的值 在指定时间内生效, 编码参数(指定编码)
    	 */
    	public static void setCookie(HttpServletRequest request, HttpServletResponse response, String cookieName, String cookieValue, int cookieMaxage, String encodeString) {
    		doSetCookie(request, response, cookieName, cookieValue, cookieMaxage, encodeString);
    	}
    
    	/**
    	 * 删除Cookie带cookie域名
    	 */
    	public static void deleteCookie(HttpServletRequest request, HttpServletResponse response, String cookieName) {
    		doSetCookie(request, response, cookieName, "", -1, false);
    	}
    
    	/**
    	 * 设置Cookie的值，并使其在指定时间内生效
    	 * 
    	 * @param cookieMaxage
    	 *            cookie生效的最大秒数
    	 */
    	private static final void doSetCookie(HttpServletRequest request, HttpServletResponse response, String cookieName, String cookieValue, int cookieMaxage, boolean isEncode) {
    		try {
    			if (cookieValue == null) {
    				cookieValue = "";
    			} else if (isEncode) {
    				cookieValue = URLEncoder.encode(cookieValue, "utf-8");
    			}
    			Cookie cookie = new Cookie(cookieName, cookieValue);
    			if (cookieMaxage > 0)
    				cookie.setMaxAge(cookieMaxage);
    			if (null != request)// 设置域名的cookie
    				cookie.setDomain(getDomainName(request));
    			cookie.setPath("/");
    			response.addCookie(cookie);
    		} catch (Exception e) {
    			logger.error("Cookie Encode Error.", e);
    		}
    	}
    
    	/**
    	 * 设置Cookie的值，并使其在指定时间内生效
    	 * 
    	 * @param cookieMaxage
    	 *            cookie生效的最大秒数
    	 */
    	private static final void doSetCookie(HttpServletRequest request, HttpServletResponse response, String cookieName, String cookieValue, int cookieMaxage, String encodeString) {
    		try {
    			if (cookieValue == null) {
    				cookieValue = "";
    			} else {
    				cookieValue = URLEncoder.encode(cookieValue, encodeString);
    			}
    			Cookie cookie = new Cookie(cookieName, cookieValue);
    			if (cookieMaxage > 0)
    				cookie.setMaxAge(cookieMaxage);
    			if (null != request)// 设置域名的cookie
    				cookie.setDomain(getDomainName(request));
    			cookie.setPath("/");
    			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;
    	}
    
    }

# 遇到的问题，domain。 #

cookieUtil类在setcookie将domain设置的域为host截取后的域。  
1.nginx方向代理时，将host修改为代理后的网关，所以需要在nginx里面设置带上原来的host。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Zpdmlicm8_size_16_color_FFFFFF_t_70 5]2.zuul网关还有一次转发，需要在配置文件中添加运来的host  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Zpdmlicm8_size_16_color_FFFFFF_t_70 6]  
3.zuul网关内部有铭感头过滤“SensitiveHeaders”，默认setcookie为铭感操作。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Zpdmlicm8_size_16_color_FFFFFF_t_70 7]  
需要在配置文件中将其设置为空。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Zpdmlicm8_size_16_color_FFFFFF_t_70 8]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Zpdmlicm8_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/35378bdc360d4597b6b4d189a9ef005e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Zpdmlicm8_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/5163f62f83e64e2986ee97d4c378e77c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Zpdmlicm8_size_16_color_FFFFFF_t_70 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/7add427ed0c349d7ad0a9b953822a603.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Zpdmlicm8_size_16_color_FFFFFF_t_70 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/7c8e9bf2d152470c87dba33da594488f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Zpdmlicm8_size_16_color_FFFFFF_t_70 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/1dbf35562bcc4275a4482d8dfc928636.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Zpdmlicm8_size_16_color_FFFFFF_t_70 5]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/60fb77534d2140f18ff6f5cd1172ca76.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Zpdmlicm8_size_16_color_FFFFFF_t_70 6]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/f5c92e2a09e84ab895db9edd24e0198f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Zpdmlicm8_size_16_color_FFFFFF_t_70 7]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/47ea26e19a9343cf91be8b5084834dc4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Zpdmlicm8_size_16_color_FFFFFF_t_70 8]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/15/e9cfd136d13d412596534bfbb2ea630b.png