import gdb

# main이라는 실행파일을 열기
gdb.execute("file ./main")

# main 함수에 breakpoint 걸기
gdb.execute("b *main")

# 실행
gdb.execute("run")

# 레지스터 값 보기
gdb.execute("i r $rax")

result = gdb.execute("i r $rax", to_string=True)
print(type(result))
print(result)

> 수행 결과
<class 'str'>
rax            0x1c                0x1c

# 레지스터의 경우 $ 붙이기
rax = int(gdb.parse_and_eval("$rax"))

# variable이라는 변수명의 값 가져오기
variable = int(gdb.parse_and_eval("variable"))

# 메모리 주소에 접근
val = int(gdb.parse_and_eval("*(long long*)0x404040")

# main 함수에 bp 설정
gdb.Breakpoint('main')

# 0x401010에 bp 설정
gdb.Breakpoint('*0x401010")

bp = gdb.Breakpoint("my_function")
bp.condition = "x == 42"

bp1 = gdb.Breakpoint("*0x401010")
bp1.condition = "ptr != NULL"

# 심볼이 없을 경우, 레지스터나 메모리에 직접 접근하여 작성 가능
bp = gdb.Breakpoint("0x401010")
bp.condition = "$rax == 42"

bp1 = gdb.Breakpoint("0x401011")
bp1.condition = "*(int*)0x404040 == 0x42"

# 표준
gdb.Breakpoint('main', type=gdb.BP_BRAKPOINT)

# hardware breakpoint
gdb.Breakpoint('*(int*)0x404040, type=gdb.BP_HARDWARE_BREAKPOINT)

# watchpoint (read/write)
gdb.Breakpoint('*(int*)0x404040, type=gdb.BP_WATCHPOINT)

# watchpoint (only read)
gdb.Breakpoint('*(int*)0x404040, type=gdb.BP_WATCHPOINT, internal=False, watch_read=True)

# watchpoint (only write)
gdb.Breakpoint('*(int*)0x404040, type=gdb.BP_WATCHPOINT, internal=False, watch_write=True)

# catchpoint
gdb.Breakpoint('throw', type=gdb.BP_CATCHPOINT)

class hook_info_param(gdb.Breakpoint):
	def __init__(self, address):
		super(hook_info_param, self).__init__(spec=f"*{address}") # spec은 bp 거는 위치를 의미합니다. 기본 parameter이므로 'spec=' 굳이 안써도 되긴 함
	
	def stop(self): # bp 걸릴 때마다 stop 호출
		rdi = int(gdb.parse_and_eval("$rdi"))
		rsi = int(gdb.parse_and_eval("$rsi"))
		
		print(f"1st param: {rdi}")
		print(f"2nd param: {rsi}")
		
		return False

hook_info_param(0x401020) # 후킹할 함수 주소를 넣어줌

class Hit_until_max(gdb.Breakpoint):
	def __init__(self, address, n):
		super(Hit_until_max, self).__init__(spec=f"*{address}", type=gdb.BP_BREAKPOINT)
		self.hit_count = 0
		self.hit_max = n
		self.loc = address
	
	def stop(self):
		self.hit_count += 1
		
		if self.hit_count < self.hit_max:
			return False # False 반환하면 stop하지 않고 계속 실행
		else:
			print(f"Breakpoint at {self.loc} hit {self.hit_count} times")
			return True # True를 반환하면 중단
	
my_bp = Hit_until_max(0x401000, 100) # 100번 hit할때까지 중단하지 않는 중단점

class watch_until_100(gdb.Breakpoint):
	def __init__(self, address):
		super(watch_until_100, self).__init__(spec=f"*(int*){address}", type=gdb.BP_WATCHPOINT, internal=False, watch_write=True)
		self.loc = address
	
	def stop(self):
		value = int(gdb.parse_and_eval(f"*(int*){self.loc}"))
		if value == 100:
			print(f"Watchpoint at {self.loc} triggered")
			return True
		else:
			return False

my_wp = watch_until_100(0x404040) # 해당 값(4byte)이 변경될 때 100이 될 때까지 중단하지 않는 watchpoint

class hook_info_retval(gdb.FinishBreakpoint):
	def __init__(self, frame, function_name):
		super(hook_info_retval, self).__init__(frame)
		self.function_name = function_name
		
	def stop(self):
		retval = int(gdb.parse_and_eval("$rax"))
		print(f"{self.function_name} return")
		print(f"\tretval: {retval}")
		return False

# 심볼이 살아 있는 경우입니다. 없는 경우는 address 기반으로 bp를 걸어야 합니다
class hook_info_param_retval(gdb.Breakpoint):
	def __init__(self, function_name):
		super(hook_info_param_retval, self).__init__(function_name)
		self.function_name = function_name
	
	def stop(self):
		frame = gdb.selected_frame() # 현재 함수의 frame을 가져옵니다.
		fb = hook_info_retval(frame, self.function_name) # FinishBreakpoint를 설정합니다.
		
		printf(f"{self.function_name} called")
		rdi = int(gdb.parse_and_eval("$rdi"))
		rsi = int(gdb.parse_and_eval("$rsi"))
		print(f"\t1st parm: {rdi}")
		print(f"\t2nd parm: {rsi}")
		return False

hook_info_param_retval("my_function")

class forge_retval(gdb.FinishBreakpoint):
    def __init__(self, frame):
        super(forge_retval, self).__init__(frame, internal=True)

    def stop(self):
        gdb.execute("set $rax=0") # retval을 0으로 위조하여 ptrace가 성공한 것처럼 함
        return False

class disable_ptrace(gdb.Breakpoint):
    def __init__(self):
        super(disable_ptrace, self).__init__("ptrace")

    def stop(self):
        frame = gdb.selected_frame()

        fb = forge_retval(frame)
 
 disable_ptrace()

# 값 읽기
inferior = gdb.selected_inferior()
memory_val = inferior.read_memory(0x600000, 10) # 0x600000주소에서부터 10바이트를 읽어옴

# 값 쓰기
inferior = gdb.selected_inferior()
new_val = b"\x90\x90\x90\x90\x90"
inferior.write_memory(0x600000, new_val) # 0x600000주소의 메모리에 new_val 값을 쓰기

import gdb

ge = gdb.execute # gdb.execute에 대한 숏컷 매크로 정의

ge("file ./prob") # 문제 파일 불러오기

class forge_retval(gdb.FinishBreakpoint):
    def __init__(self, frame, bp):
        super(forge_retval, self).__init__(frame, internal=True)
        self.bp = bp

    def stop(self):
        self.bp.delete() # 설정한 bp를 없앰
        ge("set $rax=0")
        return False

class disable_ptrace(gdb.Breakpoint):
    def __init__(self):
        super(disable_ptrace, self).__init__("ptrace")

    def stop(self):
        frame = gdb.selected_frame() # 현재 함수의 스택 프레임 가져옴
        fb = forge_retval(frame, self) # 함수 종료 시점에 breakpoint 걸기
        return False

class get_16byte(gdb.Breakpoint):
    def __init__(self, address, target_memory):
        super(get_16byte, self).__init__(f"*{address}")
        self.target_memory = target_memory
    
    def stop(self):
        print("hit")
        inferior = gdb.selected_inferior()
        result = bytes(inferior.read_memory(self.target_memory, 16)) # 0x4010에서 16바이트 읽기
        print("result:", result.hex())

disable_ptrace()
image_base = 0x555555554000 # gdb 위에서 실행되는 바이너리는 image base가 0x555555554000으로 고정
get_16byte(image_base+0x1391, image_base+0x4010)

ge("run") # BP 설정 다 했으니 실행
exit() # 딱히 의미 없음