常见的登录逻辑漏洞及其修复方法

最新推荐文章于 2024-05-29 13:35:56 发布
最新推荐文章于 2024-05-29 13:35:56 发布
阅读量685 收藏 1
点赞数 1
文章标签： java spring servlet
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44030143/article/details/130280131
版权

常见的登录逻辑漏洞及其修复方法

问题来源参考文献:https://blog.csdn.net/qq_63217130/article/details/130187929?spm=1001.2014.3001.5502

密码可爆破的情况

一、限制请求次数

可以利用Spring AOP实现请求次数的限制，主要思路如下：
定义一个请求计数器类 RequestCounter，用于记录请求次数，可以采用Map<String, Integer>类型的集合，其中Key为用户账号，Value为当前账号请求次数。
利用Spring AOP，在处理用户请求的方法上添加切面，判断当前请求账号的请求次数是否超过了限制，如果超过了限制，则抛出异常提示用户请求次数过多。
下面是一个简单的实现示例：
定义请求计数器类：

@Component
public class RequestCounter {
    private Map<String, Integer> counterMap = new ConcurrentHashMap<>();
    public void increment(String account) {
        Integer count = counterMap.get(account);
        if (count == null) {
            count = 0;
        }
        counterMap.put(account, count + 1);
    }
    public int getCount(String account) {
        Integer count = counterMap.get(account);
        return count == null ? 0 : count;
    }
}

定义请求次数限制切面：

@Aspect
@Component
public class RequestLimitAspect {
    @Autowired
    private RequestCounter requestCounter;
    @Pointcut("@annotation(com.example.demo.annotation.RequestLimit)")
    public void requestLimit() {}
    @Before("requestLimit()")
    public void before(JoinPoint joinPoint) throws RequestLimitException {
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        String account = request.getParameter("account");
        int count = requestCounter.getCount(account);
        if (count >= 5) {
            throw new RequestLimitException("请求次数过多，已被限制访问！");
        }
        requestCounter.increment(account);
    }
}

在需要进行请求次数限制的方法上添加@RequestLimit注解：

@RestController
public class UserController {
    @Autowired
    private UserService userService;
    @RequestMapping("/login")
    @RequestLimit
    public String login(String account, String password) {
        userService.login(account, password);
        return "success";
    }
}

二、锁定账号

当用户的请求次数超过了限制，可以将该账号锁定一段时间，防止用户继续进行非法请求。主要思路如下：

  1. 在请求计数器类中，记录每个账号最后一次请求的时间戳。
  2. 在请求次数限制切面中添加判断，如果当前账号已经被锁定，则抛出异常提示用户账号已被锁定；否则，检查当前请求次数是否超过了限制，并更新最后一次请求时间戳。
  3. 在登录方法中判断当前账号是否已被锁定，如果已被锁定，则不允许用户登录。

下面是一个简单的实现示例：
在请求计数器类中添加记录最后一次请求时间的方法：

@Component
public class RequestCounter {
    private Map<String, Integer> counterMap = new ConcurrentHashMap<>();
    private Map<String, Long> lastRequestTimeMap = new ConcurrentHashMap<>();
    public void increment(String account) {
        Integer count = counterMap.get(account);
        if (count == null) {
            count = 0;
        }
        counterMap.put(account, count + 1);
        lastRequestTimeMap.put(account, System.currentTimeMillis());
    }
    public int getCount(String account) {
        Integer count = counterMap.get(account);
        return count == null ? 0 : count;
    }
    public long getLastRequestTime(String account) {
        Long time = lastRequestTimeMap.get(account);
        return time == null ? 0L : time;
    }
}

修改请求次数限制切面：

