#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <stdio.h>

#include <sys/ptrace.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/user.h>

int main() {
    pid_t child = fork();
    if (child == -1) {
        perror("fork");
        return -1;
    }

    if (child == 0) { // 자식 프로세스
        // 부모가 자신을 추적할 수 있도록 설정
        if (ptrace(PTRACE_TRACEME, 0, NULL, NULL) == -1) {
            perror("ptrace");
            exit(1);
        }
        // 부모가 attach하도록 대기하기 위해 시그널 발생시킴
        // 보통 raise(SIGSTOP)을 쓰거나, execve로 새 프로그램을 실행하기도 함
        raise(SIGSTOP);

        // 자식이 하는 임의 작업
        for (int i = 0; i < 5; ++i) {
            printf("Child: i = %d\n", i);
            sleep(1);
            raise(SIGINT); // 매 카운터 출력 마다 SIGINT 시그널 임의 발생
        }
        return 0;
    } else { // 부모 프로세스
        int status;
        // 자식이 SIGSTOP으로 중단될 때까지 대기
        waitpid(child, &status, 0);
        if (WIFSTOPPED(status)) {
            printf("Parent: child has stopped, start tracing...\n");
        }

        // 자식 프로세스가 종료될 때까지 추적
        for (; ;) {
            // 자식 프로세스 실행 계속
            if (ptrace(PTRACE_CONT, child, NULL, NULL) == -1) {
                perror("ptrace");
                break;
            }

            // 자식 프로세스의 이벤트 대기
            waitpid(child, &status, 0);

            // 자식 프로세스가 죽었는지 확인
            if (WIFSIGNALED(status)) {
                printf("Parent: child killed with signal: %d\n", WTERMSIG(status));
                break;
            }

            // 자식 프로세스가 종료되었는지 확인
            if (WIFEXITED(status)) {
                printf("Parent: child exited with status %d\n", WEXITSTATUS(status));
                break;
            }

            // 중단된 경우, 부모 프로세스에서 추가 작업 가능
            if (WIFSTOPPED(status)) {
                printf("Parent: child stopped by signal %d\n", WSTOPSIG(status));
            }
        }
    }
    return 0;
}

#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <string.h>
#include <stdio.h>
#include <errno.h>

#include <sys/ptrace.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/user.h>

char secret[20] = "HelloWorld";

int main() {
    pid_t child = fork();
    if (child == -1) {
        perror("fork");
        return 1;
    }

    if (child == 0) { // 자식 프로세스
        printf("Child: secret = %s / b(secret) = 0x%lx\n", secret, *(unsigned long*)secret);

        ptrace(PTRACE_TRACEME, 0, NULL, NULL);
        raise(SIGSTOP);

        printf("Child: secret after = %s / b(secret) = 0x%lx\n", secret, *(unsigned long*)secret);
        return 0;
    } else {
        // 부모 프로세스
        int status;
        waitpid(child, &status, 0);

        if (WIFSTOPPED(status)) { // 자식 프로세스의 memory를 peek/poke
            long word;
            unsigned long addr; 

            // secret 배열의 주소를 알기 위해서는
            // 실제 바이너리 분석 또는 고정된 오프셋 등을 활용해야 합니다.
            // 여기서는 예시를 위해 "임의의 주소를 이미 안다"고 가정합니다.
            // 따라서, fork 특성 상 같은 주소를 공유하는 전역변수를 생성해서 테스트 합니다.
            // 실제 상황에서는 symbol table, DWARF 디버그 정보 등을 사용해야 합니다.
            addr = (unsigned long)secret; // 가정: secret 배열의 시작 주소

            // 자식 프로세스의 secret 메모리를 읽고 쓰는 예시
            // 실제로는 이 주소가 맞지 않으면 세그먼트 오류가 발생할 수 있음
            errno = 0;
            word = ptrace(PTRACE_PEEKDATA, child, (void*)addr, NULL);

            // "Bye"라는 문자열을 쓰고 싶다고 가정
            // '\0', '\0', '\0', '\0', '\0', 'e', 'y', 'B'
            // 문자열을 리틀 엔디안으로 인코딩해서 long에 넣는 과정이 필요
            long newWord = 0x0000000000657942; 

            if (word == -1 && errno) {
                perror("ptrace peekdata");
            } else {
                printf("Parent: read word = 0x%lx / new word = 0x%lx\n", word, newWord);
            }

            if (ptrace(PTRACE_POKEDATA, child, (void*)addr, (void*)newWord) == -1) {
                perror("ptrace pokedata");
            }

            // 자식 프로세스 재개
            ptrace(PTRACE_CONT, child, NULL, NULL);
        }

        waitpid(child, &status, 0);
        if (WIFEXITED(status)) {
            printf("Parent: child exited.\n");
        }
    }
    return 0;
}

