前言
一、接口安全的方式
1. 身份认证，鉴别客户端
2. 请求过程鉴权，防止请求被篡改
3. 访问控制，即控制客户端对API的访问权限
前言
某家电商平台上，用户可以通过客户端发起购物请求，并对所选商品进行下单、支付等操作。
为了保障系统的安全性和用户隐私，该电商平台采取了一系列安全措施，包括身份认证、请求过程鉴权和访问控制等三个阶段的验证。
第一阶段是身份认证，鉴别客户端的身份
。这一阶段可以采用多种方式进行身份验证，如HTTP基本认证、Token认证，和OAuth2认证等。在具体实践中，我们可以在客户端请求接口的时候，一并提交用于身份认证的Token信息，接口服务器可以通过相关的算法验证Token合法性并拒绝非法请求。同时，Token的生成和管理可利用第三方模块，如jsonwebtoken等来实现。
第二阶段是请求过程鉴权，防止请求被篡改
。针对您提供的拉起第三方支付的业务场景，可以在客户端请求前提前生成一份用于防伪验签的随机字符串或者签名，然后将该随机字符串或者签名等信息携带在接口请求参数中，客户端请求接口时，后端可以将请求参数中的随机字符串或者签名等信息重新计算一遍，以判断请求是否被篡改。在具体实现中，我们可以需要将关键数据通过客户端的公钥或者密钥进行加密后再发送到后端服务器上，以保证隐私数据不会被泄露。
第三阶段是访问控制，即控制客户端对API的访问权限
。在具体实践中，我们可以利用RBAC模型对访问API的权限进行控制。RBAC模型的基本思想是将访问API的用户分为多个角色，然后对每个角色授予对API的访问权限。当用户访问API时，后端服务器会根据该用户被授予的角色来判断用户是否有权访问该API，如果没有授权访问权限，则服务器会拒绝请求。
以下是Java版本的接口验签示例代码：
import java.security.MessageDigest;
import java.util.Map;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class PaymentController {
private final String APP_SECRET = "xxx";
@RequestMapping("/third_party_payment")
@ResponseBody
public String third_party_payment(@RequestParam Map<String, String> params) {
String appId = params.get("app_id");
String timestamp = params.get("timestamp");
String paymentAmount = params.get("payment_amount");
String sign = params.get("sign");
// 进行参数合法性校验
if (StringUtils.isEmpty(appId) || StringUtils.isEmpty(timestamp) || StringUtils.isEmpty(paymentAmount)
|| StringUtils.isEmpty(sign)) {
return "{"code":400,"msg":"参数不完整。"}";
}
// 进行接口鉴权校验
String data = String.format("%s%s%s%s", appId, timestamp, paymentAmount, APP_SECRET);
String md5Sign = MD5(data);
if (!md5Sign.equals(sign)) {
return "{"code":400,"msg":"签名不正确。"}";
}
// 成功的业务逻辑处理
return "{"code":200,"msg":"ok"}";
}
/**
* 计算MD5值
*/
private String MD5(String data) {
try {
MessageDigest md = MessageDigest.getInstance("MD5");
byte[] bytes = md.digest(data.getBytes("UTF-8"));
StringBuilder sb = new StringBuilder();
for (byte b : bytes) {
String hex = Integer.toHexString(b & 0xff);
if (hex.length() == 1) {
sb.append("0");
}
sb.append(hex);
}
return sb.toString();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
在该实现中，我们使用SpringBoot作为应用开发框架，通过RESTful
API的方式提供第三方支付接口服务。接口请求时需要提供app_id、timestamp、payment_amount和sign四个参数，其中sign参数是通过对前三个参数进行加密生成的。我们使用了MD5算法对前三个参数和app_secret进行加密，生成sign参数。请求到达服务端后，我们可以通过鉴别请求参数的合法性来进行身份认证和请求过程鉴权，接着可以使用MD5算法对请求参数进行处理，判断请求是否被篡改。最后，我们对用户的请求进行业务逻辑处理，并返回对应的结果。
总的来说，该实现使用了常见的开发框架和加密算法，实现了基本的接口验策略。在实际应用中，需要结合具体业务场景进行优化和改进，以保证接口的安全性、可靠性和高效性。
常见的案例：
输入验证
输入验证是保证接口安全性的重要措施之一，可以使用正则表达式或其他验证方式对请求参数进行验证，确保数据的完整性和正确性。以下是一个简单的示例代码：
@RequestMapping(value = “/login”, method = RequestMethod.POST)
public ResponseEntity login(@RequestParam(“username”) String username,
@RequestParam(“password”) String password) {
// 验证用户名是否合法
if (!username.matches(“1*$”)) {
return new ResponseEntity<>(“Invalid username”, HttpStatus.BAD_REQUEST);
}
// 验证密码是否合法
if (!password.matches(“2*$”)) {
return new ResponseEntity<>(“Invalid password”, HttpStatus.BAD_REQUEST);
}
// TODO: 根据具体业务逻辑进行其他验证
return new ResponseEntity<>(“Login success”, HttpStatus.OK);
}
复制代码
防止SQL注入
SQL注入是常见的攻击手段之一，可以通过参数化查询或预编译语句来防止SQL注入攻击。以下是一个简单的示例代码：
@RequestMapping(value = “/users”, method = RequestMethod.GET)
public ResponseEntity getUsers(@RequestParam(“name”) String name)
{
String sql = “SELECT * FROM user WHERE name = ?”;
List users = jdbcTemplate.query(sql, new Object[]{name}, new
BeanPropertyRowMapper<>(User.class));
return new ResponseEntity<>(users, HttpStatus.OK);
}
复制代码
防止XSS攻击
XSS攻击是指攻击者在页面中注入恶意脚本，可以通过对特殊字符进行转义或使用HTML5的Content Security
Policy来防止XSS攻击。以下是一个简单的示例代码：
@RequestMapping(value = “/search”, method = RequestMethod.GET)
public ResponseEntity search(@RequestParam(“keyword”) String keyword)
{
// 对特殊字符进行转义
keyword = HtmlUtils.htmlEscape(keyword);
// TODO: 根据具体业务逻辑进行查询
return new ResponseEntity<>(result, HttpStatus.OK);
}
复制代码
4. 防止CSRF攻击
CSRF攻击是指攻击者利用用户的登录状态发起恶意请求，可以通过在请求中添加随机生成的CSRF令牌来防止CSRF攻击。以下是一个简单的示例代码：
@RequestMapping(value = “/transfer”, method = RequestMethod.POST)
public ResponseEntity transfer(@RequestParam(“from”) String from,
@RequestParam(“to”) String to,
@RequestParam(“amount”) BigDecimal amount,
@RequestParam(“csrfToken”) String csrfToken,
HttpServletRequest request) {
// 验证CSRF令牌
HttpSession session = request.getSession();
String sessionToken = (String) session.getAttribute(“csrfToken”);
if (!csrfToken.equals(sessionToken)) {
return new ResponseEntity<>(“Invalid CSRF token”, HttpStatus.BAD_REQUEST);
}
// TODO: 根据具体业务逻辑进行转账
return new ResponseEntity<>(“Transfer success”, HttpStatus.OK);
}
@RequestMapping(value = “/getCSRFToken”, method = RequestMethod.GET)
public ResponseEntity getCSRFToken(HttpServletRequest request) {
// 生成随机的CSRF令牌
String csrfToken = UUID.randomUUID().toString();
HttpSession session = request.getSession();
session.setAttribute(“csrfToken”, csrfToken);
return new ResponseEntity<>(csrfToken, HttpStatus.OK);
}
复制代码
5. 验证UID是否是登录UID
验证UID是否是登录UID也是保证接口安全性的重要措施之一。在实际开发中，我们通常会使用会话机制（session）来保存用户的登录状态。对于需要验证UID的接口，我们可以在会话中保存用户的UID，并在接口调用时进行验证，确保用户只能访问自己的数据。以下是一个简单的示例代码：
@RequestMapping(value = “/getUserInfo”, method = RequestMethod.GET)
public ResponseEntity getUserInfo(@RequestParam(“uid”) Long uid,
HttpSession session) {
// 验证用户是否登录
Long loginUid = (Long) session.getAttribute(“uid”);
if (loginUid == null) {
return new ResponseEntity<>(HttpStatus.UNAUTHORIZED);
}
// 验证UID是否是登录UID
if (!uid.equals(loginUid)) {
return new ResponseEntity<>(HttpStatus.FORBIDDEN);
}
// TODO: 根据UID获取用户信息
UserInfo userInfo = userService.getUserInfo(uid);
return new ResponseEntity<>(userInfo, HttpStatus.OK);
}
复制代码
在实际开发中，以上安全措施可能只是保障接口安全的基础，还需要根据具体的业务场景和安全需求进行进一步的加固。以下是一些额外的安全措施：
HTTPS：采用HTTPS协议保障接口传输的安全性，防止中间人攻击和数据泄露。
API密钥：为每个客户端分配唯一的API密钥，防止未经授权的访问。
访问频率限制：限制接口访问的频率，防止恶意攻击和DDoS攻击。
日志记录：记录接口的访问日志和异常日志，方便追踪和排查安全问题。
安全审计：定期对接口进行安全审计，发现可能存在的安全漏洞并及时修复。
防火墙：在服务器上配置防火墙，限制对接口的访问，防止未经授权的访问和攻击。
综上所述，保障接口安全需要采取一系列的安全措施，包括输入验证、防止SQL注入、防止XSS攻击、防止CSRF攻击、验证UID是否是登录UID等。除此之外，还可以采取其他的安全措施来进一步加固接口的安全性，确保接口的稳定和安全。
一、为什么要保证接口安全
在我们日常开发中,存在一些接口是敏感且重要的,比如充值接口,如果在你调用充值接口的时候被别人抓包了,然后就可以修改充值的金额,本来充值10元可以改成充值10w,产生重大生产问题,再或者说被被人抓包了,别人可以不限制的调用该充值10元的接口,调用几万次,也是会导致重大问题,那么我们该如何保证接口安全呢?
二、接口安全的几种方式
2.1 数据参数合法性校验
接口数据的安全性保证，还需要我们的系统，有个数据合法性校验，简单来说就是参数校验，比如身份证长度，手机号长度，是否是数字等等
2.2 token授权认证方式
一般我们系统都会使用token鉴权登陆校验用户登陆状态和用户权限,访问接口前先校验token的合法性
2.3 数据加密,防止报文明文传输
说到数据加密,我们不难想到使用HTTPS进行传输,HTTPS使用了RSA和AES加密的方式保证了数据传输中的安全问题,具体的HTTPS的加密原理,请看HTTPS原理
数据在传输过程中被加密了，理论上，即使被抓包，数据也不会被篡改。但是https不是绝对安全的哦。还有一个点：https加密的部分只是在外网，然后有很多服务是内网相互跳转的，签名验证也可以在这里保证不被中间人篡改，所以一般转账类安全性要求高的接口开发，都需要加签验签
2.4 签名验证
https虽然保证了在外网上数据不会被篡改,但是不能保证在内网中数据篡改的风险,所以需要有签名验证的环节
客户端把参数以特定顺序进行md5加密形成签名sign,一并同参数传递到服务端
服务端接收到签名和参数,也以一定的顺序对参数进行md5加密,对比传递来的sign判断是否是否被篡改
这样做的好处就是,在数据传输过程中,可以保证数据不会被篡改,如果篡改了的话sign就会不一致,验证不通过
但是这仅仅只是解决了篡改问题,那如果我拿到请求后不修改参数,原样数据多次调用,还是会产生问题,这时候就需要增加防重放功能
2.5 timestamp+nonce方案防止重放攻击
timestamp是时间戳超时机制,当一个请求超过该时间后,则认定为该请求失效,需要重新发送请求,默认60s,但是如果在60s内多次调用岂不是也会导致问题?
通常来说,从抓包到重放的时间绝对不止60s,为了避免此类问题发生,我们可以在客户端发送请求的时候随机产生一个nonce随机数
nonce令牌是一个随机数,每次请求后都会存入redis,过期时间60s,这样就没个请求只能请求一次,避免了多次调用的问题
2.6 白名单黑名单
三、防重放和防篡改拦截器
这里我们使用timestamp+nonce+sign对接口进行安全处理
1. 构建请求头
@Data
@Builder
public class RequestHeader {
/**
* 签名
*/
private String sign;
/**
* 时间戳
*/
private Long timestamp;
/**
* 临时的数据
*/
private String nonce;
}
2. 保存请求流对象
public class SignRequestWrapper extends HttpServletRequestWrapper {
//用于将流保存下来
private byte[] requestBody = null;
public SignRequestWrapper(HttpServletRequest request) throws IOException {
super(request);
requestBody = StreamUtils.copyToByteArray(request.getInputStream());
}
@Override
public ServletInputStream getInputStream() throws IOException {
final ByteArrayInputStream bais = new ByteArrayInputStream(requestBody);
return new ServletInputStream() {
@Override
public boolean isFinished() {
return false;
}
@Override
public boolean isReady() {
return false;
}
@Override
public void setReadListener(ReadListener readListener) {
}
@Override
public int read() throws IOException {
return bais.read();
}
};
}
@Override
public BufferedReader getReader() throws IOException {
return new BufferedReader(new InputStreamReader(getInputStream()));
}
}
3. 创建请求数据处理工具
@Slf4j
public class HttpDataUtil {
/**
* post请求处理：获取 Body 参数，转换为SortedMap
*
* @param request
*/
public static SortedMap<String, String> getBodyParams(final HttpServletRequest request) throws IOException {
byte[] requestBody = StreamUtils.copyToByteArray(request.getInputStream());
String body = new String(requestBody);
return JsonUtils.parseObject(body, SortedMap.class);
}
/**
* get请求处理：将URL请求参数转换成SortedMap
*/
public static SortedMap<String, String> getUrlParams(HttpServletRequest request) {
String param = "";
SortedMap<String, String> result = new TreeMap<>();
if (StringUtils.isEmpty(request.getQueryString())) {
return result;
}
try {
param = URLDecoder.decode(request.getQueryString(), "utf-8");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
String[] params = param.split("&");
for (String s : params) {
String[] array = s.split("=");
result.put(array[0], array[1]);
}
return result;
}
}
4. 签名验证工具
@Slf4j
public class SignUtil {
/**
* 验证签名
* 验证算法：把timestamp + JsonUtil.object2Json(SortedMap)合成字符串，然后MD5
*/
@SneakyThrows
public static boolean verifySign(SortedMap<String, String> map, RequestHeader requestHeader) {
String params = requestHeader.getNonce() + requestHeader.getTimestamp() + JsonUtils.toJsonString(map);
return verifySign(params, requestHeader);
}
/**
* 验证签名
*/
public static boolean verifySign(String params, RequestHeader requestHeader) {
log.debug("客户端签名: {}", requestHeader.getSign());
if (StringUtils.isEmpty(params)) {
return false;
}
log.info("客户端上传内容: {}", params);
String paramsSign = DigestUtils.md5DigestAsHex(params.getBytes()).toUpperCase();
log.info("客户端上传内容加密后的签名结果: {}", paramsSign);
return requestHeader.getSign().equals(paramsSign);
}
}
5. 创建拦截器SignFilter
@Slf4j
public class SignFilter implements Filter {
private static final Long signMaxTime = 60L;
private static final String NONCE_KEY = "x-nonce-";
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
HttpServletRequest httpRequest = (HttpServletRequest) servletRequest;
log.info("过滤URL:{}", httpRequest.getRequestURI());
//request数据流只能读取一次，这里保存request流
HttpServletRequestWrapper requestWrapper = new SignRequestWrapper(httpRequest);
//构建请求头
String nonceHeader = httpRequest.getHeader("X-Nonce");
String timeHeader = httpRequest.getHeader("X-Time");
String signHeader = httpRequest.getHeader("X-Sign");
//验证请求头是否存在
if (StringUtils.isEmpty(nonceHeader) || ObjectUtils.isEmpty(timeHeader) || StringUtils.isEmpty(signHeader)) {
throw new RuntimeException("请求头不存在");
}
RequestHeader requestHeader = RequestHeader.builder()
.nonce(httpRequest.getHeader("X-Nonce"))
.timestamp(Long.parseLong(httpRequest.getHeader("X-Time")))
.sign(httpRequest.getHeader("X-Sign")).build();
/*
* 1.验证签名是否过期，防止重放
* 判断timestamp时间戳与当前时间是否操过60s（过期时间根据业务情况设置）,如果超过了就提示签名过期。
*/
long now = System.currentTimeMillis() / 1000;
if (now - requestHeader.getTimestamp() > signMaxTime) {
throw new RuntimeException("签名过期");
}
//2. 判断nonce，是否重复发送
boolean nonceExists = RedisUtils.hasKey(NONCE_KEY + requestHeader.getNonce());
if (nonceExists) {
//请求重复
throw new RuntimeException("请求重复");
} else {
RedisUtils.set(NONCE_KEY + requestHeader.getNonce(), requestHeader.getNonce(), signMaxTime);
}
// 3. 验证签名，防止篡改
boolean accept;
SortedMap<String, String> paramMap;
switch (httpRequest.getMethod()) {
case "GET":
paramMap = HttpDataUtil.getUrlParams(requestWrapper);
accept = SignUtil.verifySign(paramMap, requestHeader);
break;
case "POST":
paramMap = HttpDataUtil.getBodyParams(requestWrapper);
accept = SignUtil.verifySign(paramMap, requestHeader);
break;
default:
accept = true;
break;
}
if (accept) {
filterChain.doFilter(requestWrapper, servletResponse);
} else {
throw new RuntimeException("签名有误，请重新请求");
}
}
}
6. 配置拦截器
@Configuration
public class SignFilterConfiguration {
@Bean
public FilterRegistrationBean contextFilterRegistrationBean() {
FilterRegistrationBean registration = new FilterRegistrationBean();
registration.setFilter(new SignFilter());
registration.addUrlPatterns("/sign/*");
registration.setName("SignFilter");
// 设置过滤器被调用的顺序
registration.setOrder(1);
return registration;
}
}
7. 测试
@RequestMapping("")
@RestController
public class SignDemoController {
@PostMapping("/sign/demo1")
public R demo1(@RequestBody DemoDto demoDto) {
System.out.println("===执行了demo1");
return R.ok();
}
@GetMapping("/demo2")
public R demo2() {
System.out.println("执行了demo2====");
return R.ok();
}
}
@Data
class DemoDto {
private Integer age;
private String username;
private Long id;
}
接下来我将给各位同学划分一张学习计划表！
学习计划
那么问题又来了，作为萌新小白，我应该先学什么，再学什么？
既然你都问的这么直白了，我就告诉你，零基础应该从什么开始学起：
阶段一：初级网络安全工程师
接下来我将给大家安排一个为期1个月的网络安全初级计划，当你学完后，你基本可以从事一份网络安全相关的工作，比如渗透测试、Web渗透、安全服务、安全分析等岗位；其中，如果你等保模块学的好，还可以从事等保工程师。
综合薪资区间6k~15k
1、网络安全理论知识（2天）
①了解行业相关背景，前景，确定发展方向。
②学习网络安全相关法律法规。
③网络安全运营的概念。
④等保简介、等保规定、流程和规范。（非常重要）
2、渗透测试基础（1周）
①渗透测试的流程、分类、标准
②信息收集技术：主动/被动信息搜集、Nmap工具、Google Hacking
③漏洞扫描、漏洞利用、原理，利用方法、工具（MSF）、绕过IDS和反病毒侦察
④主机攻防演练：MS17-010、MS08-067、MS10-046、MS12-20等
3、操作系统基础（1周）
①Windows系统常见功能和命令
②Kali Linux系统常见功能和命令
③操作系统安全（系统入侵排查/系统加固基础）
4、计算机网络基础（1周）
①计算机网络基础、协议和架构
②网络通信原理、OSI模型、数据转发流程
③常见协议解析（HTTP、TCP/IP、ARP等）
④网络攻击技术与网络安全防御技术
⑤Web漏洞原理与防御：主动/被动攻击、DDOS攻击、CVE漏洞复现
5、数据库基础操作（2天）
①数据库基础
②SQL语言基础
③数据库安全加固
6、Web渗透（1周）
①HTML、CSS和JavaScript简介
②OWASP Top10
③Web漏洞扫描工具
④Web渗透工具：Nmap、BurpSuite、SQLMap、其他（菜刀、漏扫等）
那么，到此为止，已经耗时1个月左右。你已经成功成为了一名“脚本小子”。那么你还想接着往下探索吗？
阶段二：中级or高级网络安全工程师（看自己能力）
综合薪资区间15k~30k
7、脚本编程学习（4周）
在网络安全领域。是否具备编程能力是“脚本小子”和真正网络安全工程师的本质区别。在实际的渗透测试过程中，面对复杂多变的网络环境，当常用工具不能满足实际需求的时候，往往需要对现有工具进行扩展，或者编写符合我们要求的工具、自动化脚本，这个时候就需要具备一定的编程能力。在分秒必争的CTF竞赛中，想要高效地使用自制的脚本工具来实现各种目的，更是需要拥有编程能力。
零基础入门的同学，我建议选择脚本语言Python/PHP/Go/Java中的一种，对常用库进行编程学习
搭建开发环境和选择IDE，PHP环境推荐Wamp和XAMPP，IDE强烈推荐Sublime；
Python编程学习，学习内容包含：语法、正则、文件、 网络、多线程等常用库，推荐《Python核心编程》，没必要看完
用Python编写漏洞的exp,然后写一个简单的网络爬虫
PHP基本语法学习并书写一个简单的博客系统
熟悉MVC架构，并试着学习一个PHP框架或者Python框架 (可选)
了解Bootstrap的布局或者CSS。
阶段三：顶级网络安全工程师
如果你对网络安全入门感兴趣，那么你需要的话可以点击这里
👉[网络安全重磅福利：入门&进阶全套282G学习资源包免费分享！](https://mp.weixin.qq.com/s/BWb9OzaB-
gVGVpkm161PMw)
学习资料分享
当然， 只给予计划不给予学习资料的行为无异于耍流氓
，这里给大家整理了一份【282G】的网络安全工程师从入门到精通的学习资料包，可点击下方二维码链接领取哦。
-
a-zA-Z0-9 ↩︎
-
a-zA-Z0-9 ↩︎
学习网络安全技术的方法无非三种:
第一种是报网络安全专业，现在叫网络空间安全专业，主要专业课程:程序设计、计算机组成原理原理、数据结构、操作系统原理、数据库系统、 计算机网络、人工智能、自然语言处理、社会计算、网络安全法律法规、网络安全、内容安全、数字取证、机器学习，多媒体技术，信息检索、舆情分析等。
第二种是自学，就是在网上找资源、找教程，或者是想办法认识一-些大佬，抱紧大腿，不过这种方法很耗时间，而且学习没有规划，可能很长一段时间感觉自己没有进步，容易劝退。
如果你对网络安全入门感兴趣，那么你需要的话可以点击这里👉网络安全重磅福利：入门&进阶全套282G学习资源包免费分享！
第三种就是去找培训。
接下来，我会教你零基础入门快速入门上手网络安全。
网络安全入门到底是先学编程还是先学计算机基础？这是一个争议比较大的问题，有的人会建议先学编程，而有的人会建议先学计算机基础，其实这都是要学的。而且这些对学习网络安全来说非常重要。但是对于完全零基础的人来说又或者急于转行的人来说，学习编程或者计算机基础对他们来说都有一定的难度，并且花费时间太长。
第一阶段：基础准备 4周~6周
这个阶段是所有准备进入安全行业必学的部分，俗话说：基础不劳，地动山摇
第二阶段：web渗透
学习基础 时间：1周 ~ 2周：
① 了解基本概念：（SQL注入、XSS、上传、CSRF、一句话木马、等）为之后的WEB渗透测试打下基础。
② 查看一些论坛的一些Web渗透，学一学案例的思路，每一个站点都不一样，所以思路是主要的。
③ 学会提问的艺术，如果遇到不懂得要善于提问。
配置渗透环境 时间：3周 ~ 4周：
① 了解渗透测试常用的工具，例如（AWVS、SQLMAP、NMAP、BURP、中国菜刀等）。
② 下载这些工具无后门版本并且安装到计算机上。
③ 了解这些工具的使用场景，懂得基本的使用，推荐在Google上查找。
渗透实战操作 时间：约6周：
① 在网上搜索渗透实战案例，深入了解SQL注入、文件上传、解析漏洞等在实战中的使用。
② 自己搭建漏洞环境测试，推荐DWVA，SQLi-labs，Upload-labs，bWAPP。
③ 懂得渗透测试的阶段，每一个阶段需要做那些动作：例如PTES渗透测试执行标准。
④ 深入研究手工SQL注入，寻找绕过waf的方法，制作自己的脚本。
⑤ 研究文件上传的原理，如何进行截断、双重后缀欺骗(IIS、PHP)、解析漏洞利用（IIS、Nignix、Apache）等，参照：上传攻击框架。
⑥ 了解XSS形成原理和种类，在DWVA中进行实践，使用一个含有XSS漏洞的cms，安装安全狗等进行测试。
⑦ 了解一句话木马，并尝试编写过狗一句话。
⑧ 研究在Windows和Linux下的提升权限，Google关键词：提权
以上就是入门阶段
第三阶段：进阶
已经入门并且找到工作之后又该怎么进阶？详情看下图
给新手小白的入门建议：
新手入门学习最好还是从视频入手进行学习，视频的浅显易懂相比起晦涩的文字而言更容易吸收，这里我给大家准备了一套网络安全从入门到精通的视频学习资料包免费领取哦！
如果你对网络安全入门感兴趣，那么你需要的话可以点击这里👉网络安全重磅福利：入门&进阶全套282G学习资源包免费分享！
扫一扫
945
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
