接口层面的安全措施

最新推荐文章于 2024-08-15 17:27:32 发布

技术熊

最新推荐文章于 2024-08-15 17:27:32 发布

阅读量1.1k

点赞数 2

分类专栏：安全文章标签：服务器网络安全接口 web安全

本文链接：https://blog.csdn.net/u013513053/article/details/108201092

版权

安全专栏收录该内容

4 篇文章 0 订阅

订阅专栏

验签机制：

是什么（what）

验签机制是一种安全校验机制，通过代码层面进行修改，提高安全性。在请求中添加一些安全校验的参数进行校验，防止参数被篡改。同时可以引入时间戳，可以控制接口的时效性。自定义的验签规则以及验签的额外参数，也可以校验请求方是否合法。

在什么场景下用（where）

当对接口有一定的安全性要求，且非公开接口一般都可以使用该方式。比如自己app的接口，网页的接口，服务间的接口等。

什么时候用（when）

当发起请求时，进行验签计算，将验签结果和时间戳等参数加到请求中。服务端接收到请求时，可以用拦截器统一处理。对验签进行校验，然后再进行下一步操作。

怎么用（how）

重头戏在这，该如何使用验签

验签的机制是，将参数进行某个规则的加密，这个规则只有你的服务端和客户端知道，参数中除了正常的请求参数外，多了一个验签参数 sign。后台拿到请求参数后，可以将参数用同样的方法加密，然后与sign比对，如果一致就认为没有被篡改。

请求参数和时间戳一起加密，因为时间戳是变化的，所以说加密出来的结果也是变化的。同时请求参数中带着时间戳参数，服务端可以根据时间戳来限制单次请求的有效时间，比如说单次请求1分钟内有效。那么之后的请求，就算原封不动的拿过来，因为时间戳的限制，不是当时的请求就是无效的，获取不到数据。然而要修改参数中的时间戳，又跟加密验签sign不一致，也得不到返回。

服务端个客户端都是我们自己的程序，或者说都是我们授权的。那么我就可以在服务端设置一个参数secret。然后我们把secret告诉给客户端。当然不是走网络请求，而是通过线下的方式，比如说发邮件啊啥的。然后客户端会把secret存在自己本地，服务器也存一个secret。加密的时候，将secret拼接在要加密的字符串上，secret本身不进行网络传输。这样，在原文中就有一个不可见的字符，别人通过网络也拿不到真正的原文。这样破解起来就不容易了

我们还可以设置加密秘钥，服务端和客户端知道，也不参与传输。这样也更安全。而且加密不用选择对称加密，采用MD5这种非对称加密就可以，因为服务器不需要解密，服务器只用通过相同的加密规则得到一个相同的结果就可以了

然后还有数字签名，其实本质上是一样的，但数字签名更加规范一些。简单来说就是通过提供可鉴别的数字信息验证自身身份的一种方式。一套数字签名通常定义两种互补的运算，一个用于签名，另一个用于验证。分别由发送者持有能够代表自己身份的私钥 (私钥不可泄露),由接受者持有与私钥对应的公钥，能够在接受到来自发送者信息时用于验证其身份。

附代码：spring boot 拦截器实现

拦截器配置

@Configuration
public class ApiConfig implements WebMvcConfigurer {

    @Autowired
    private ApiInterceptor apiInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //注册TestInterceptor拦截器
        InterceptorRegistration registration = registry.addInterceptor(apiInterceptor);
        registration.addPathPatterns("/api/**");                      //所有路径都被拦截
    }
}

拦截器实现

@Slf4j
@Component
public class ApiInterceptor implements HandlerInterceptor {

    @Value("${api.secret}")
    private String secret;