#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <string.h>
#include <stdio.h>
#include <errno.h>

#include <sys/ptrace.h>
#include <sys/wait.h>
#include <sys/user.h>

// 간단히, 자식이 실행할 함수
void test_function() {
    printf("Test Function Start\n");
    for (int i = 0; i < 3; ++i) {
        printf("In loop: i=%d\n", i);
        sleep(1);
    }
    printf("Test Function End\n");
}

int main() {
    pid_t child = fork();
    if (child == 0) { // 자식 프로세스
        ptrace(PTRACE_TRACEME, 0, NULL, NULL);
        raise(SIGSTOP);

        // test_function 실행
        test_function();
        test_function();

        return 0;
    } else { // 부모 프로세스
        int status;
        waitpid(child, &status, 0);

        // 브레이크포인트를 걸고자 하는 주소(이 예시에서는 test_function의 시작 주소)
        // 실제로는 심볼 테이블에서 주소를 구하거나, 동적 분석을 해야 합니다.
        unsigned long breakpoint_addr = (unsigned long)test_function;

        // 원본 명령어 저장용
        long original_data;

        // 1) 원본 명령어 읽기
        errno = 0;
        original_data = ptrace(PTRACE_PEEKTEXT, child, (void*)breakpoint_addr, NULL);
        if (original_data == -1 && errno) {
            perror("ptrace peektext");
            return 1;
        }

        // 2) 브레이크포인트(0xCC) 삽입
        long data_with_break = (original_data & 0xFFFFFFFFFFFFFF00) | 0xCC;
        // x86-64 리틀 엔디안에서, 첫 바이트가 0xCC가 되도록 수정
        if (ptrace(PTRACE_POKETEXT, child, (void*)breakpoint_addr, (void*)data_with_break) == -1) {
            perror("ptrace poketext");
            return 1;
        }

        // 자식 실행
        ptrace(PTRACE_CONT, child, NULL, NULL);

        for (; ;) {
            waitpid(child, &status, 0);
            if (WIFEXITED(status)) {
                printf("Child exited\n");
                break;
            }
            if (WIFSTOPPED(status)) {
                int sig = WSTOPSIG(status);
                if (sig == SIGTRAP) { // 브레이크 포인트 도달
                    printf("Hit breakpoint at 0x%lx\n", breakpoint_addr);

                    // 3) 브레이크포인트를 복원
                    // 원본 명령어 복원
                    ptrace(PTRACE_POKETEXT, child, (void*)breakpoint_addr, (void*)original_data);

                    // 4) RIP를 한 바이트 뒤로 되돌리기
                    // x86-64 환경에서 브레이크포인트 명령어(0xCC)가 1바이트이므로
                    // RIP에서 1만큼 빼서 원래 명령어 재실행
                    struct user_regs_struct regs;
                    ptrace(PTRACE_GETREGS, child, NULL, &regs);
                    regs.rip -= 1; // 브레이크포인트 명령어가 있는 위치
                    ptrace(PTRACE_SETREGS, child, NULL, &regs);

                    // 단일 스텝으로 명령어 한 번만 실행
                    ptrace(PTRACE_SINGLESTEP, child, NULL, NULL);
                    waitpid(child, &status, 0);

                    // 5) 다시 브레이크포인트 설치 (재진입 확인용)
                    ptrace(PTRACE_POKETEXT, child, (void*)breakpoint_addr, (void*)data_with_break);

                    // 이후 재개
                    ptrace(PTRACE_CONT, child, NULL, NULL);
                } else {
                    // 다른 시그널이면 계속
                    ptrace(PTRACE_CONT, child, NULL, sig);
                }
            }
        }
    }
    return 0;
}