接口鉴权实践-代码

男娘i 2023-02-25 02:26 127阅读 0赞

### 文章目录 ###

*   *  目标
     *  接口设计
     *  认证鉴权服务
     *  代码实践
     *   *  声明鉴权注解
         *  鉴权注解的具体实现
         *  鉴权服务
         *  被鉴权注解修饰的公共接口
     *  加密解密
     *   *  代码
     *  其他

## 目标 ##

*  接口鉴权的代码实践
    
    参考：[HandlerMethodArgumentResolver用于统一获取当前登录用户][HandlerMethodArgumentResolver]
    
    [springboot自定义参数解析HandlerMethodArgumentResolver][springboot_HandlerMethodArgumentResolver]
    
    [WebMvcConfigurer.addArgumentResolvers自定义参数处理器不生效的原理与解决方案][WebMvcConfigurer.addArgumentResolvers]
    
    [百度api-鉴权认证机制][api-]
    
    [鉴权认证机制][Link 1]
    
    [字节数组与16进制字符串的相互转换][16]
    
    [spring几种获取 HttpServletRequest 对象的方式][spring_ HttpServletRequest]
    
    [AES自动生成base64密钥加密解密][AES_base64]

## 接口设计 ##

业务场景：模拟普通用户调用公共接口

业务细节：

此公共接口要求只允许普通用户调用10次。

此接口要求**验证请求者的身份**，**保护传输中的数据，防止非法篡改**，**防止重放攻击**。

实现思路：

用户需要携带认证token，认证字符串（签名），请求参数，请求公共接口。

token ：用户通过登录，手机验证码等方法调用系统，颁发的认证标识。（验证请求者身份）

签名（sign）：将请求参数和随机码（reqnum）和有效时间（timespace）拼接，根据密钥（signkey ）加密得到。（保护传输中的数据，防止非法篡改，防止重复攻击）

鉴权服务检查token的合法性有效性，根据签名检查请求参数没有被非法篡改，根据签名中的有效时间来防止在有效时间外来重放请求。

简单流程图：

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

## 认证鉴权服务 ##

*  认证服务
    
    最常见的就是使用用户名密码进行登录，在传统web项目中使用session来保证是同一会话，在微服务的架构中，常用redis来保存用户信息，来模拟session的作用。redis的单点登陆，实践参考:https://github.com/gengzi/GsjBlog 关注interceptor 和UserController 包下的代码。
 *  鉴权服务
    
    鉴权需要在执行真正controller接口方法之前执行，之前的web项目一般使用拦截器（Interceptor）或者过滤器（Filter）来实现请求的拦截，校验session是否存在，不存在即用户登陆失效，让用户重新登陆。基于springboot工程，可以使用注解（annotation），webmvcconfig的形式来针对请求拦截的处理，来实现鉴权服务。

## 代码实践 ##

项目源码地址：https://github.com/gengzi/codecopy

版本环境 ：jdk1.8，Spring boot 2.2.7，mysql5.7，reids

上述已经说明了思路和一般常见的实现方式。

下面通过注解的方式，来实现。使得被注解修饰的controller接口，进行鉴权操作。

如果希望与所有的接口或者很多接口都执行鉴权操作，可以使用webmvcconfig配置对方法的处理。在参考的一些文章中，有具体说明。

### 声明鉴权注解 ###

fun.gengzi.codecopy.aop.BusinessAuthentication