@Aspect
@Component
public class RequestLimitAspect {
    @Autowired
    private RequestCounter requestCounter;
    @Pointcut("@annotation(com.example.demo.annotation.RequestLimit)")
    public void requestLimit() {}
    @Before("requestLimit()")
    public void before(JoinPoint joinPoint) throws RequestLimitException {
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        String account = request.getParameter("account");
        long lastRequestTime = requestCounter.getLastRequestTime(account);
        if (lastRequestTime > 0 && System.currentTimeMillis() - lastRequestTime < 60000) {
            throw new RequestLimitException("请求过于频繁，请稍后再试！");
        }
        int count = requestCounter.getCount(account);
        if (count >= 5) {
            requestCounter.lastRequestTimeMap.put(account, System.currentTimeMillis());
            throw new RequestLimitException("请求次数过多，已被限制访问！");
        }
        requestCounter.increment(account);
    }
}

修改登录方法：

@Service
public class UserService {
    @Autowired
    private RequestCounter requestCounter;
    private Map<String, Long> lockMap = new ConcurrentHashMap<>();
    public void login(String account, String password) throws AccountLockedException {
        long lastRequestTime = requestCounter.getLastRequestTime(account);
        if (lastRequestTime > 0 && System.currentTimeMillis() - lastRequestTime < 60000) {
            throw new AccountLockedException("账号已被锁定，请稍后再试！");
        }
        // TODO: 验证账号密码
        // ...
        // 登录成功，清除请求次数和最后一次请求时间
        requestCounter.counterMap.remove(account);
        requestCounter.lastRequestTimeMap.remove(account);
        lockMap.remove(account);
    }
}

短信轰炸 aop切面或者令牌桶

  1. 定义一个验证码请求计数器类 VerificationCodeRequestCounter，用于记录验证码请求次数和最后一次请求时间，可以采用Map<String, VerificationCodeRequest>类型的集合，其中Key为用户账号，Value为该账号的验证码请求信息。
  2. 利用Spring AOP，在发送验证码的方法上添加切面，判断当前账号的验证码请求时间是否超过了限制，如果超过了限制，则抛出异常提示用户请求过于频繁。

下面是一个简单的实现示例：
定义验证码请求计数器类：

@Component
public class VerificationCodeRequestCounter {
    private Map<String, VerificationCodeRequest> requestMap = new ConcurrentHashMap<>();
    public void increment(String account) {
        VerificationCodeRequest request = requestMap.get(account);
        if (request == null) {
            request = new VerificationCodeRequest();
        }
        request.increment();
        requestMap.put(account, request);
    }
    public int getCount(String account) {
        VerificationCodeRequest request = requestMap.get(account);
        return request == null ? 0 : request.getCount();
    }
    public long getLastRequestTime(String account) {
        VerificationCodeRequest request = requestMap.get(account);
        return request == null ? 0L : request.getLastRequestTime();
    }
}
class VerificationCodeRequest {
    private int count;
    private long lastRequestTime;
    public VerificationCodeRequest() {
        this.count = 0;
        this.lastRequestTime = 0L;
    }
    public void increment() {
        count++;
        lastRequestTime = System.currentTimeMillis();
    }
    public int getCount() {
        return count;
    }
    public long getLastRequestTime() {
        return lastRequestTime;
    }
}

定义验证码请求次数限制切面：

@Aspect
@Component
public class VerificationCodeRequestLimitAspect {
    @Autowired
    private VerificationCodeRequestCounter requestCounter;
    @Pointcut("@annotation(com.example.demo.annotation.VerificationCodeRequestLimit)")
    public void verificationCodeRequestLimit() {}
    @Before("verificationCodeRequestLimit()")
    public void before(JoinPoint joinPoint) throws VerificationCodeRequestLimitException {
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        String account = request.getParameter("account");
        long lastRequestTime = requestCounter.getLastRequestTime(account);
        if (lastRequestTime > 0 && System.currentTimeMillis() - lastRequestTime < 60000) {
            throw new VerificationCodeRequestLimitException("验证码请求过于频繁，请稍后再试！");
        }
        int count = requestCounter.getCount(account);
        if (count >= 3) {
            throw new VerificationCodeRequestLimitException("验证码请求次数过多，已被限制！");
        }
        requestCounter.increment(account);
    }
}

在需要进行验证码请求限制的方法上添加@VerificationCodeRequestLimit注解：