    /**
     * 在请求处理之前进行调用（Controller方法调用之前）
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        try {
            log.info("请求参数：" + JSON.toJSONString(request.getParameterMap()));
            // 校验请求时间，三分钟以内  获取当前时间戳
            int nowTimestamp = (int) (System.currentTimeMillis() / 1000);
            // 获取发起请求时的时间戳
            int requestTimestamp = Integer.parseInt(request.getParameter("timestamp"));
            // 如果请求时间超过3分钟则请求无效
            if (Math.abs(nowTimestamp - requestTimestamp) > 3 * 60) {
                AjaxResult ajaxResult = AjaxResult.error("请求时间无效");
                ServletUtils.renderString(response, JSON.toJSONString(ajaxResult));
                return false;
            }
            StringBuilder sb = new StringBuilder();
            sb.append(secret);

            // 将发送请求页面中form表单里所有具有name属性的表单对象获取(包括button).返回一个Enumeration类型的枚举
            Enumeration<String> params = request.getParameterNames();
            while (params.hasMoreElements()) {
                String paramName = params.nextElement();
                // 过滤掉时间戳和sign这两个属性
                if (!paramName.equals("timestamp") && !paramName.equals("sign")) {
                    sb.append(paramName);
                    sb.append("=[");
                    sb.append(request.getParameter(paramName));
                    sb.append("]");
                }
            }
            sb.append(requestTimestamp);
            log.info("验签加密前：" + sb);

            String resultString = MD5Util.md5(sb.toString());
            log.info("验签加密后：" + resultString);

            if (resultString.equals(request.getParameter("sign"))) {
                return true;
            }
        } catch (Exception e) {
            log.error(e.toString());
        }
        AjaxResult ajaxResult = AjaxResult.error("验签校验失败");
        ServletUtils.renderString(response, JSON.toJSONString(ajaxResult));
        return false;
    }

}

token机制：

是什么（what）

token机制也是常用的一种接口授权认证的机制。token在计算机身份认证中是令牌（临时）的意思，在词法分析中是标记的意思。一般作为邀请、登录系统使用。
当用户登录后，产生一个token，之后所有用户请求，都需要携带token。当token失效请求失败

在什么场景下用（where）

一般用在有登录场景的接口中，如app的用户登录后的一系列操作。这个也没有严格的限制，只要是涉及到用户认证的，都可以采用token机制。服务对服务间的接口，也有采用token机制的。

什么时候用（when）

当用户登录时，传参用户名密码，有时为了防止暴力破解请求，会加入验证码，或者限制ip请求次数。当用户登录请求传到后台，后台接口验证登录用户名密码，返回一个生成的token。token具有时效性，和自动延时性。后续请求都需要携带token，token验证通过则访问成功。

登录请求不是仅仅为了验证密码返回用户信息的，而是登录要管理起来后面所有跟用户权限有关的接口，不登录是不能用的。

怎么用（how）

我们登陆接口中可以加上一个token验证机制，就是说，如果登录成功，我们随机生成一串字符，把这个字符作为key，关联存储user对象。然后我们返回这个key。之后的所有请求都需要携带这个key，后面的请求过来后，先通过key查找缓存中是否有User对象。如果有，说明已经登录过了，就有权限访问，反之则没有权限访问。

同时，由于我们使用了key关联user对象，那么我们也不需要返回user对象。后面的请求也不需要携带user对象中的信息过来。因为我们缓存中已经存储了user对象，通过key查了出来，我们直接使用查出来的user对象作为参数就可以了。这样也避免了user对象的泄露。

key也可以添加有效时间的信息，比如说我们可以记录上一次请求key的时间，然后下一次请求就有了一个现在的时间。如果说登录操作有效时间是2小时，那么就可以拿现在的时间减去上一次请求的时间，得到一个差值，然后比较这个差值是否小于2小时，如果小于的话则是在有效时间内，允许请求。同时更新一下最后一次请求时间为当前时间，下一次请求继续判断。如果是超时了，就可以将缓存的user给删掉，直接返回错误，重新登录。用户退出也是一样的，删除掉缓存的user对象，那么以后的请求就找不到user对象，就不允许请求了

上代码：spring boot + spring security 实现，仅供参考。只展示关键代码，相关内容不再具体展示

登录控制器

/**
 * 登录验证
 * 
 * @author jdac
 */
@RestController
public class SysLoginController
{
    @Autowired
    private SysLoginService loginService;


    @Autowired
    private TokenService tokenService;

    /**
     * 登录方法
     * 
     * @param loginBody 登录信息
     * @return 结果
     */
    @PostMapping("/login")
    public AjaxResult login(@RequestBody LoginBody loginBody)
    {
        AjaxResult ajax = AjaxResult.success();
        // 生成令牌
        String token = loginService.login(loginBody.getUsername(), loginBody.getPassword(), loginBody.getCode(),
                loginBody.getUuid());
        ajax.put(Constants.TOKEN, token);
        return ajax;
    }