/** * <h1>接口鉴权注解</h1> * 用于标识那些controller 接口需要鉴权才能调用 * * @author gengzi * @date 2020年6月4日16:43:30 * <p> * 对于接口鉴权，也可以使用 拦截器，过滤器，指定那些路径进行拦截。 */
    @Target({ ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface BusinessAuthentication { 
        /** * 调用次数限定 默认 -1 不限制次数 * @return */
        int callNumber() default -1;
    
    // /**
    // * ip 限定，限定指定范围的ip地址，访问该接口
    // *
    // * @return
    // */
    // String[] IPLimit() default {};
    }

### 鉴权注解的具体实现 ###

fun.gengzi.codecopy.aop.BusinessAuthenticationAspect

采用aop的思想，为添加了鉴权注解的方法，增强功能

/** * <h1>接口鉴权校验 aop</h1> */
    @Aspect
    @Configuration
    public class BusinessAuthenticationAspect { 
    
        private Logger logger = LoggerFactory.getLogger(BusinessAuthenticationAspect.class);
    
        // 鉴权服务接口url地址
        @Value("${token.url.validToken}")
        private String validToken;
        // AES 密钥
        @Value("${token.aeskey}")
        private String aeskey;
    
        // RSA 的密钥
        @Value("${token.publickey}")
        private String publickey;
    
        //切入点
        @Pointcut("@annotation(fun.gengzi.codecopy.aop.BusinessAuthentication)")
        public void BusinessAuthenticationAspect() { 
    
        }
    
        /** * <h2>环绕通知</h2> * // 根据controller 配置的注解，执行该方法 * // 获取请求信息中的 token 校验，存在，执行 token 校验，不存在，阻断 * // 校验 token ，失败，阻断 * // 获取该注解配置的字段信息 * // 校验该用户是否还有调用次数 ， 无 ，阻断 * // 校验该用户是否在允许的ip 范围， 无，阻断 * // 放行 * * @param joinPoint * @return */
        @Around("BusinessAuthenticationAspect()")
        public Object around(ProceedingJoinPoint joinPoint) { 
            logger.info("鉴权 - BusinessAuthenticationAspect start");
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            Method method = signature.getMethod();
            BusinessAuthentication businessAuthentication = method.getAnnotation(BusinessAuthentication.class);
            ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
            HttpServletRequest request = attributes.getRequest();
            // 校验token 是否有效
            final String token = request.getHeader(HttpHeaders.AUTHORIZATION);
            // 获取controller 方法名称
            final String name = method.getName();
            logger.info("被鉴权的方法 - BusinessAuthenticationAspect method name : {}", name);
            // 如果没有 token，进行记录并抛出异常，响应前台
            if (StringUtils.isBlank(token)) { 
                logger.info("无token结束 - BusinessAuthenticationAspect no token, end !");
                throw new RrException("无权限", RspCodeEnum.NOTOKEN.getCode());
            }
            // 调用鉴权服务接口，鉴权
            Boolean flag = reqValidToken(businessAuthentication, token);
            Object obj;
            try { 
                if (flag) { 
                    // 鉴权成功，允许调用指定接口
                    logger.info("鉴权成功 - BusinessAuthenticationAspect success !");
                    obj = joinPoint.proceed();
                } else { 
                    logger.info("鉴权失败- BusinessAuthenticationAspect failure !");
                    throw new RrException("无权限");
                }
            } catch (Throwable e) { 
                logger.error("鉴权失败，出现异常- BusinessAuthenticationAspect failure ! , exception : {} ", e.getMessage());
                throw new RrException("无权限");
            }
            return obj;
        }
    
        /** * <h2>调用接口鉴权服务</h2> * <p> * // 调用鉴权服务，进行 token 校验，并返回该用户信息 * // 先定义 aes 秘钥，定义 rsa 的公钥和秘钥 * // 使用 aes 秘钥对 组装后的参数加密，再base64 转码 生成一个签名 * // 调用服务端， token 设置在请求头，请求体是 签名 ， 其他固定的几个参数 * <p> * // 服务端校验 token， 解析请求体参数，将签名 使用 base64 解开，然后 aes 解密 * // 解密完成，比较 参数是否一致，一致说明，参数没有在传递时发生更改。 * // 服务端鉴权完毕，响应数据，将数据使用 rsa 私钥加密，使用base64 转码 * <p> * // 客户端获取响应数据，对应字段使用base64 转码，使用 rsa 公钥解密，解密完成，正式成功 * * @param businessAuthentication 注解 * @param token 认证token * @return 鉴权成功 true ，鉴权失败 false */
        private Boolean reqValidToken(BusinessAuthentication businessAuthentication, String token) { 
            ConcurrentHashMap<String, String> concurrentHashMap = new ConcurrentHashMap<>();
            StringBuilder signBuilder = new StringBuilder();
            // 获取注解中的字段
            final int callNumber = businessAuthentication.callNumber();
            // 随机码
            String reqNum = IdUtil.randomUUID();
            // 组拼参数，例如： reqNum=uuid值&callNumber=33&
            if (callNumber > 0) { 
                concurrentHashMap.put(AuthenticationConstans.CALLNUMBER, String.valueOf(callNumber));
            }
            concurrentHashMap.put(AuthenticationConstans.REQNUM, reqNum);
            concurrentHashMap.forEach((key, value) -> signBuilder.append(key).append("=").append(value).append("&"));
            // 将参数加密
            String signStr = AESUtils.encrypt(signBuilder.toString(), aeskey)
                    .orElseThrow(() -> new RrException("error", RspCodeEnum.FAILURE.getCode()));
            // 调用鉴权服务接口
            logger.info("调用鉴权接口参数- BusinessAuthenticationAspect qryParams token :{},reqNum :{} ,signStr :{}", token, reqNum, signStr);
            ReturnData returnData = getReturnData(token, reqNum, signStr);
            logger.info("调用鉴权接口结果- BusinessAuthenticationAspect result", returnData.toString());
    
            Boolean flag = false;
            if (RspCodeEnum.SUCCESS.getCode() == returnData.getStatus()) { 
                Object info = returnData.getInfo();
                if(info instanceof JSONObject){ 
                    TokenUserInfoResp.UserinfoData userinfoData = JSONUtil.toBean((JSONObject) info, TokenUserInfoResp.UserinfoData.class);
                    String certificateNo = userinfoData.getCertificateNo();
                    // RSA 解密
                    String certificateNoDecrpt = RSAUtils.decrypt(certificateNo, publickey).orElseThrow(() -> new RrException("error"));
                    if (callNumber == -1 || callNumber >=  Integer.valueOf(certificateNoDecrpt) ){ 
                        flag = true;
                    }
                }
            }
            return flag;
        }
    
        /** * 调用鉴权服务接口 * * @param token token * @param reqNum 随机码 * @param signStr 签名 * @return {@link ReturnData} */
        private ReturnData getReturnData(String token, String reqNum, String signStr) { 
            // 封装请求参数
            RequestParamEntity requestParamEntity = new RequestParamEntity();
            requestParamEntity.setReqNum(reqNum);
            requestParamEntity.setSign(signStr);
            String jsonBody = JSONUtil.parseObj(requestParamEntity, false).toStringPretty();
            String body = HttpRequest.post(validToken)
                    .header(Header.AUTHORIZATION, token)
                    .body(jsonBody).execute().body();
            return JSONUtil.toBean(body, ReturnData.class);
        }
    
    }

### 鉴权服务 ###

fun.gengzi.codecopy.business.authentication.controller.AuthenticationController

/** * <h1>接口鉴权controller</h1> * * @author gengzi * @date 2020年6月5日10:42:08 */
    @Api(value = "接口鉴权", tags = { "接口鉴权"})
    @Controller
    @RequestMapping("/api/v1")
    public class AuthenticationController { 
        private Logger logger = LoggerFactory.getLogger(AuthenticationController.class);
    
        // RSA 的密钥
        @Value("${token.secretkey}")
        private String secretkey;
    
        private final AuthenticationService authenticationService;
    
        public AuthenticationController(AuthenticationService authenticationService) { 
            this.authenticationService = authenticationService;
        }
    
    
        @ApiOperation(value = "校验token", notes = "校验token")
        @ApiImplicitParams({ 
                @ApiImplicitParam(name = "RequestParamEntity", value = "请求参数实体", required = true)})
        @ApiResponses({ @ApiResponse(code = 200, message = "\t{\n" +
                "\t \"status\": 200,\n" +
                "\t \"info\": {\n" +
                "\t }\n" +
                "\t \"message\": \"success\",\n" +
                "\t}\n")})
        @PostMapping("/validToken")
        @ResponseBody
        public ReturnData validToken(@RequestBody RequestParamEntity requestParamEntity, HttpServletRequest request) { 
            ReturnData ret = ReturnData.newInstance();
            final String token = request.getHeader(HttpHeaders.AUTHORIZATION);
            // 校验token 是否有效
            Boolean validToken = authenticationService.isValidToken(token);
            if(validToken){ 
                // 校验签名
                Boolean validSign = authenticationService.isValidSign(requestParamEntity);
                if(validSign){ 
                    // 根据token 获取用户信息，响应
                    // TODO 默认响应一个，该用户调用的次数，写死 10
                    TokenUserInfoResp.UserinfoData userinfoData = new TokenUserInfoResp.UserinfoData();
                    // 将返回字段都进行 rsa 加密
                    String numNo = RSAUtils.encrypt("1", secretkey).orElse("");
                    userinfoData.setCertificateNo(numNo);
                    ret.setSuccess();
                    ret.setInfo(userinfoData);
                    ret.setMessage("success");
                    return ret;
                }
            }
            ret.setFailure("failure");
            return ret;
        }
    
    }

### 被鉴权注解修饰的公共接口 ###

fun.gengzi.codecopy.business.shorturl.controller.ShortUrlGeneratorController

当调用此接口时，先执行鉴权注解的方法，如果鉴权成功，再执行真正的目标接口。

@PostMapping("/getShortUrlByTest")
        @ResponseBody
        @BusinessAuthentication(callNumber = 10)
        public ReturnData testgeneratorShortUrl(@RequestParam("longurl") String longurl) { 
            logger.info("getShortUrl start {} ", System.currentTimeMillis());
            String shortUrl = shortUrlGeneratorService.generatorShortUrl(longurl);
            ReturnData ret = ReturnData.newInstance();
            ret.setSuccess();
            ret.setMessage(shortUrl);
            return ret;
        }

## 加密解密 ##

上述在鉴权注解aop和鉴权服务中，分别使用两种加密方式，RSA 非对称加密，AES 对称加密。

对称加密

[非对称加密][Link 2]

在响应给前端的一些数据中，也可以使用DSA加密后，响应，考虑脱敏后再响应。

其中在加密解密中，还使用base64 转码，为什么要使用base64 ，因为AES 和 RSA 加密后的数据都是字节数组，base64可以将字节数组转为字符串，方便于传输数据。

### 代码 ###

使用了 httool 工具类，参考github

fun.gengzi.codecopy.utils.AESUtils

fun.gengzi.codecopy.utils.RSAUtils

## 其他 ##

对于完善的接口设计，上述内容还是太薄弱。可以参考大厂官方api接口的设计，更加的复杂也会更加的安全，也可以作为设计的参考。

下面是百度api的一些设计，可以参考。

[百度api-鉴权认证机制][api-]

这里关注一下请求头里面的 Authorization 认证字符串

![UESSv8.png][]

Authorization 的生成策略：

![UAzvCt.png][]

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

[HandlerMethodArgumentResolver]: https://blog.csdn.net/songzehao/article/details/99641594
[springboot_HandlerMethodArgumentResolver]: https://www.jianshu.com/p/40606baf49b8
[WebMvcConfigurer.addArgumentResolvers]: https://blog.csdn.net/weixin_42213903/article/details/101211873
[api-]: https://cloud.baidu.com/doc/Reference/s/Njwvz1wot
[Link 1]: https://ai.baidu.com/ai-doc/REFERENCE/Ck3dwjhhu
[16]: https://www.cnblogs.com/zhaoyue1215/p/10449530.html
[spring_ HttpServletRequest]: https://blog.csdn.net/hellozhxy/article/details/80775832
[AES_base64]: https://www.jianshu.com/p/ff7fccc57197
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4ODE3NzM5_size_16_color_FFFFFF_t_70]: /images/20230209/ff3e81f2be7842699d6c6c7fc4529c45.png
[Link 2]: https://www.hutool.cn/docs/#/crypto/%E9%9D%9E%E5%AF%B9%E7%A7%B0%E5%8A%A0%E5%AF%86-AsymmetricCrypto?id=%E9%9D%9E%E5%AF%B9%E7%A7%B0%E5%8A%A0%E5%AF%86-asymmetriccrypto
[UESSv8.png]: /images/20230209/2e81d56cd0ed4fa595f6993be8b37a72.png
[UAzvCt.png]: /images/20230209/4d874c68fd2f4816b80cc5983645642f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4ODE3NzM5_size_16_color_FFFFFF_t_70 1]: /images/20230209/a297830c9f714632b9ec860c0d96e68f.png