@RestController
public class UserController {
    @Autowired
    private VerificationCodeService verificationCodeService;
    @RequestMapping("/sendVerificationCode")
    @VerificationCodeRequestLimit
    public String sendVerificationCode(String account) {
        verificationCodeService.sendVerificationCode(account);
        return "success";
    }
}

万能验证码

  1. 添加滑块验证码或人机验证等复杂验证码，增加破解的难度。
  2. 添加验证码有效期，验证码过期后需重新获取验证码。
  3. 限制验证码输入错误次数，超过一定次数后需要重新获取验证码。

下面是一个限制验证码输入错误次数的示例代码：
首先定义一个验证码错误计数器类 VerificationCodeErrorCounter，用于记录验证码输入错误次数，可以采用Map<String, Integer>类型的集合，其中Key为验证码ID，Value为该验证码的错误输入次数。

@Component
public class VerificationCodeErrorCounter {
    private Map<String, Integer> errorMap = new ConcurrentHashMap<>();
    public void increment(String id) {
        Integer count = errorMap.get(id);
        if (count == null) {
            count = 0;
        }
        count++;
        errorMap.put(id, count);
    }
    public int getCount(String id) {
        Integer count = errorMap.get(id);
        return count == null ? 0 : count;
    }
    public void clear(String id) {
        errorMap.remove(id);
    }
}

然后在验证码校验的方法中，判断验证码输入错误次数是否超过了限制，如果超过了限制，则抛出异常提示用户验证码输入错误次数过多。

@RestController
public class VerificationCodeController {
    @Autowired
    private VerificationCodeService verificationCodeService;
    @Autowired
    private VerificationCodeErrorCounter errorCounter;
    @PostMapping("/verifyCode")
    public String verifyCode(String id, String code) {
        boolean result = verificationCodeService.verifyCode(id, code);
        if (!result) {
            errorCounter.increment(id);
            int count = errorCounter.getCount(id);
            if (count >= 3) {
                errorCounter.clear(id);
                throw new VerificationCodeErrorLimitException("验证码输入错误次数过多，请重新获取验证码！");
            }
            throw new VerificationCodeErrorException("验证码输入错误，请重新输入！");
        }
        errorCounter.clear(id);
        return "success";
    }
}

用户批量注册

后端对 IP 进行注册次数限制
1 定义一个 IP 计数器类 IpCounter，用于记录每个 IP 的注册次数。可以采用 Map<String, Integer> 类型的集合，其中 Key 为 IP 地址，Value 为该 IP 的注册次数。

@Component
public class IpCounter {
    private Map<String, Integer> countMap = new ConcurrentHashMap<>();
    public void increment(String ip) {
        Integer count = countMap.get(ip);
        if (count == null) {
            count = 0;
        }
        count++;
        countMap.put(ip, count);
    }
    public int getCount(String ip) {
        Integer count = countMap.get(ip);
        return count == null ? 0 : count;
    }
    public void clear(String ip) {
        countMap.remove(ip);
    }
}

2 在注册接口中，获取客户端的 IP 地址，并判断该 IP 的注册次数是否超过了限制。如果超过了限制，则抛出异常提示用户注册次数过多。

@RestController
public class UserController {
    @Autowired
    private UserService userService;
    @Autowired
    private IpCounter ipCounter;
    @PostMapping("/register")
    public String register(String username, String password, HttpServletRequest request) {
        String ip = request.getRemoteAddr();
        int count = ipCounter.getCount(ip);
        if (count >= 3) {
            ipCounter.clear(ip);
            throw new IpRegisterLimitException("该 IP 注册次数过多，请稍后再试！");
        }
        ipCounter.increment(ip);
        userService.register(username, password);
        return "success";
    }
}

3 对于同一个 IP，需要在一定时间内进行注册次数限制。可以使用 Guava 的 Cache 工具类来实现，将 IP 地址作为 Key，注册时间作为 Value，设置过期时间为一定时间后，再次进行注册时，判断当前时间与注册时间的差是否超过了限制。