    /**
     * 获取用户信息
     * 
     * @return 用户信息
     */
    @GetMapping("getInfo")
    public AjaxResult getInfo()
    {
        LoginUser loginUser = tokenService.getLoginUser(ServletUtils.getRequest());
        SysUser user = loginUser.getUser();
        
        AjaxResult ajax = AjaxResult.success();
        ajax.put("user", user);
        return ajax;
    }
}

登录service方法
/**
     * 登录验证
     * 
     * @param username 用户名
     * @param password 密码
     * @param code 验证码
     * @param uuid 唯一标识
     * @return 结果
     */
    public String login(String username, String password, String code, String uuid)
    {
        boolean captchaOnOff = configService.selectCaptchaOnOff();
        // 验证码开关  这里验证码根据自己需要实现，不再进行代码展示
        if (captchaOnOff)
        {
            validateCaptcha(username, code, uuid);
        }
        // 用户验证
        Authentication authentication = null;
        try
        {
            // 该方法会去调用UserDetailsServiceImpl.loadUserByUsername
            authentication = authenticationManager
                    .authenticate(new UsernamePasswordAuthenticationToken(username, password));
        }
        catch (Exception e)
        {
            if (e instanceof BadCredentialsException)
            {
            //记录登录信息日志用，根据自身需求去实现，不再展开描述
                AsyncManager.me().execute(AsyncFactory.recordLogininfor(username, Constants.LOGIN_FAIL, MessageUtils.message("user.password.not.match")));
                throw new UserPasswordNotMatchException();
            }
            else
            {
             //记录登录信息日志用，根据自身需求去实现，不再展开描述
                AsyncManager.me().execute(AsyncFactory.recordLogininfor(username, Constants.LOGIN_FAIL, e.getMessage()));
                throw new CustomException(e.getMessage());
            }
        }
         //记录登录信息日志用，根据自身需求去实现，不再展开描述
        AsyncManager.me().execute(AsyncFactory.recordLogininfor(username, Constants.LOGIN_SUCCESS, MessageUtils.message("user.login.success")));
        
        LoginUser loginUser = (LoginUser) authentication.getPrincipal();

		//记录登录信息
        recordLoginInfo(loginUser.getUser());
        // 生成token
        return tokenService.createToken(loginUser);
    }
 	/**
     * 记录登录信息
     */
    public void recordLoginInfo(SysUser user)
    {
        user.setLoginIp(IpUtils.getIpAddr(ServletUtils.getRequest()));
        user.setLoginDate(DateUtils.getNowDate());
        userService.updateUserProfile(user);
    }

token service 相关代码


/**
 * token验证处理
 *
 * @author jdac
 */
@Component
public class TokenService
{
    // 令牌自定义标识
    @Value("${token.header}")
    private String header;

    // 令牌秘钥
    @Value("${token.secret}")
    private String secret;

    // 令牌有效期（默认30分钟）
    @Value("${token.expireTime}")
    private int expireTime;

    protected static final long MILLIS_SECOND = 1000;

    protected static final long MILLIS_MINUTE = 60 * MILLIS_SECOND;

    private static final Long MILLIS_MINUTE_TEN = 20 * 60 * 1000L;

    @Autowired
    private RedisCache redisCache;

    /**
     * 获取用户身份信息
     *
     * @return 用户信息
     */
    public LoginUser getLoginUser(HttpServletRequest request)
    {
        // 获取请求携带的令牌
        String token = getToken(request);
        if (StringUtils.isNotEmpty(token))
        {
            try
            {
                Claims claims = parseToken(token);
                // 解析对应的权限以及用户信息
                String uuid = (String) claims.get(Constants.LOGIN_USER_KEY);
                String userKey = getTokenKey(uuid);
                LoginUser user = redisCache.getCacheObject(userKey);
                return user;
            }
            catch (Exception e)
            {
            }
        }
        return null;
    }

    /**
     * 设置用户身份信息
     */
    public void setLoginUser(LoginUser loginUser)
    {
        if (StringUtils.isNotNull(loginUser) && StringUtils.isNotEmpty(loginUser.getToken()))
        {
            refreshToken(loginUser);
        }
    }