@Component
public class IpRegisterCache {
    private static final long EXPIRE_TIME = 1L; // 过期时间，单位为分钟
    private Cache<String, Long> cache = CacheBuilder.newBuilder()
            .expireAfterWrite(EXPIRE_TIME, TimeUnit.MINUTES)
            .build();
    public boolean isOverLimit(String ip) {
        Long registerTime = cache.getIfPresent(ip);
        if (registerTime == null) {
            return false;
        }
        long currentTime = System.currentTimeMillis();
        return (currentTime - registerTime) < (EXPIRE_TIME * 60 * 1000);
    }
    public void put(String ip) {
        long currentTime = System.currentTimeMillis();
        cache.put(ip, currentTime);
    }
}

@RestController
public class UserController {
    @Autowired
    private UserService userService;
    @Autowired
    private IpCounter ipCounter;
    @Autowired
    private IpRegisterCache ipRegisterCache;
    @PostMapping("/register")
    public String register(String username, String password, HttpServletRequest request) {
        String ip = request.getRemoteAddr();
        if (ipRegisterCache.isOverLimit(ip)) {
            throw new IpRegisterLimitException("该 IP 注册次数过多，请稍后再试！");
        }
        int count = ipCounter.getCount(ip);
        if (count >= 3) {
            ipCounter.clear(ip);
            ipRegisterCache.put(ip);
            throw new IpRegisterLimitException("该 IP 注册次数过多，请稍后再试！");
        }
        ipCounter.increment(ip);
        userService.register(username, password);
        return "success";
    }
}

销毁登录成功的凭证防止复用

1 在生成登录成功凭证时，设置凭证的有效期，并将凭证存储到 Redis 或其他缓存中。

public String generateToken() {
    String token = UUID.randomUUID().toString();
    stringRedisTemplate.opsForValue().set(token, "user_id", Duration.ofMinutes(30));
    return token;
}

2 在需要验证凭证的接口中，从请求头或请求参数中获取凭证，并从 Redis 中取出对应的值。如果存在，则说明凭证有效，可以继续执行操作；否则说明凭证无效，需要重新登录。

public void checkToken(String token) {
    String userId = stringRedisTemplate.opsForValue().get(token);
    if (userId == null) {
        throw new RuntimeException("Token invalid");
    } else {
        // ...执行其他操作...
    }
}

3 在用户注销或退出登录时，从 Redis 中删除对应的凭证，以销毁凭证并防止复用。

public void logout(String token) {
    stringRedisTemplate.delete(token);
}

通过这种方式，可以有效防止登录成功凭证被复用。当用户注销或退出登录时，系统会删除对应的凭证，即使攻击者获取了凭证，也无法再次使用该凭证进行操作。同时，为了增加凭证的安全性，可以在生成凭证时，加入一些额外的信息，如客户端 IP、浏览器类型等，以增加凭证的复杂度和安全性。