    /**
     * 删除用户身份信息
     */
    public void delLoginUser(String token)
    {
        if (StringUtils.isNotEmpty(token))
        {
            String userKey = getTokenKey(token);
            redisCache.deleteObject(userKey);
        }
    }

    /**
     * 创建令牌
     *
     * @param loginUser 用户信息
     * @return 令牌
     */
    public String createToken(LoginUser loginUser)
    {
        String token = IdUtils.fastUUID();
        loginUser.setToken(token);
        setUserAgent(loginUser);
        refreshToken(loginUser);

        Map<String, Object> claims = new HashMap<>();
        claims.put(Constants.LOGIN_USER_KEY, token);
        return createToken(claims);
    }

    /**
     * 验证令牌有效期，相差不足20分钟，自动刷新缓存
     *
     * @param loginUser
     * @return 令牌
     */
    public void verifyToken(LoginUser loginUser)
    {
        long expireTime = loginUser.getExpireTime();
        long currentTime = System.currentTimeMillis();
        if (expireTime - currentTime <= MILLIS_MINUTE_TEN)
        {
            refreshToken(loginUser);
        }
    }

    /**
     * 刷新令牌有效期
     *
     * @param loginUser 登录信息
     */
    public void refreshToken(LoginUser loginUser)
    {
        loginUser.setLoginTime(System.currentTimeMillis());
        loginUser.setExpireTime(loginUser.getLoginTime() + expireTime * MILLIS_MINUTE);
        // 根据uuid将loginUser缓存
        String userKey = getTokenKey(loginUser.getToken());
        redisCache.setCacheObject(userKey, loginUser, expireTime, TimeUnit.MINUTES);
    }

    /**
     * 设置用户代理信息
     *
     * @param loginUser 登录信息
     */
    public void setUserAgent(LoginUser loginUser)
    {
        UserAgent userAgent = UserAgent.parseUserAgentString(ServletUtils.getRequest().getHeader("User-Agent"));
        String ip = IpUtils.getIpAddr(ServletUtils.getRequest());
        loginUser.setIpaddr(ip);
        loginUser.setLoginLocation(AddressUtils.getRealAddressByIP(ip));
        loginUser.setBrowser(userAgent.getBrowser().getName());
        loginUser.setOs(userAgent.getOperatingSystem().getName());
    }

    /**
     * 从数据声明生成令牌
     *
     * @param claims 数据声明
     * @return 令牌
     */
    private String createToken(Map<String, Object> claims)
    {
        String token = Jwts.builder()
                .setClaims(claims)
                .signWith(SignatureAlgorithm.HS512, secret).compact();
        return token;
    }

    /**
     * 从令牌中获取数据声明
     *
     * @param token 令牌
     * @return 数据声明
     */
    private Claims parseToken(String token)
    {
        return Jwts.parser()
                .setSigningKey(secret)
                .parseClaimsJws(token)
                .getBody();
    }

    /**
     * 从令牌中获取用户名
     *
     * @param token 令牌
     * @return 用户名
     */
    public String getUsernameFromToken(String token)
    {
        Claims claims = parseToken(token);
        return claims.getSubject();
    }

    /**
     * 获取请求token
     *
     * @param request
     * @return token
     */
    private String getToken(HttpServletRequest request)
    {
        String token = request.getHeader(header);
        if (StringUtils.isNotEmpty(token) && token.startsWith(Constants.TOKEN_PREFIX))
        {
            token = token.replace(Constants.TOKEN_PREFIX, "");
        }
        return token;
    }

    private String getTokenKey(String uuid)
    {
        return Constants.LOGIN_TOKEN_KEY + uuid;
    }
}

token过滤器代码

/**
 * token过滤器 验证token有效性
 * 
 * @author jdac
 */
@Component
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter
{
    @Autowired
    private TokenService tokenService;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
            throws ServletException, IOException
    {
        LoginUser loginUser = tokenService.getLoginUser(request);
        if (StringUtils.isNotNull(loginUser) && StringUtils.isNull(SecurityUtils.getAuthentication()))
        {
            tokenService.verifyToken(loginUser);
            UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(loginUser, null, loginUser.getAuthorities());
            authenticationToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
            SecurityContextHolder.getContext().setAuthentication(authenticationToken);
        }
        chain.doFilter(request, response);
    }
}