hughmu
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
逻辑漏洞小总结
yk2909438315的博客
07-10 3664
1、找到关键的数据包可能一个支付操作有三四个数据包，我们要对数据包进行挑选。2、分析数据包支付数据包中会包含很多的敏感信息（账号，金额，余额，优惠），要尝试对数据包中的各个参数进行分析。3、不按套路出牌多去想想开发者没有想到的地方。4、pc端尝试过，手机端wap也看看，app也试试防御方法1、在后端检查订单的每一个值，包括支付状态；2、校验价格、数量参数，比如产品数量只能为整数，并限制最大购买数量；
网站安全检测之逻辑漏洞检测 修复方案
网站安全专家
09-18 650
网站安全是整个网站运营中最重要的一部分，网站没有了安全，那用户的隐私如何保障，在网站中进行的任何交易，支付，用户的注册信息都就没有了安全保障，所以网站安全做好了，才能更好的去运营一个网站，我们SINE安全在对客户进行网站安全部署与检测的同时，发现网站的业务逻辑漏洞很多，尤其暴利破解漏洞。 网站安全里的用户密码暴利破解，是目前业务逻辑漏洞里出现比较多的一个网站漏洞，其实暴力破解简单来说就是利用...
五种不寻常的身份验证绕过技术
最新发布
2401_84488651的博客
05-29 1263
就在过期之前，应用程序在终端/refresh/tokenlogin中向后端服务器发送了一个请求，该请求在标头和HTTP主体部分的用户名参数中包含有效的身份验证令牌。复杂的身份验证机制可能成为攻击者使用的最具隐蔽性的攻击手段，特别是在容易出现业务逻辑漏洞的应用程序上。进一步的测试表明，删除请求上的Authorization标头并更改HTTP主体上的用户名参数将为提供的用户名创建一个新的有效令牌。乍一看，它似乎是安全的，但对后端请求的分析显示，应用程序在重定向响应上返回了异常大的内容长度(超过40000字节)
分享网站漏洞检测与如何修复网站逻辑漏洞
网站安全专家
12-14 527
在网站安全的日常安全检测当中，我们SINE安全公司发现网站的逻辑漏洞占比也是很高的，前段时间某酒店网站被爆出存在高危的逻辑漏洞，该漏洞导致酒店的几亿客户的信息遭泄露，包括手机号，姓名，地址都被泄露，后续带来的损失很大，最近几年用户信息泄露的事件时有发生，给很多企业，酒店都上了一堂生动的安全课。关于网站逻辑漏洞的总结，今天跟大家详细讲解一下。 网站逻辑漏洞 用户的隐私信息属于数据的保护的最高...
网站有绕过认证逻辑漏洞怎么修复
网站安全专家
11-02 450
c).将变更的手机号改成自个的手机号。d).根据变更的手机号接到的检验码变更手机号。普遍的几类认证功能就包含账户密码认证、验证码短信认证、JavaScript数据信息内容认证及服务器端数据信息内容认证这些，但写代码的技术员在涉及到认证方法时很有可能存有缺点造成被绕过，因此小结了下列几类绕过认证的姿态和大伙儿一块探讨探讨。程序员在写认证程序代码时会很有可能会认证效果返回到pc客户端，由pc客户端依据服务器端提供的认证效果完成下一阶段应用，攻击者能够根据篡改认证效果或立即实行下一阶段应用完成绕过。
逻辑漏洞梳理与总结
hackzkaq的博客
05-11 908
零基础学黑客，搜索公众号：白帽子左一 设计阶段产生，老司机也会产生、相对难发现、难以防护，相对容易利用 第三方逻辑缺陷、没有在设计初期进行安全审计、安全水平及对安全认知程度不一致 身份验证漏洞 暴力破解漏洞 漏洞介绍：攻击者可以通过该漏洞获取用户名和对应弱口令密码，并进行登录操作 漏洞原理：由于没有设置登录失败次数限制，导致攻击者可以通过口令字典进行特定用户的密码爆破或通过用户名字典进行特定弱口令的用户枚举 漏洞点：系统登录点 漏洞修复： 对于固定用户名爆破密码 可以针对用户名进行错误次数计算，高于一定
限制域中账户在不同计算机上重复登录的脚本
weixin_34029680的博客
05-04 210
在微软的AD域中，任何一个用户账户都可以在不同的客户机上登录，有时甚至同一个账户同一个时间在不同的计算机上重复登录。微软AD自带的账户控制功能“登录到”设置仅仅能控制某一个账户在某一台（或多台）计算机上登录，但是并不能控制整个域中所有账户的重复登录。 除非管理员能够非常有耐心的设置每一个账户的登录位置，并且从此以后这些账户的登录计算机被固定死了。那么如何达到限制账户同一...
Web编程常见漏洞与检测
05-16
本文将深入探讨几种常见的Web漏洞及其检测方法，帮助Web设计者和管理者提升应用的安全性。 1. **SQL注入**：SQL注入是最常见的Web安全漏洞之一，它允许攻击者通过输入恶意的SQL代码来操纵数据库。当应用程序没有...
漏洞及漏洞工具
02-23
- 逻辑漏洞：程序设计时的逻辑错误，让攻击者有机会绕过安全机制。 - 配置管理漏洞：不正确的系统配置可能导致服务暴露或敏感信息泄漏。 - 软件更新与补丁管理：未及时修复的安全更新或补丁，会留下被攻击的窗口...
360eshop漏洞利用教程
06-22
这类文档对于理解漏洞的本质及其潜在影响至关重要，同时也是修复和预防措施的基础。 在360eshop的漏洞利用中，常见的攻击手段可能包括SQL注入、跨站脚本（XSS）和命令注入等。SQL注入允许攻击者通过输入恶意的SQL...
finecms-含有前台文件上传漏洞源码包.zip
01-04
《细解FineCMS前台文件上传漏洞及其源码分析》 FineCMS是一款常见的开源内容管理系统，以其易用性和灵活性深受开发者喜爱。然而，如同其他软件一样，FineCMS也存在潜在的安全问题，其中最为突出的就是前台文件上传...
thinkphp漏洞检测工具
06-06
本文将深入探讨这些工具的工作原理、使用方法及其在维护ThinkPHP项目安全中的重要作用。 首先，我们要明确的是，漏洞检测工具的主要目标是发现可能的安全隐患，包括但不限于SQL注入、XSS跨站脚本攻击、命令注入、...
掌握逻辑漏洞复现技术，保护您的数字环境
weixin_43263566的博客
08-31 1336
这篇文章旨在用于，请勿进行任何非法行为，否则后果自负。
常见的登录逻辑漏洞总结
qq_63217130的博客
04-16 2016
遇到登录界面，可以测试的漏洞（授权情况下）
Web安全之业务逻辑漏洞
qq_52358808的博客
08-03 1877
业务逻辑 不同的项目有不同的功能，不同的功能需要不同的代码实现，实现这些核心功能的代码就叫业务逻辑。 业务逻辑漏洞 业务逻辑漏洞是指由于程序逻辑不严谨或逻辑太复杂，导致一些逻辑分支不能正常处理或处理错误。 常见的业务逻辑漏洞 业务逻辑漏洞挖掘过程 确定业务流程—>寻找流程中可以被操控的环节—>分析可被操控环节中可能产生的逻辑问题—>尝试修改参数触发逻辑问题 业务逻辑漏洞1.URL跳转漏洞1.1.URL跳转概述1.2.触发方式及绕或技巧1.3.修复方法2.短信邮箱轰炸漏洞2.1.短信邮.
账号安全那些事儿
wangluoanquan111的博客
08-11 786
以操作系统、数据库、网络设备运维视角设定账号，这类账号一旦设定，不能随时删除，因此，在员工离职、调岗等异动时不能通过删除账号来实现账号权限回收。特权账号保管不善，导致登录凭证泄露、丢失，被恶意攻击者、别有用心者获取，然后被攻击者利用该登录凭证非授权访问业务系统，进而可能导致系统数据被删除、恶意增加管理员权限、非法下载大量数据等。
网安笔记（一）
weixin_63116337的博客
03-02 469
fastjson提供了autotype功能，在请求过程中，我们可以在请求包中通过修改@type的值，来反序列化为指定的类型，而fastjson在反序列化过程中会设置和获取类中的属性，如果类中存在恶意方法，就会导致代码执行等这类问题。由于PHP utf-8编码 数据库GBK编码，PHP发送请求到mysql时经过一次gbk编码，因为GBK是双字节编码，所以我们提交的%df这个字符和转译的反斜杠组成了新的汉字，然后数据库处理的时候是根据GBK去处理的，然后单引号就逃逸了出来。
常规web渗透测试漏洞描述及修复建议
weixin_34150830的博客
11-12 1770
Apache样例文件泄漏 测试方法   在链接的根目录中添加examples或者docs目录进行访问判断！ 漏洞描述  apache一些样例文件没有删除，可能存在cookie、session伪造，进行后台登录操作 修复建议  1、删除样例文件 2、对apache中web.xml进行相关设置 弱口令 测试方法   先手工尝试一些最基本的弱口令，如admin...
Web安全测试中常见逻辑漏洞解析
06-23
除了上述两种常见的逻辑漏洞之外，还有许多其他类型的逻辑漏洞，例如权限控制不足、未经验证的重定向等。要想有效地挖掘这些逻辑漏洞，需要了解业务逻辑，并通过模糊测试和逻辑分析的方法来进行测试。同时，及时更新...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值