포렌식 & 개발 이야기 - Forensics & Development

인터넷이 안되는 시골집에 CCTV 설치하기

pental — Sun, 3 May 2026 00:33:10 +0900

때는 2025년 초쯤, 시골에 계시는 할아버지집 뿐만 아니라 근처에서 큰 불이 발생하였다.

하지만 통신망이 끊겨서 전화조차 터지지 않는 상황,,, 그래서 무슨일 없는지 확인할 수도 없는 상황이라, 근처 지구대에 연락해서 피해상황이 어떤지 등을 확인했던 기억이 있어서 26년 초쯤 CCTV를 설치하기로 협의하였다.

그러나 해당 시골집(친가, 외가)에는 기지국은 설치되어 있지만, 할아버지, 할머니가 인터넷을 사용하지 않는 폴더폰이기에 인터넷망을 구축하기에 월 비용 부담이 조금 크다. (100mb라고 해도 월 2만원대가 기본이기 때문이다..)

그렇다면 두집에 모두 인터넷 라인을 깔게 되면 월 4.4만원이라는 부담이 생기게 되는것이다..

그래서 이 방법을 어떻게 파훼할까 해서 LTE CCTV등을 알아 보았고, 알리에서 LTE CCTV를 파는 것을 확인해서 바로 주문했다.

(본 글은 두집에 설치한 내용이 짬뽕되어 있기 때문에 복잡할 수 있다.)

2026년 5월 기준으로 현재는 5만원 미만으로 살수 있다. 해당 제품을 구입해서 유심을 개통했다.

현재 5회선을 사용하고 있다. 데이터 함께쓰기 요금제로 월 5천원씩 2회선 총 1만원씩 부과되고 이렇게 되면 두집 인터넷 설치 4.4만원보다 3.4만원을 아낀셈이 된것이다. (ESIM 회선도 1개 쓰고 있다, 1회선은 라우터용, 그리고 3회선 전화번호는 나도 모른다..)

2026년 2월

2026년 4월

대리점에 들려서 USIM 발급을 받으려는데 회선이 너무 많아서 "심사 부적격" 판정을 받았지만 어찌저찌 우회해서 발급이 됐다.

현재는 0청년 69요금제로 160GB 요금제를 사용하고 있는데, 카메라에서 사용되는 데이터는 달에 대략 2GB안팍이었다.

(클라우드 서비스를 사용하지 않고, SD카드에 저장하는 방식을 사용함)

폭력적으로 생긴 CCTV에 USIM을 끼워놓고 작동시키면 끝난다. 따로 APN 설정을 하지 않아도 알아서 잡아준다.

태양광으로도 충전이 가능하다고는 하는데 설치가 귀찮으니 패스 하고, 그냥 쿠팡에서 5M짜리 충전선을 구입해서 장착했다.

역시 5m도 충분했다. 3m사도 됐을듯,,,

지금 위 글까지는 자체 LTE모듈이 들어 있는 카메라에 대한 내용이고, 아래는 외가댁에 설치한 LTE 라우터를 이용한 CCTV 설치이다.

외가댁에는 거실 + 현관을 찍기 위해서 LTE 라우터도 하나 구입하였고, 2대를 연결한다.

간단하게 드릴로 뚫고 설치하고 얘도 태양광을 달기에는 영 못미더워서 그냥 DC 5V로 연결했다.

굉장히 만족스럽게 잘 장착되었고, 잘 작동한다.

이상 끝.

[2025 DFC] 2025 디지털포렌식 챌린지 - 301 - 404 VMK Not Found

pental — Mon, 20 Apr 2026 21:15:57 +0900

Step-by-step methodology:

문제풀이에 앞서 MD5 해시값 검증을 진행한다.

그림 1 Mem_files.zip 파일 해시 검증

문제에서 주어진 Mem_files.zip의 MD5 해시값이 C488FB533376039D5345F19E65C4D190과 동일한것을 확인했다.

문제에서 주어진 이미지 파일인 diskimg 파일의 정보는 다음과 같다.

그림 2 diskimg 파일의 해시 정보

File Name	diskimg
File Size	1,048,576,000 바이트
MD5	2D1560610DF4AF997A00D3882E4DFDF5
SHA1	A743E5447280DF0210B09543B044EC423ACF55D1

표 1 diskimg 파일의 정보

해당 파일을 HxD를 통해 확인하면 다음과 같다.

그림 3 HxD를 통해 확인한 diskimg 파일

HxD를 통해 확인한 결과, FVE-FS 라는 시그니처를 확인 할 수 있으며, 이는 BitLocker 암호화 볼륨의 메타데이터 시그니처이다. BitLocker로 보호되는 드라이브의 시작 부분(메타데이터 영역)에 기록되는 특징을 가지고 있다.

diskimg 파일을 인식시키기 위해 아스날 이미지 마운터를 사용하였으며 아래는 diskimg파일를 논리적으로 인식시키는 과정이다.

그림 4 ARSENAL IMAGE MOUNTER의 포터플 파일 폴더

그림 5 ARSENAL IMAGE MOUNTER의 실행화면

그림 6 diskimg 파일을 탑재한 모습

아스날 이미지 마운터 (ARSENAL IMAGE MOUNTER)을 통해 diskimg를 탑재 후 파일 탐색기를 통해 이미지가 정상적으로 마운트 된 것을 확인 할 수 있다.

그림 7 파일탐색기를 통해 확인한 이미지파일 인식 확인

그림 8 디스크 우 클릭 후 메뉴 일부

탑재한 결과 비트라커로 암호화된 디스크 1개를 확인 할 수 있다. 비트라커 암호화 키를 확인하기 위해서 메모리 분석을 진행한다.

Mem_files.zip 파일을 압축 해제하면 다음 그림과 같이 6개의 메모리 덤프파일을 확인할 수 있다.

그림 9 Mem_files.zip의 압축해제 후 파일 목록

해당 파일은 메모리 덤프 파일이며 cat 명령어를 통해서 6개로 나뉘어져 있는 파일을 모두 통합한다.

pental@pentalui-MacBookAir Mem_files % cat mempart00.bin mempart01.bin mempart02.bin mempart03.bin mempart04.bin mempart05.bin > memory.dmp

표 2 메모리 파일을 통합하기 위해 사용한 명령어

비트라커(BitLocker) 복구키(Recovery Key) 는 Windows에서 드라이브 암호화를 해제하거나, 정상적인 인증 절차로는 접근할 수 없을 때 데이터를 복구하기 위해 사용하는 특수한 48자리 숫자 암호이다. 복구키의 경우 6자리 숫자가 8개의 그룹 형태를 나타내고 있으며 예시는 다음과 같다.

123456-123456-123456-123456-123456-123456-123456-123456

표 3 비트라커 복구키의 예시

합쳐진 memory 덤프 파일에서 strings 및 정규식을 통해 Bitlocker 복구키와 관련된 증거를 확보한다.

strings memory.dmp | grep -E "[0-9]{6}-[0-9]{6}-[0-9]{6}-[0-9]{6}-[0-9]{6}-[0-9]{6}-[0-9]{6}-[0-9]{6}"

표 4 정규식을 통한 복구키 파싱 명령어

위 명령을 수행한 결과 아래와 같은 복구키를 확인 할 수 있다.

played by your PC, then use the following key to unlock your drive. Recovery Key: 322839-683573-358259-411290-335368-358182-335566-709874 If the above identifier doesn't match the one displayed by your PC, then this isn't the right key to unlock your drive. Try another recovery key, or refer to https://go.microsoft.com/fwlink/?LinkID=260589 for additional assistance.
entifier matches the one displayed by your PC, then use the following key to unlock your drive. Recovery Key: 060896-522335-394207-442046-104115-373010-632456-443289 If the above identifier doesn't match the one displayed by your PC, then this isn't the right key to unlock your drive. Try another recovery key, or refer to https://go.microsoft.com/fwlink/?LinkID=260589 for additional assistance.
8FE0955C If the above identifier matches the one displayed by your PC, then use the following key to unlock your drive. Recovery Key: 322839-683573-358259-411290-335368-358182-335566-709874 If the above identifier doesn't match the one displayed by your PC, then this isn't the right key to unlock your drive. Try another recovery key, or refer to https://go.microsoft.com/fwlink/?LinkID=260589 for additional assistance.
To verify that this is the correct recovery key, compare the start of the following identifier with the identifier value displayed on your PC. Identifier: 1088859C-680D-45C7-9376-7C228FE0955C If the above identifier matches the one displayed by your PC, then use the following key to unlock your drive. Recovery Key: 322839-683573-358259-411290-335368-358182-335566-709874 If the above identifier doesn't match the one displayed by your PC, then this isn't the right key to unlock your drive. Try another recovery key, or refer to https://go.microsoft.com/fwlink/?LinkID=260589 for additional assistance.
BitLocker Drive Encryption recovery key To verify that this is the correct recovery key, compare the start of the following identifier with the identifier value displayed on your PC. Identifier: 1088859C-680D-45C7-9376-7C228FE0955C If the above identifier matches the one displayed by your PC, then use the following key to unlock your drive. Recovery Key: 322839-683573-358259-411290-335368-358182-335566-709874 If the above identifier doesn't match the one displayed by your PC, then this isn't the right key to unlock your drive. Try another recovery key, or refer to https://go.microsoft.com/fwlink/?LinkID=260589 for additional assistance.
BitLocker Drive Encryption recovery key To verify that this is the correct recovery key, compare the start of the following identifier with the identifier value displayed on your PC. Identifier: 91442E6D-8B2B-42F0-84F7-A844A6C15290 If the above identifier matches the one displayed by your PC, then use the following key to unlock your drive. Recovery Key: 060896-522335-394207-442046-104115-373010-632456-443289 If the above identifier doesn't match the one displayed by your PC, then this isn't the right key to unlock your driv
BitLocker Drive Encryption recovery key To verify that this is the correct recovery key, compare the start of the following identifier with the identifier value displayed on your PC. Identifier: 1088859C-680D-45C7-9376-7C228FE0955C If the above identifier matches the one displayed by your PC, then use the following key to unlock your drive. Recovery Key: 322839-683573-358259-411290-335368-358182-335566-709874 If the above identifier doesn't match the one displayed by your PC, then this isn't the right key to unlock your drive. Try another recovery key, or refer to https://go.microsoft.com/fwlink/?LinkID=260589 for additional assistance.

표 5 표 4의 실행 결과

위 결과를 종합적으로 분석한 결과 2개의 복구키를 확인 할 수 있다.

Identifier	Recovery Key
1088859C-680D-45C7-9376-7C228FE0955C	322839-683573-358259-411290-335368-358182-335566-709874
91442E6D-8B2B-42F0-84F7-A844A6C15290	060896-522335-394207-442046-104115-373010-632456-443289

표 6 정규식을 통해 추출한 복구키 정보

그림 10 비트라커 디스크 잠금 해제 과정

비트라커의 경우 드라이브 암호를 알지 못하는 경우 기타 옵션을 통해 복구키를 입력 할 수 있다.

그림 11 기타 옵션을 클릭 한 후 모습

복구 키 입력 버튼을 클릭하면 해당 디스크의 키 ID를 확인 할 수 있다.

그림 12 복구 키 입력을 클릭 한 후 확인되는 식별자 ID

위 그림에서 확인 할 수 있듯이 키 ID가 91442E6D임을 나타내고 있으며, 이 키는 메모리 덤프 파일에서 정규식을 통해 추출한 결과에서 동일한 8자리 식별자를 확인 할 수 있다.

그림 13 추출한 복구키를 입력한 모습

따라서 표 6을 참고하여 91442E6D 키 ID를 가진 Recovery Key를 입력한다.

그림 14 비트라커가 해제된 모습

정상적으로 비트라커가 해제되었으며 해당 디스크에서는 flag.txt 파일을 확인 할 수 있다.

flag.txt 파일의 정보는 다음과 같다.

File Name	flag.txt
File Size	20 바이트
MD5	BDEA960F1BC2F21D8CF3579D44DD0FED
SHA1	29492F034EDF0EFA5553305779752868C2989697

표 7 flag.txt 파일 정보

윈도우 기본 프로그램인 메모장을 통해 flag.txt 파일을 열어본 결과는 다음과 같다.

그림 15 flag.txt 에 담겨져 있는 내용

Base64로 인코딩 된 결과를 확인 할 수 있으며 복호화 하기 위해서 base64decode.org 온라인 도구를 사용하였다. (https://base64decode.org)

그림 16 base64 복호화 모습

복호화 결과 200 Ok-DFC2025 라는 값을 얻을 수 있다.

답 : 200 Ok-DFC2025

[2025 DFC] 2025 디지털포렌식 챌린지 - 207 – iBackup Trace

pental — Mon, 20 Apr 2026 21:12:43 +0900

Step-by-step methodology:

문제 풀이에 앞서, dfchallenge.org에서 제공한 문제 파일의 해시값과 다운로드 받은 파일의 해시값을 비교하여 동일성을 검증하였다.

그림 1 dfchallenge.org에 명시되어 있는 MD5 해시값

그림 2 HashTab을 사용해 다운로드 받은 파일의 MD5 해시값

주어진 파일은 backup.zip 파일이며 상세 정보는 다음과 같다.

FileName	backup.zip
Size	131,621,229 Bytes
MD5	d4591cd1aa35101c2484bc6a6d986538

표 1 주어진 파일의 상세 정보

압축을 해제하면 `00008130-001E682D11181001C` 폴더가 생성되며, 하위 폴더의 예시는 다음과 같다.

그림 3 압축 해제 된 파일의 일부 폴더

문제에서 주어진 파일들은 iTunes를 통한 아이폰 논리 백업파일의 형태이며, 일반적인 백업 파일과 다르게 Manifest.db 등이 0Bytes로 설정되어 문제 내용과 같이 일부 내용은 복구 되지 못한 모습을 보여주고 있다.

그림 4 비정상적으로 Manifiest.db 파일등이 0bytes로 되어 있는 모습

문자 메시지 기록과 연락처를 복구하기 위해서는 각각 어떤 파일과 매핑되는지를 먼저 확인해야 한다. 이를 위해 문제 시나리오와 유사한 환경에서 직접 아이폰 논리 백업을 수행하였다. 논리 백업이 완료된 후, Manifest.db 파일을 분석하여 문자 메시지 및 연락처 데이터베이스의 실제 저장 경로를 확인하였다.

그림 5 비슷한 환경에서 논리 백업 후 Manifest.db 파일 내 sms.db 문자열 검색 결과

그림 6 비슷한 환경에서 논리 백업 후 Manifest.db 파일 내 AddressBook.sqlitedb 문자열 검색 결과

이 과정에서 확인된 fileID 값은 SHA1 해시를 기반으로 생성된다. 해시 생성 방식은 Manifest.db의 Files 테이블에서 domain 컬럼과 relativePath 컬럼을 “-”로 연결한 문자열을 입력값으로 하여 SHA1 알고리즘을 적용하는 방식이다.

import hashlib

def string_to_sha1(s) :
return hashlib.sha1(s.encode('utf-8')).hexdigest()

# "3d0d7e5fb2ce288813306e4d4636395e047a3d28"
print(string_to_sha1("HomeDomain" + "-" + "Library/SMS/sms.db"))
# "31bb7ba8914766d4ba40d6dfb6113c8b614be442"
print(string_to_sha1("HomeDomain" + "-" + "Library/AddressBook/AddressBook.sqlitedb"))

표 2 특정 경로를 sha1으로 변환 검증 코드

각각 문제에서 필요한 데이터베이스의 파일 해쉬값은 다음과 같다.

Type	SHA1
SMS	3d0d7e5fb2ce288813306e4d4636395e047a3d28
AddressBook	31bb7ba8914766d4ba40d6dfb6113c8b614be442

표 3 문제에서 필요한 SHA1 해시값 (fileID)

총 몇개의 메세지가 존재하는가? (50점)

SMS 데이터베이스는 3d0d7e5fb2ce288813306e4d4636395e047a3d28 파일에 존재하며, 실제 파일명은 sms.db이다. 이하 본 보고서에서는 이를 sms.db 파일이라 칭한다.

해당 데이터베이스는 DB Browser for SQLite 도구를 이용하여 분석하였다. sms.db의 message 테이블을 조회함으로써 전체 문자 메시지 내역을 확인할 수 있었다.

그림 7 DB Browser for SQLite를 통한 sms.db 파일 내 message 테이블의 일부

SELECT COUNT(*) FROM message;

표 4 전체 행 개수를 계산 하기 위한 SQL 쿼리

그림 8 SQL 쿼리 결과

정답 : 131개

2. 총 몇 명이 주소록에 저장되어있는가? (50점)

주소록 데이터베이스는 31bb7ba8914766d4ba40d6dfb6113c8b614be442 파일에 존재하며, 실제 파일명은 AddressBook.sqlitedb이다. 이하 본 보고서에서는 이를 AddressBook 파일이라 칭한다.

해당 데이터베이스는 DB Browser for SQLite 도구를 통해 분석하였다. 주소록에 저장된 인원 정보는 ABPerson 테이블에 기록되어 있으며, 이를 기반으로 전체 연락처 내역을 확인할 수 있다.

그림 9 DB Browser for SQLite를 통한 AddressBook 파일 내 ABPerson 테이블의 일부

SELECT COUNT(*) FROM ABPerson;

표 5 전체 행 개수를 확인하기 위한 SQL 쿼리

그림 10 SQL 쿼리 결과

3. 지인으로부터 온 메세지의 제목과 내용을 알아내시오. (50점)

AddressBook 파일에서는 총 12명의 주소록을 확인할 수 있으며, 문제에서 의미하는 지인은 A씨의 주소록에 저장된 사람을 의미하는 것으로 추정된다. 따라서 AddressBook 파일에 존재하는 주소록을 기반으로 분석을 진행한다.

아래 사진은 AddressBook 파일의 ABPerson 테이블의 일부 칼럼의 내용이다.

그림 11 AddressBook 파일 내 ABPerson 테이블 일부

위 사진에서는 주소록에 저장된 실제 전화번호를 확인할 수 없으며, ABMultiValue 테이블에서 실제 연락처 정보를 확인할 수 있다.

아래 사진은 AddressBook 파일의 ABMultiValue 테이블의 일부 칼럼의 내용이다.

그림 12 AddressBook 파일 내 ABMultiValue 테이블 일부

해당 데이터베이스 구조를 도식화하면 다음과 같다.

그림 13 AddressBook 파일의 구조 도식화

AddressBook 파일의 ABPerson 테이블과 ABMultiValue 테이블이 연관이 있는 테이블이다.

ABPerson의 ROWID가 ABMultiValue 테이블의 record_id와 연결된다. 따라서 아래와 같은 주소록 정보를 얻을 수 있다.

ABPerson-ROWID	ABPerson-FIRST	ABPerson-LAST	ABMultiValue-value
1	Lisa	Yo	010990058411
2	James	Ahn	010210084511
3	Emily	Smith	010850861301
4	Michael	Johnson	010514438041
5	Olivia	Williams	010905861151
6	Ethan	Brown	010378812541
7	Ava	Jones	010667438511
8	Daniel	Garcia	010455304201
9	Sophia	Miller	010751292861
10	Benjamin	Davis	010385699121
11	Mia	Wilson	010985233641
12	Lucas	Anderson	010318424451

표 6 ABPerson과 ABMultiValue를 조합한 정리 테이블

위 표에서 확인한 전화번호를 바탕으로 DB Browser for SQLite 도구를 통해 SMS파일의 message 테이블에서 필터링 한 결과 010751292861 번호에서만 1개의 메시지가 발견되었다. 이 전화번호는 message 테이블에 fallback_hash 칼럼에 다음과 같은 형식으로 저장되어 있다.

그림 14 sms.db 내 message 테이블에서 발견된 751292861 정보

message 테이블의 구조는 다음과 같다.

컬럼명	설명	활용 포인트
ROWID	각 메시지의 고유 식별자 (PK)	다른 테이블(message_attachment_join)과 매핑 시 기준 키
guid	메시지 고유 식별자 (UUID)	iMessage/DB 간 메시지 추적
text	문자 메시지 본문	실제 송수신된 메시지 내용
subject	메시지 제목	MMS 등 제목 포함 메시지 분석 시
handle_id	발신/수신자 식별 ID (handle 테이블과 매핑)	송수신 상대 확인
date	메시지 생성(전송) 시각 (epoch time)	타임라인 분석
date_read	읽은 시각	수신자 확인 여부 추적
date_delivered	배달 완료 시각	전송 성공 여부 확인
is_from_me	내가 보낸 메시지 여부 (1=보낸 메시지, 0=수신 메시지)	송·수신 구분
is_sent	메시지 전송 완료 여부	실제 전송 성공 여부 판단
is_read	메시지 읽음 여부	확인/미확인 상태 분석
service	서비스 유형 (예: SMS, iMessage)	통신 방식 구분
account / account_guid	사용된 계정 정보	Apple ID, iCloud 연계 확인
cache_has_attachments	첨부파일 존재 여부 (0=없음, 1=있음)	첨부 추적 여부 판단
fallback_hash	전화번호/세션/해시가 혼합된 값	발신자 번호 추적, 데이터 복구 단서

표 7 sms.db 내 message 테이블의 구조

s:tel:+8210751292861|0(28)<6F04EC061108B8DA6F7852BEC387D9800A6A2AEE55BABB4BEB5A32DC448881A6>

표 8 fallback_hash 칼럼에서 발견된 010751292861 정보

Fallback_hash의 구조는 다음과 같다.

s:tel:+8210751292861 : 전화번호가 국제 표준(E.164) 형식으로 저장된 부분이며, +82는 대한민국 국가번호를 의미한다.

|0(28) : 메시지 전송 세션과 관련된 내부 식별자를 의미한다.

<...> : 송수신 시점에서 메시지 무결성 검증 및 추적을 위한 해시값 형태이다.

즉, fallback_hash는 전화번호를 국제 표기 방식으로 변환한 후, 메시지 전송 과정의 고유 식별자와 해시값을 함께 저장하는 필드로 볼 수 있다. 이를 통해 단말기 간 동기화 또는 데이터베이스 복구 과정에서 중복 메시지를 구분하거나 무결성을 확인할 수 있다.

제목

Please confirm your order details

내용

[Web Message]
Transfer Path Activated — Clean Lane, Silent Move
Greetings, Mate. This isn’t a pitch. It’s a notice.
If you're reading this, your node is trusted and your line is considered green.

Our infrastructure handles mid- to high-volume dispatches, including flagged stacks.
We process across primary, relay, and ghost channels, depending on timing and pressure.

Primary Gateway: http://70.com/login.asp
Clearance Code: 555

✅ Release-on-trigger system — no confirmations needed post-signal
✅ Zero KYC enforcement on receiver side
✅ Currency-neutral transfer (₩→$, $→€, or internal credits)
✅ Routing auto-adjusts based on throughput; congested lines reassign in real time
✅ Split delivery optional — main + buffer payload if flagged

Standard dispatch: up to ₩1B per cycle
Parallel links yield up to 1.2%
Full log trace available on backchannel
Ledger access given via secondary hash (on request only)

If your recipient requires obscured receipt, enable blind handoff mode in your key panel.
Relay points are scrubbed at 48-hour intervals. No residuals. No trace.

We’re not a brand. We’re a mechanism.
Run a 100K test cycle — it’ll move cleaner than any front you’ve dealt with.

표 9 문제 3번의 정답

5. 해당 메시지에 첨부된 것으로 추정되는 파일의 저장된 파일명을 찾으시오. (50점)

sms.db 파일에는 문자 메시지 송수신 내역이 저장되어 있으며, 이를 기반으로 전체 대화 기록을 확인할 수 있다. 아래 그림은 SMS 데이터베이스의 일부 구조를 도식화한 것이다.

그림 15 sms.db 파일의 구조 도식화

sms.db의 message 테이블에서 각 레코드는 고유 식별자인 ROWID를 가진다. 이 ROWID는 message_attachment_join 테이블의 message_id와 1:1로 매핑된다. 또한, message_attachment_join 테이블의 attachment_id는 attachment 테이블의 ROWID와 1:1 연관 관계를 형성한다.

message_attachment_join 테이블은 문자 메시지(message 테이블)와 첨부파일(attachment 테이블) 간의 관계를 정의한다. 각 메시지는 0개 이상의 첨부파일을 가질 수 있으며, 하나의 첨부파일이 여러 메시지와 연결될 수도 있다. 이러한 관계를 관리하기 위해 중간 매핑 테이블이 사용된다.

컬럼명	타입	설명
message_id	INTEGER	message 테이블의 ROWID (외래키)
attachment_id	INTEGER	attachment 테이블의 ROWID (외래키)

표 10 message_attachment_join 테이블의 구조

attachment 테이블은 문자 메시지에 첨부된 파일의 메타데이터를 저장한다. 주요 컬럼의 의미는 다음과 같다.

컬럼명	타입	설명
ROWID	INTEGER	각 첨부파일 레코드의 고유 식별자 (기본키)
guid	TEXT	첨부파일의 전역 고유 식별자 (UUID 형식)
created_date	INTEGER	첨부파일 생성 시각 (UNIX 타임스탬프)
start_date	INTEGER	첨부파일 전송 시작 시각
filename	TEXT	첨부파일 저장 경로
uti	TEXT	Uniform Type Identifier (ex. public.png)
mime_type	TEXT	MIME 타입 (ex. image/png)
transfer_state	INTEGER	첨부 전송 상태 코드
is_outgoing	INTEGER	송신 여부 (1=보낸 첨부, 0=수신 첨부)
user_info	BLOB	사용자 관련 메타데이터
transfer_name	TEXT	전송된 실제 파일명
total_bytes	INTEGER	첨부파일 크기 (bytes 단위)
is_sticker	INTEGER	스티커 여부
attribution_info	BLOB	메시지 출처 정보
ck_sync_state	INTEGER	CloudKit 동기화 상태
ck_record_id	TEXT	CloudKit 레코드 ID
original_guid	TEXT	원본 GUID (중복 방지를 위해 UNIQUE 제약 적용)
is_commsafety_sensitive	INTEGER	민감 콘텐츠 여부 표시
emoji_image_content_identifier	TEXT	(이모지 이미지의 경우) 콘텐츠 식별자
emoji_image_short_description	TEXT	(이모지 이미지의 경우) 짧은 설명
preview_generation_state	INTEGER	미리보기 생성 상태

표 11 attachment 테이블의 구조

따라서, 3번 문제에서 확인한 메시지의 ROWID 값을 기준으로 message_attachment_join 테이블을 조회하면 해당 메시지와 연결된 첨부파일 정보를 확인할 수 있다.

그림 16 sms.db 파일 내 message_attachment_join 테이블의 일부

3번 문제에서 확인된 문자 메시지의 ROWID는 125이며, 해당 메시지는 attachment_id = 11과 연관되어 있다. 따라서 attachment 테이블에서 ROWID = 11인 레코드를 조회하면 해당 메시지에 첨부된 파일 정보를 확인할 수 있다.

그림 17 sms.db 파일 내 attachment 테이블의 일부 및 ROWID 11 정보

해당 데이터(ROWID=11)를 추출한 결과는 아래와 같다.

컬럼명	값
ROWID	11
guid	8B37AEFD-D9D3-401E-8A73-8DB82BBAB25D
filename	~/Library/SMS/Attachments/c7/07/8B37AEFD-D9D3-401E-8A73-8DB82BBAB25D/Resized_1753100894543_1753101056921.png
uti	public.png
mime_type	image/png
transfer_name	Resized_1753100894543_1753101056921.png
total_bytes	567599

표 12 ROWID가 11인 데이터

분석 결과, 해당 메시지에 첨부된 것으로 확인되는 파일명(transfer_name 컬럼)은 다음과 같다.

정답 : Resized_1753100894543_1753101056921.png

[2025 DFC] 2025 디지털포렌식 챌린지 - 206 – Let’s Vibe

pental — Mon, 20 Apr 2026 21:02:31 +0900

Step-by-step methodology:

문제 풀이에 앞서 대회에서 주어진 이미지 파일과 다운로드 받은 파일의 해시 값 검증을 진행한다.

Figure 1 대회에서 주어진 MD5 해시값

Figure 2 HashTab을 이용한 다운로드 받은 파일의 해시값 검증

주어진 파일의 정보는 다음과 같다.

File Name	desktop.zip
File Size	20,473,057,512 바이트
MD5	3908E6DBDE1ED0F0B6A41F97693DA3CB
SHA-1	EA2807F984EA95C40FD903C04B876E05B1AAD340

Table 1 주어진 파일의 정보

압축을 해제하면 다음과 같은 파일을 확인 할 수 있으며 각각 정보는 다음과 같다.

Figure 3 압축 해제 된 파일들

총 18개의 가상 디스크 이미지가 확인되었다.

1. 데스크톱에 설치된 응용프로그램들의 정보를 서술하시오.(10 points)

\Users\dfc2025\NTUSER.DAT

Table 2 설치된 응용프로그램의 정보를 확인하기 위한 경로

다음 경로에서 설치된 응용프로그램들의 정보를 확인 할 수 있다.

Figure 4 Magnet Axiom을 이용한 설치된 응용프로그램 확인

Magnet Axiom 도구를 사용하여 추출된 결과는 다음과 같다.

프로그램명	설치 일자	버전 정보
VMware Tools	2025-07-26 PM 11:59:24.547	12.4.5.23787635
Cursor	2025-07-27 PM 4:06:23.666	1.2.4
Windsurf	2025-07-27 PM 4:13:33.934	1.11.1
GitHub Desktop	2025-07-29 AM 1:15:40.448	3.5.2
Eraser 6.2.0.2996	2025-07-29 AM 2:04:54.141	6.2.2996
Clipchamp		3.0.10220.0

Figure 5 설치된 응용프로그램 정보

2. 개발자가 사용한 Github 계정을 식별하시오 (10 points)

다음 경로에서 Github 계정 정보를 식별 할 수 있다.

\Users\dfc2025\.gitconfig

Figure 6 이미지에서 발견된 gitconfig 파일 경로

Figure 7 gitconfig 파일 내 정보

추가적으로 Github Desktop이 설치되어 있고, 프리패치 등 Github Desktop을 사용한 흔적이 있으며, 해당 부분을 분석한 결과는 다음과 같다.

\Users\dfc2025\AppData\Roaming\Github Desktop\Local Storage\leveldb\000003.log

Table 3 Github Dektop에서 생성된 로그파일 1

위 경로는 Github Desktop에서 생성된 로그 파일이며 해당 로그 파일에도 .gitconfig 와 동일한 Github 이름과 이메일을 확인 할 수 있다.

Figure 8 000003.log 파일의 일부

{"login":"cyber-chef-2025","endpoint":"https://api.github.com","token":"","emails":[{"email":"dfc2025.glen@gmail.com","primary":true,"verified":true,"visibility":"public"}],"avatarURL":"https://avatars.githubusercontent.com/u/223317873?v=4","id":223317873,"name":"cyber-chef-2025","plan":"free","

Table 4 000003.log 파일의 일부

정답

github 계정 : cyber-chef-2025

github 이메일 : dfc2025.glen@gmail.com

3. 개발자가 첫번째로 사용한 IDE에서 사용한 프롬프트를 분석하고, 타임라인을 구성하시오 (50 points)

첫번째로 사용한 IDE를 찾기 위해서 프리패치 분석을 진행했다.

먼저 설치된 IDE는 Windsurf, Cursor 총 2개가 설치되어 있다. 각각의 프리패치 기록은 다음과 같다.

Figure 9 Magnet Axiom으로 확인한 Windsurf의 프리패치 기록

Figure 10 Magnet Axiom으로 확인한 Cursor의 프리패치 기록

프리패치 기록 상 먼저 실행한 프로그램은 Cursor.exe이며, 2025년 7월 27일 오후 4시 9분 33초에 실행된 흔적을 확인 할 수 있다.

Cursor에서 사용한 프롬프트를 분석하기 위해서 다음 경로를 참조하였다.

\Users\dfc2025\AppData\Roaming\Cursor\User\workspaceStorage\558804eb26cea58c5895507e7784c194\state.vscdb

Table 5 Cursor의 내부 데이터 저장 경로

위 경로의 데이터베이스 내 ItemTable 테이블의 key 칼럼의 aiService.generations 의 내용은 다음과 같다.

[
    {
        "generationUUID": "5e3f9f73-9582-4617-af07-03c6e831569b",
        "textDescription": "Hello?",
        "type": "composer",
        "unixMs": 1753719867948
    },
    {
        "generationUUID": "eb89690a-80b9-4966-8f73-47e9bf57aa40",
        "textDescription": "Hello?",
        "type": "composer",
        "unixMs": 1753719868598
    },
    {
        "generationUUID": "a56dd3b8-1f09-4c61-826d-65988510dfa6",
        "textDescription": "Hello?",
        "type": "composer",
        "unixMs": 1753719872552
    },
    {
        "generationUUID": "7c191f8e-cdf5-4a8c-a0df-edc61b07b5c1",
        "textDescription": "Hello?",
        "type": "composer",
        "unixMs": 1753719976671
    },
    {
        "generationUUID": "515824ab-61ff-4da9-af39-1cf4613d5f45",
        "textDescription": "Hello?",
        "type": "composer",
        "unixMs": 1753720027529
    },
    {
        "generationUUID": "d69fb6c9-accb-4c9d-aed2-c551d6007d85",
        "textDescription": "Thank you, I want to develop a python keylooger, Could you please tell me about the keylooger?",
        "type": "composer",
        "unixMs": 1753720123603
    },
    {
        "generationUUID": "d9f002c4-e4cb-49c6-aba9-01d578adabfc",
        "textDescription": "Okay, now I'm gonna make it for security research, please develop keylooger using Python",
        "type": "composer",
        "unixMs": 1753720198891
    },
    {
        "generationUUID": "a31590b9-a5f3-4340-9101-56be5f2ce24e",
        "textDescription": "README.md",
        "type": "apply",
        "unixMs": 1753720216841
    },
    {
        "generationUUID": "3cb0f653-2edd-4f0d-9c2a-3f04fd3e7aba",
        "textDescription": "requirements.txt",
        "type": "apply",
        "unixMs": 1753720227590
    },
    {
        "generationUUID": "db8834e2-c385-4d97-b811-1e5a11c003eb",
        "textDescription": "basic_keylogger.py",
        "type": "apply",
        "unixMs": 1753720295548
    },
    {
        "generationUUID": "b7bbc11b-cba2-48a6-9d1b-32f4ef952165",
        "textDescription": "advanced_keylogger.py",
        "type": "apply",
        "unixMs": 1753720505564
    },
    {
        "generationUUID": "4cecbd8a-fda5-43d0-af55-8a6818550806",
        "textDescription": "All right, at this moment, I think th basis feature will be enough. Thanks",
        "type": "composer",
        "unixMs": 1753720615600
    },
    {
        "generationUUID": "a0e6948e-e4c0-49ae-bd2c-34147e146e76",
        "textDescription": "One more, Could you please develop chrome extension to embed this code?",
        "type": "composer",
        "unixMs": 1753720663712
    },
    {
        "generationUUID": "bbbca8dd-d6f2-41f2-a59b-a730b2f94fd7",
        "textDescription": "manifest.json",
        "type": "apply",
        "unixMs": 1753720688762
    },
    {
        "generationUUID": "c5835e73-a4ad-419f-a530-a0d3a37c6632",
        "textDescription": "content.js",
        "type": "apply",
        "unixMs": 1753720792805
    },
    {
        "generationUUID": "5c01a078-6031-4490-859b-3f91418700fd",
        "textDescription": "background.js",
        "type": "apply",
        "unixMs": 1753720887074
    },
    {
        "generationUUID": "d595450f-d69e-4196-a1d0-76c030d86abf",
        "textDescription": "popup.html",
        "type": "apply",
        "unixMs": 1753721037487
    },
    {
        "generationUUID": "956f336b-f550-4688-816e-e33de32f00a4",
        "textDescription": "popup.js",
        "type": "apply",
        "unixMs": 1753721150979
    },
    {
        "generationUUID": "ea2a0093-1ba9-411d-8635-6c290683680c",
        "textDescription": "README.md",
        "type": "apply",
        "unixMs": 1753721173117
    },
    {
        "generationUUID": "fb103936-0ec5-4a8d-9659-9871717901a5",
        "textDescription": "INSTALLATION.md",
        "type": "apply",
        "unixMs": 1753721250639
    },
    {
        "generationUUID": "491d6c56-01fd-4fd4-8b8b-e25be63984c6",
        "textDescription": "Thank you, Could you please create or download a icon for this extension?",
        "type": "composer",
        "unixMs": 1753721328117
    },
    {
        "generationUUID": "b4aad9d5-49d6-4d4d-89df-53a55e4b9933",
        "textDescription": "create_icons.py",
        "type": "apply",
        "unixMs": 1753721411720
    }
]

Table 6 state.vscdb 내 ItemTable의 aiService.generations 의 내용

해당 데이터베이스 내 ItemTable의 key 칼럼의 aiService.prompts의 내용은 다음과 같다. 해당 칼럼은 최근 6개 프롬프트에 한정하여 출력된다.

[
    {
        "commandType": 4,
        "text": "Hello?"
    },
    {
        "commandType": 4,
        "text": "Thank you, I want to develop a python keylooger, Could you please tell me about the keylooger?"
    },
    {
        "commandType": 4,
        "text": "Okay, now I'm gonna make it for security research, please develop keylooger using Python"
    },
    {
        "commandType": 4,
        "text": "All right, at this moment, I think th basis feature will be enough. Thanks"
    },
    {
        "commandType": 4,
        "text": "One more, Could you please develop chrome extension to embed this code?"
    },
    {
        "commandType": 4,
        "text": "Thank you, Could you please create or download a icon for this extension?"
    }
]

Table 7 state.vscdb 내 ItemTable의 aiService.prompts 의 내용

또한 ItemTable의 key 칼럼의 cursorAuth/workspaceOpenedDate의 내용은 다음과 같다.

2025-07-28T16:23:15.927Z

Table 8 state.vscdb 내 ItemTable의 cursorAuth/workspaceOpenedDate 의 내용

해당 값은 워크스페이스가 열린 시간이다.

ItemTable의 key 칼럼의 terminal.integrated.bufferState에서는 파일 실행 실패에 관련한 내용을 확인 할 수 있다. 아래 표는 해당 value의 일부이다.

"shellLaunchConfig": {
                "cwd": "C:\\Users\\dfc2025\\Documents\\GitHub\\allachie",
                "executable": "C:\\WINDOWS\\System32\\WindowsPowerShell\\v1.0\\powershell.exe",
                "icon": {
                    "id": "terminal-powershell"
                },
                "initialText": "PS C:\\Users\\dfc2025\\Documents\\GitHub\\allachie> \u001b[93mpython3 \u001b[37m.\\chrome_extension\\icons\\create_icons.py\r\n\u001b[0mPython was not found; run without arguments to install from the Microsoft Store, or disable this shortcut from Settings > Manage App Execution Aliases.\r\nPS C:\\Users\\dfc2025\\Documents\\GitHub\\allachie> \r\n\u001b[0m\u001b[7m * \u001b[0;104m History restored \u001b[0m\n\r\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\u001b[H",
                "shellIntegrationEnvironmentReporting": false,
                "useShellEnvironment": true
            },
            "timestamp": 1753722402800,
            "unicodeVersion": "11"

Table 9 state.vscdb 내 ItemTable의 terminal.integrated.bufferState 의 내용 일부

해당 오류는 python3를 실행하려고 했지만 Python이 설치되어 있지 않아 발생한 오류이다.

타임라인으로 정리하면 다음과 같다.

Time (UTC + 9)	Prompt	Type	Apply File	Content
2025-07-29 01:23:15				워크스페이스 열린 시간
2025-07-29 01:24:27.948	Hello?	composer		사용자 질의 시작
2025-07-29 01:24:28.598	Hello?	composer		사용자 메시지
2025-07-29 01:24:32.552	Hello?	composer
2025-07-29 01:26:16.671	Hello?	composer
2025-07-29 01:27:07.529	Hello?	composer
2025-07-29 01:28:43.603	Thank you, I want to develop a python keylooger, Could you please tell me about the keylooger?	composer		사용자 메시지 파이썬을 이용한 키로거 개발 요청 프롬프트
2025-07-29 01:29:58.891	Okay, now I'm gonna make it for security research, please develop keylooger using Python	composer		사용자 메시지 파이썬을 이용한 키로거 개발 요청 프롬프트
025-07-29 01:30:16.841		apply	README.md	Cursor의 README.md 적용
025-07-29 01:30:27.590		apply	requirements.txt	Cursor의 requirements.txt 적용
025-07-29 01:31:35.548		apply	basic_keylogger.py	Cursor의 basic_keylogger.py 적용
025-07-29 01:35:05.564		apply	advanced_keylogger.py	Cursor의 advanced_keylogger.py 적용
025-07-29 01:36:55.600	All right, at this moment, I think th basis feature will be enough. Thanks	composer		사용자 메시지 크롬 확장 프로그램 개발 요청 프롬프트
025-07-29 01:37:43.712	One more, Could you please develop chrome extension to embed this code?	composer		사용자 메시지 크롬 확장 프로그램 개발 요청 프롬프트
2025-07-29 01:38:08.762		apply	manifest.json	Cursor의 manifest.json 적용
2025-07-29 01:39:52.805		apply	content.js	Cursor의 content.js 적용
2025-07-29 01:41:27.074		apply	background.js	Cursor의 background.js 적용
2025-07-29 01:43:57.487		apply	popup.html	Cursor의 popup.html 적용
2025-07-29 01:45:50.979		apply	popup.js	Cursor의 popup.json 적용
2025-07-29 01:46:13.117		apply	README.md	Cursor의 README.md 적용
2025-07-29 01:47:30.639		apply	INSTALLATION.md	Cursor의 INSTALLATION.md 적용
2025-07-29 01:48:48.117	Thank you, Could you please create or download a icon for this extension?	composer		사용자 메시지 아이콘 생성 또는 다운로드 요청 프롬프트
2025-07-29 01:50:11.720		apply	create_icons.py	Cursor의 create_icons.py 적용
2025-07-29 02:06:42:800	PS C:\\Users\\dfc2025\\Documents\\GitHub\\allachie> \u001b[93mpython3 \u001b[37m.\\chrome_extension\\icons\\create_icons.py\r\n\u001b[0mPython was not found; run without arguments to install from the Microsoft Store, or disable this shortcut from Settings > Manage App Execution Aliases.			오류로 인해 실행 실패

Table 10 사용자의 행위를 정리한 타임라인

최종적으로 state.vscdb 정보를 바탕으로 Cursor에서 생성 또는 수정된 파일은 다음과 같다.

File Path

C:\Users\dfc2025\Documents\GitHub\allachie\README.md

C:\Users\dfc2025\Documents\GitHub\allachie\requirements.txt

C:\Users\dfc2025\Documents\GitHub\allachie\src\basic_keylogger.py

advanced_keylogger.py

C:\Users\dfc2025\Documents\GitHub\allachie\chrome_extension\manifest.json

C:\Users\dfc2025\Documents\GitHub\allachie\chrome_extension\content.js

C:\Users\dfc2025\Documents\GitHub\allachie\chrome_extension\background.js

C:\Users\dfc2025\Documents\GitHub\allachie\chrome_extension\popup.html

C:\Users\dfc2025\Documents\GitHub\allachie\chrome_extension\popup.js

C:\Users\dfc2025\Documents\GitHub\allachie\chrome_extension\INSTALLATION.md

C:\Users\dfc2025\Documents\GitHub\allachie\chrome_extension\icons\README.md

C:\Users\dfc2025\Documents\GitHub\allachie\chrome_extension\icons\create_icons.py

Table 11 Cursor에서 생성 또는 수정된 파일 목록

advanced_keylogger.py 의 경우 Cursor 데이터베이스의 aiService.generations에서는 존재하지만 history.entries 등에서는 존재하지 않는다. 이 경우 Cursor에서 생성 되었지만 사용자가 지웠을 가능성 또는 Cursor에서 미상의 이유로 생성되지 못했을 경우 두가지가 존재한다.

하지만 NTFS 로그를 확인해보면 advanced_keylogger.py 파일은 생성된 흔적을 확인 할 수 없다. 따라서 Cursor에서 미상의 이유로 생성되지 못했을 것으로 추정할 수 있다.

4. 개발자가 두번째로 사용한 IDE에서 생성한 코드 파일을 복구하시오 (50 points)

두번째로 사용한 IDE는 Windsurf이다. Windsurf의 데이터를 확인하기 위해 아래 경로의 데이터 베이스를 참조하였다.

\Users\dfc2025\AppData\Roaming\Windsurf\User\workspaceStorage\558804eb26cea58c5895507e7784c194\state.vscdb

Table 12 Winsurf의 내부 데이터 저장 경로

해당 데이터베이스의 itemTable 테이블의 key가 history.entries 경우 해당 프롬프트를 통해서 어떤 파일이 생성되었는지 확인 할 수 있다.

Figure 11 itemTable 테이블의 history.entries 일부

[
    {
        "editor": {
            "forceFile": true,
            "options": {
                "override": "default"
            },
            "resource": "file:///c%3A/Users/dfc2025/Documents/GitHub/allachie/example_usage.py"
        }
    },
    {
        "editor": {
            "forceFile": true,
            "options": {
                "override": "default"
            },
            "resource": "file:///c%3A/Users/dfc2025/Documents/GitHub/allachie/requirements.txt"
        }
    },
    {
        "editor": {
            "forceFile": true,
            "options": {
                "override": "default"
            },
            "resource": "file:///c%3A/Users/dfc2025/Documents/GitHub/allachie/port_scanner.py"
        }
    },
    {
        "editor": {
            "forceFile": true,
            "options": {
                "override": "default"
            },
            "resource": "file:///c%3A/Users/dfc2025/.codeium/windsurf/brain/411d5fa3-2192-4df1-8585-13bf6b2fd53c/plan.md"
        }
    },
    {
        "editor": {
            "forceFile": true,
            "options": {
                "override": "default"
            },
            "resource": "file:///c%3A/Users/dfc2025/Documents/GitHub/allachie/PORT_SCANNER_README.md"
        }
    },
    {
        "editor": {
            "forceFile": true,
            "options": {
                "override": "default"
            },
            "resource": "file:///c%3A/Users/dfc2025/Documents/GitHub/allachie/README.md"
        }
    }
]

Table 13 state.vscdb 내 ItemTable의 history.entries 의 내용 일부

즉, plan.md에는 windsurf가 사용할 체크리스트를 가지고 있으며, example_usage.py, requirements.txt, port_scanner.py, PORT_SCANNER_README.md, README.md 파일을 생성 및 수정한 것을 확인할 수 있다.

plan.md 파일은 Windsurf의 LLM 에이전트가 사용자의 프롬프트를 통해서 이전에 수행 내용을 미리 정리 해둔 파일이다.

또한 memento/workbench.editors.files.textFileEditor 에서는 파일의 행 수 정보를 나타내고 있다.

Figure 12 state.vscdb 내 ItemTable의 memento/workbench.editors.files.textFileEditor의 내용 일부

FilePath	LineCount
file:///c%3A/Users/dfc2025/.codeium/windsurf/brain/411d5fa3-2192-4df1-8585-13bf6b2fd53c/plan.md	20
file:///c%3A/Users/dfc2025/Documents/GitHub/allachie/port_scanner.py	140
file:///c%3A/Users/dfc2025/Documents/GitHub/allachie/README.md	114
file:///c%3A/Users/dfc2025/Documents/GitHub/allachie/requirements.txt	9
file:///c%3A/Users/dfc2025/Documents/GitHub/allachie/example_usage.py"	38

Table 14 memento/workbench.editors.files.textFileEditor에서 발견된 LineCount

Windsurf의 경우 아래 경로에 프로젝트 내부 백업 파일을 저장한다. 따라서 생성한 코드 파일을 복구 하기 위해서 다음 두 경로를 참조하였다.

Index	Path
1	\Users\dfc2025\.codeium\windsurf\brain\411d5fa3-2192-4df1-8585-13bf6b2fd53c
2	\Users\dfc2025\.codeium\windsurf\code_tracker\active\allachie_e39fe48b75c418d781052bbd4cfec37e7b8ebaa6

Table 15 삭제된 파일을 복구하기 위해 참조한 경로

각각 경로에 존재하는 파일은 다음과 같다.

1번 경로에서는 다음과 같은 파일을 확인할 수 있다.

FileName	FileSize	MD5
plan.md	794 바이트	90748074D82FAAC94862E7189F0F8799
plan_metadata.pbtxt	78 바이트	90F6839F7C974AB3071EC01B8FA5D6CF

Table 16 표 15의 1번 경로에서 확인된 파일

2번 경로에서는 다음과 같은 파일을 확인할 수 있다.

FileName	FileSize	MD5
23a7f620f90bd83c3795c4f494abc355_PORT_SCANNER_README.md	3,820 바이트	39DC6EE1F10ECB51E4B5F4AA3655A37D
816b3a93dd9003225f12de7b2a166e67_README.md	4,055 바이트	6CC88984CEDE782C911B8681447DFB4A
28945a67fca14a8292ff59fd8e559f77_requirements.txt	414 바이트	2400AF97B3CE664EA4AB2FDBD9257A55
c61863821c3b420d68c73427941a56b1_example_usage.py	1,371 바이트	1D79F7054BC64D8752C490F01AD17B46
fb2e08a8541b0450c9b54bd97377b9a9_port_scanner.py	4,815 바이트	E3A76E8A902EDD215B8CB891C4C46A2A

Table 17 표 15의 2번 경로에서 확인된 파일

각각의 복구된 파일 내용은 다음과 같다.

# Simple Port Scanner

A Python-based port scanner that can scan for open ports on target hosts using multi-threading for improved performance.

## Features

- **Multi-threaded scanning** for faster performance
- **Customizable port ranges** (single port, range, or default 1-1024)
- **Service identification** for common ports
- **Timeout configuration** for connection attempts
- **Command-line interface** with argument parsing
- **Thread pool management** to prevent resource exhaustion

## Files

- `port_scanner.py` - Main port scanner script with CLI
- `example_usage.py` - Example of programmatic usage
- `PORT_SCANNER_README.md` - This documentation file

## Installation

No additional dependencies required - uses only Python standard library modules:
- `socket` - For network connections
- `threading` - For concurrent scanning
- `argparse` - For command-line arguments
- `datetime` - For timestamps

## Usage

### Command Line Interface

```bash
# Basic scan of common ports (1-1024)
python port_scanner.py 127.0.0.1

# Scan specific port range
python port_scanner.py 192.168.1.1 -p 1-100

# Scan single port
python port_scanner.py example.com -p 80

# Custom timeout and thread count
python port_scanner.py 127.0.0.1 -p 1-1000 -t 0.5 --threads 200
```

### Command Line Arguments

- `host` - Target host to scan (required)
- `-p, --ports` - Port range to scan (default: 1-1024)
- Single port: `80`
- Port range: `1-1024`
- Custom range: `80-443`
- `-t, --timeout` - Connection timeout in seconds (default: 1.0)
- `--threads` - Number of concurrent threads (default: 100)

### Programmatic Usage

```python
from port_scanner import PortScanner

# Create scanner instance
scanner = PortScanner("127.0.0.1", timeout=1.0)

# Scan port range
scanner.scan_ports(start_port=1, end_port=1024, threads=100)

# Scan single port
scanner.scan_port(80)

# Check results
print(f"Open ports: {scanner.open_ports}")
```

## Example Output

```
Starting port scan on 127.0.0.1
Scanning ports 1-1024
Started at: 2025-07-28 09:57:56
--------------------------------------------------
Port 22: Open
Port 80: Open
Port 443: Open
--------------------------------------------------

Open ports on 127.0.0.1:
Port 22: SSH
Port 80: HTTP
Port 443: HTTPS

Scan completed at: 2025-07-28 09:58:15
```

## Common Services Detected

The scanner identifies common services for well-known ports:

- Port 21: FTP
- Port 22: SSH
- Port 23: Telnet
- Port 25: SMTP
- Port 53: DNS
- Port 80: HTTP
- Port 443: HTTPS
- Port 3389: RDP
- Port 3306: MySQL
- Port 5432: PostgreSQL
- And more...

## Performance Tips

1. **Adjust thread count**: More threads = faster scanning, but may overwhelm the target
2. **Set appropriate timeout**: Lower timeout = faster scanning, but may miss slow services
3. **Scan specific ranges**: Avoid scanning all 65535 ports unless necessary
4. **Use localhost for testing**: Test on 127.0.0.1 to avoid network delays

## Ethical Usage

This tool is for educational and authorized testing purposes only:
- Only scan systems you own or have explicit permission to test
- Respect network policies and terms of service
- Use responsibly and ethically
- Consider the impact on target systems

## Limitations

- TCP ports only (no UDP scanning)
- Basic service detection (port-based only)
- No stealth scanning techniques
- No OS fingerprinting
- Limited error handling for edge cases

## Security Considerations

- Port scanning may trigger security alerts
- Some firewalls may block or rate-limit scan attempts
- Always obtain proper authorization before scanning
- Be aware of legal implications in your jurisdiction

Table 18 복구된 PORT_SCANNER_README.md 파일

pynput==1.7.6
psutil==5.9.5
cryptography==41.0.7
requests==2.31.0
colorama==0.4.6
Pillow==10.0.1
pywin32==306; sys_platform == "win32"
python-xlib==0.33; sys_platform == "linux"
pyobjc-framework-Cocoa==10.1; sys_platform == "darwin"

Table 19 복구된 requirements.txt 파일

#!/usr/bin/env python3
"""
Example usage of the Port Scanner
This script demonstrates how to use the PortScanner class programmatically.
"""

from port_scanner import PortScanner

def example_scan():
"""Example of how to use the PortScanner class"""

# Example 1: Scan common ports on localhost
print("=== Example 1: Scanning localhost (common ports) ===")
scanner = PortScanner("127.0.0.1", timeout=0.5)
scanner.scan_ports(start_port=20, end_port=100, threads=50)

print("\n" + "="*60 + "\n")

# Example 2: Scan specific ports on a target
print("=== Example 2: Scanning specific ports ===")
target_host = "127.0.0.1" # Change this to your target
scanner2 = PortScanner(target_host, timeout=1.0)

# Scan only web-related ports
web_ports = [80, 443, 8080, 8443, 3000, 5000, 8000]

print(f"Scanning web-related ports on {target_host}: {web_ports}")
for port in web_ports:
scanner2.scan_port(port)

if scanner2.open_ports:
print(f"Open web ports found: {sorted(scanner2.open_ports)}")
else:
print("No open web ports found")

if __name__ == "__main__":
example_scan()

Table 20 복구된 example_usage.py 파일

#!/usr/bin/env python3
"""
Simple Port Scanner Script
A basic port scanner that checks for open ports on a target host.
"""

import socket
import sys
import threading
from datetime import datetime
import argparse

class PortScanner:
def __init__(self, target_host, timeout=1):
self.target_host = target_host
self.timeout = timeout
self.open_ports = []
self.lock = threading.Lock()

def scan_port(self, port):
"""Scan a single port on the target host"""
try:
# Create a socket object
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.settimeout(self.timeout)

# Attempt to connect to the host and port
result = sock.connect_ex((self.target_host, port))

if result == 0:
with self.lock:
self.open_ports.append(port)
print(f"Port {port}: Open")

sock.close()

except socket.gaierror:
# Could not resolve hostname
print(f"Error: Could not resolve hostname {self.target_host}")
sys.exit(1)
except Exception as e:
# Handle other exceptions
pass

def scan_ports(self, start_port=1, end_port=1024, threads=100):
"""Scan a range of ports using threading for faster scanning"""
print(f"\nStarting port scan on {self.target_host}")
print(f"Scanning ports {start_port}-{end_port}")
print(f"Started at: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
print("-" * 50)

# Create and start threads
thread_list = []

for port in range(start_port, end_port + 1):
thread = threading.Thread(target=self.scan_port, args=(port,))
thread_list.append(thread)
thread.start()

# Limit the number of concurrent threads
if len(thread_list) >= threads:
for t in thread_list:
t.join()
thread_list = []

# Wait for remaining threads to complete
for thread in thread_list:
thread.join()

# Display results
print("-" * 50)
if self.open_ports:
print(f"\nOpen ports on {self.target_host}:")
self.open_ports.sort()
for port in self.open_ports:
service = self.get_service_name(port)
print(f"Port {port}: {service}")
else:
print(f"\nNo open ports found on {self.target_host}")

print(f"\nScan completed at: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")

def get_service_name(self, port):
"""Get the common service name for a port"""
common_ports = {
21: "FTP",
22: "SSH",
23: "Telnet",
25: "SMTP",
53: "DNS",
80: "HTTP",
110: "POP3",
143: "IMAP",
443: "HTTPS",
993: "IMAPS",
995: "POP3S",
3389: "RDP",
5432: "PostgreSQL",
3306: "MySQL",
1433: "MSSQL",
6379: "Redis",
27017: "MongoDB"
}
return common_ports.get(port, "Unknown")

def main():
parser = argparse.ArgumentParser(description="Simple Port Scanner")
parser.add_argument("host", help="Target host to scan")
parser.add_argument("-p", "--ports", default="1-1024",
help="Port range to scan (e.g., 1-1024, 80, 80-443)")
parser.add_argument("-t", "--timeout", type=float, default=1.0,
help="Connection timeout in seconds (default: 1.0)")
parser.add_argument("--threads", type=int, default=100,
help="Number of threads to use (default: 100)")

args = parser.parse_args()

# Parse port range
if "-" in args.ports:
start_port, end_port = map(int, args.ports.split("-"))
else:
start_port = end_port = int(args.ports)

# Validate port range
if start_port < 1 or end_port > 65535 or start_port > end_port:
print("Error: Invalid port range. Ports must be between 1-65535")
sys.exit(1)

# Create scanner and start scanning
scanner = PortScanner(args.host, args.timeout)

try:
scanner.scan_ports(start_port, end_port, args.threads)
except KeyboardInterrupt:
print("\n\nScan interrupted by user")
sys.exit(1)

if __name__ == "__main__":
main()

Table 21 복구된 port_scanner.py 파일

2번의 분석에 사용된 데이터를 타임라인으로 시각화 할 수 있는 웹 애플리케이션을 Vibe Coding으로 개발하시오. (80 points)

2번 분석에서 사용된 데이터는 Github Desktop의 사용자의 Appdata\Roaming 데이터이다. 해당 파일을 다음과 같이 Chat GPT 도구에 프롬프트를 전송하였다. (프롬프트의 답변은 하단의 프롬프트 공유 링크를 사용해 확인 할 수 있다.)

아래의 표는 사용한 프롬프트이다.

This file is a compressed C:\Users\[UserName]\Local\Roaming\Github Desktop folder, and its detailed structure is as follows.
abc@code-server:~/workspace/DFC_206/GitHub Desktop$ tree
.
├── $I30
├── blob_storage
│   └── baa2ed1f-c213-49c6-96b3-5bdfc86dad06
├── Cache
│   └── Cache_Data
│       ├── $I30
│       ├── data_0
│       ├── data_1
│       ├── data_2
│       ├── data_3
│       ├── f_000001
│       └── index
├── Code Cache
│   ├── js
│   │   ├── index
│   │   └── index-dir
│   │       └── the-real-index
│   └── wasm
│       ├── index
│       └── index-dir
│           └── the-real-index
├── DawnGraphiteCache
│   ├── data_0
│   ├── data_1
│   ├── data_2
│   ├── data_3
│   └── index
├── DawnWebGPUCache
│   ├── data_0
│   ├── data_1
│   ├── data_2
│   ├── data_3
│   └── index
├── Dictionaries
│   └── ko-3-0.bdic
├── DIPS
├── DIPS-shm
├── DIPS-wal
├── GPUCache
│   ├── data_0
│   ├── data_1
│   ├── data_2
│   ├── data_3
│   └── index
├── IndexedDB
│   └── file__0.indexeddb.leveldb
│       ├── $I30
│       ├── 000003.log
│       ├── CURRENT
│       ├── LOCK
│       ├── LOG
│       └── MANIFEST-000001
├── Local State
├── Local Storage
│   └── leveldb
│       ├── 000003.log
│       ├── CURRENT
│       ├── LOCK
│       ├── LOG
│       └── MANIFEST-000001
├── lockfile
├── logs
│   └── 2025-07-28.desktop.production.log
├── Network
│   ├── $I30
│   ├── Cookies
│   ├── Cookies-journal
│   ├── NetworkDataMigrated
│   ├── Network Persistent State
│   ├── TransportSecurity
│   ├── Trust Tokens
│   └── Trust Tokens-journal
├── Preferences
├── Shared Dictionary
│   ├── cache
│   │   ├── index
│   │   └── index-dir
│   │       └── the-real-index
│   ├── db
│   └── db-journal
├── SharedStorage
├── SharedStorage-wal
└── WebStorage
    ├── QuotaManager
    └── QuotaManager-journal
Through the data, the user's traces should be expressed in a timeline and visually through a web application through Python. First, look at the structure of the compressed file and proceed with the analysis while focusing on logs, etc
If you upload the zip file through Python flask, you need to analyze it and produce a web application that can visually express the timeline, etc

Additionally, Can you find github email?

Then add this feature and update the flask code

Even if you use the zip file I gave you, the total number of events is zero

2025-07-28T17:05:55.920000+00:00 GitHub Desktop Log log:info [ui] Executing getStashEntries: git log -g -z --format=%gD%x00%H%x00%gs%x00%T%x00%P refs/stash -- (took 11.347s) C:\Users\User\Downloads\work\case_20250917_111345\extracted\GitHub Desktop\logs\2025-07-28.desktop.production.log 2025-07-28T17:06:05.972000+00:00 GitHub Desktop Log log:info [ui] Executing getAllTags: git show-ref --tags -d (took 10.033s) C:\Users\User\Downloads\work\case_20250917_111345\extracted\GitHub Desktop\logs\2025-07-28.desktop.production.log 2025-09-17T02:13:45.621748+00:00 Local State JSON file:modified Local State JSON modified C:\Users\User\Downloads\work\case_20250917_111345\extracted\GitHub Desktop\Local State 2025-09-17T02:13:45.621748+00:00 Chromium Local State file:modified Chromium Local State mtime C:\Users\User\Downloads\work\case_20250917_111345\extracted\GitHub Desktop\Local State 2025-09-17T02:13:45.623742+00:00 Preferences JSON file:modified Preferences JSON modified C:\Users\User\Downloads\work\case_20250917_111345\extracted\GitHub Desktop\Preferences 2025-09-17T02:13:45.623742+00:00 Chromium Preferences file:modified Chromium Preferences mtime C:\Users\User\Downloads\work\case_20250917_111345\extracted\GitHub Desktop\Preferences 2025-09-17T02:13:45.736219+00:00 GitHub Account Scan account:noreply_email 2223317873+cyber-chef-2025@users.noreply.github.com IndexedDB\file__0.indexeddb.leveldb\000003.log 2025-09-17T02:13:45.742120+00:00 IndexedDB LevelDB Manifest file:modified IndexedDB LevelDB Manifest mtime C:\Users\User\Downloads\work\case_20250917_111345\extracted\GitHub Desktop\IndexedDB\file__0.indexeddb.leveldb\MANIFEST-000001 2025-09-17T02:13:45.744082+00:00 GitHub Account Scan account:primary_email dfc2025.glen@gmail.com Local Storage\leveldb\000003.log 2025-09-17T02:13:45.748915+00:00 LocalStorage LevelDB Manifest file:modified LocalStorage LevelDB Manifest mtime C:\Users\User\Downloads\work\case_20250917_111345\extracted\GitHub Desktop\Local Storage\leveldb\MANIFEST-000001 2025-09-17T02:13:45.749912+00:00 GitHub Desktop log file:modified GitHub Desktop log mtime C:\Users\User\Downloads\work\case_20250917_111345\extracted\GitHub Desktop\logs\2025-07-28.desktop.production.log 2025-09-17T02:13:45.754394+00:00 Chromium Cookies DB file:modified Chromium Cookies DB mtime C:\Users\User\Downloads\work\case_20250917_111345\extracted\GitHub Desktop\Network\Cookies 2025-09-17T02:13:45.770776+00:00 WebStorage quota:scan Scanned QuotaManager.sqlite C:\Users\User\Downloads\work\case_20250917_111345\extracted\GitHub Desktop\WebStorage\QuotaManager 2025-09-17T02:13:45.770776+00:00 WebStorage QuotaManager file:modified WebStorage QuotaManager mtime C:\Users\User\Downloads\work\case_20250917_111345\extracted\GitHub Desktop\WebStorage\QuotaManager
The e-mail search part seems to be processed because the time has changed to the current date, but would it be difficult to just search in the original file? And you can take out functions such as csv download and json download

GitHub Username is not found, can you find github username in logs?

Since we need to not only focus on this case but also other samples, we should avoid fs_maker focusing on a specific date at the moment

Table 22 사용된 프롬프트 목록

사용한 프롬프트 및 답변은 https://chatgpt.com/share/68ca1dc2-0f48-800a-b158-15b1c441d19a 를 통해 확인 할 수 있다.

시각화를 위해 사용되는 데이터 파일은 AppData\Roaming\Github Desktop 폴더를 압축한 파일이며, 사용 예시는 다음과 같다.

Figure 13 python3를 통해 스크립트를 실행한 결과

Figure 14 http://127.0.0.1:8000 을 접속한 모습

127.0.0.1:8000을 접속하면 Github Desktop 폴더를 압축한 파일을 올릴 수 있는 폼이 있다. 해당 폼에 압축된 Github Desktop 파일을 업로드 하면 분석이 진행횐다.

Figure 15 Github Desktop.zip 파일이 업로드 선택된 사진

Figure 16 python을 통한 Github 사용자 식별 웹 애플리케이션 사진

Figure 17 Timeline에서 확인 할 수 있는 정보

코드는 아래와 같으며, 사용한 데이터셋은 별첨1_Github_Desktop.zip 으로 첨부한다. 코드 또한 별첨2_Github_Timeline.py 로 첨부한다.

import os, zipfile, json, sqlite3, re
from pathlib import Path
from datetime import datetime, timedelta, timezone
try:
    from zoneinfo import ZoneInfo
except Exception:
    ZoneInfo = None
from flask import Flask, request, render_template_string, redirect, url_for

APP_DIR = Path(__file__).parent
UPLOADS = APP_DIR / "uploads"
WORK = APP_DIR / "work"
UPLOADS.mkdir(exist_ok=True)
WORK.mkdir(exist_ok=True)

def get_tz(tz_name: str):
    if ZoneInfo is not None:
        try:
            return ZoneInfo(tz_name)
        except Exception:
            pass
    return timezone.utc

def chrome_webkit_time_to_dt(us: int, tz_name="UTC"):
    try:
        epoch = datetime(1601,1,1,tzinfo=timezone.utc)
        dt = epoch + timedelta(microseconds=int(us))
        return dt.astimezone(get_tz(tz_name))
    except Exception:
        return None

def file_mtime(path: Path, tz_name="UTC"):
    try:
        return datetime.fromtimestamp(path.stat().st_mtime, tz=get_tz(tz_name))
    except Exception:
        return None

def add_event(events, ts, source, category, description, path=None, extra=None):
    if not ts:
        return
    events.append({
        "timestamp": ts.isoformat() if isinstance(ts, datetime) else str(ts),
        "source": source,
        "category": category,
        "description": description,
        "path": str(path) if path else None,
        "extra": extra or {}
    })

# ---------- Parsers for extracted files ----------
def parse_desktop_logs(root: Path, events, tz_name="UTC"):
    log_dir = root / "logs"
    if not log_dir.exists():
        return []
    found = []
    pat1 = re.compile(r"(?P<ts>\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z)\s*-\s*(?P<lvl>\w+):\s*(?P<msg>.*)")
    for p in sorted(log_dir.glob("*.log")):
        found.append(str(p))
        try:
            with p.open("r", encoding="utf-8", errors="ignore") as f:
                for line in f:
                    m = pat1.search(line)
                    if m:
                        ts = datetime.fromisoformat(m.group("ts").replace("Z","+00:00")).astimezone(get_tz(tz_name))
                        lvl = m.group("lvl"); msg = m.group("msg")
                        add_event(events, ts, "GitHub Desktop Log", f"log:{lvl.lower()}", msg, p)
                    else:
                        m2 = re.search(r"\[(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z)\]\s*(.*)", line)
                        if m2:
                            ts = datetime.fromisoformat(m2.group(1).replace("Z","+00:00")).astimezone(get_tz(tz_name))
                            msg = m2.group(2).strip()
                            add_event(events, ts, "GitHub Desktop Log", "log:info", msg, p)
        except Exception as e:
            add_event(events, file_mtime(p, tz_name), "GitHub Desktop Log", "log:error", f"Failed to parse log: {e}", p)
    return found

def parse_cookies(db_path: Path, events, tz_name="UTC"):
    out = {"dotcom_user": None, "count": 0, "domains": []}
    if not db_path.exists():
        return out
    try:
        conn = sqlite3.connect(f"file:{db_path}?mode=ro", uri=True)
        cur = conn.cursor()
        cur.execute("SELECT name FROM sqlite_master WHERE type='table'")
        tables = {r[0].lower() for r in cur.fetchall()}
        table = "cookies" if "cookies" in tables else next(iter(tables)) if tables else None
        if not table:
            conn.close()
            return out
        cur.execute(f"PRAGMA table_info({table})")
        cols = {r[1]: i for i, r in enumerate(cur.fetchall())}
        cur.execute(f"SELECT * FROM {table}")
        rows = cur.fetchall()
        out["count"] = len(rows)
        domains = set()
        for row in rows:
            try:
                host = row[cols.get("host_key")]
                name = row[cols.get("name")]
                path = row[cols.get("path")]
                creation = row[cols.get("creation_utc")]
                last_access = row[cols.get("last_access_utc")]
                expires = row[cols.get("expires_utc")]
                domains.add(host)
                if name == "dotcom_user" and "github.com" in host:
                    if "value" in cols:
                        out["dotcom_user"] = row[cols.get("value")]
                ts_c = chrome_webkit_time_to_dt(creation, tz_name)
                ts_a = chrome_webkit_time_to_dt(last_access, tz_name)
                ts_e = chrome_webkit_time_to_dt(expires, tz_name)
                if ts_c: add_event(events, ts_c, "Chromium Cookies", "cookie:created", f"{name} @ {host}{path}", db_path)
                if ts_a: add_event(events, ts_a, "Chromium Cookies", "cookie:last_access", f"{name} @ {host}{path}", db_path)
                if ts_e and expires != 0: add_event(events, ts_e, "Chromium Cookies", "cookie:expires", f"{name} @ {host}{path}", db_path)
            except Exception:
                continue
        conn.close()
        out["domains"] = sorted(list(domains))[:50]
    except Exception:
        pass
    return out

def parse_json_events(path: Path, source_name: str, events, tz_name="UTC"):
    ts = file_mtime(path, tz_name)
    if ts:
        add_event(events, ts, source_name, "file:modified", f"{source_name} modified", path)
    try:
        data = json.loads(path.read_text(encoding="utf-8", errors="ignore"))
        return {"keys": list(data.keys())[:50]}
    except Exception:
        return {"keys": []}

def parse_quota_manager(db_path: Path, events, tz_name="UTC"):
    info = {"origins": 0}
    if not db_path.exists():
        return info
    try:
        conn = sqlite3.connect(f"file:{db_path}?mode=ro", uri=True)
        cur = conn.cursor()
        cur.execute("SELECT name FROM sqlite_master WHERE type='table'")
        tables = {r[0].lower() for r in cur.fetchall()}
        for t in tables:
            if "origin" in t or "quota" in t or "storage" in t:
                try:
                    cur.execute(f"SELECT * FROM {t} LIMIT 50")
                    rows = cur.fetchall()
                    info["origins"] += len(rows)
                except Exception:
                    continue
        conn.close()
        mt = file_mtime(db_path, tz_name)
        if mt:
            add_event(events, mt, "WebStorage", "quota:scan", "Scanned QuotaManager.sqlite", db_path)
    except Exception:
        pass
    return info

# ---------- Username detection in logs ----------
BAD_OWNERS = set(["login","settings","site","features","about","contact","pricing","topics","apps","marketplace","explore","issues","pulls"])
def username_from_logs(root: Path):
    log_dir = root / "logs"
    if not log_dir.exists():
        return None, {}
    text = ""
    for p in sorted(log_dir.glob("*.log")):
        try:
            text += p.read_text(encoding="utf-8", errors="ignore") + "\n"
        except Exception:
            pass
    m = re.search(r'"login"\s*:\s*"([^"]+)"', text)
    if m:
        return m.group(1), {"method":"json_login"}
    m = re.search(r'\b\d+\+([A-Za-z0-9._-]+)@users\.noreply\.github\.com\b', text)
    if m:
        return m.group(1), {"method":"noreply_email"}
    owners = re.findall(r'github\.com[/:]([A-Za-z0-9._-]+)/[A-Za-z0-9._-]+', text)
    owners = [o for o in owners if o.lower() not in BAD_OWNERS]
    if owners:
        from collections import Counter
        cand, _ = Counter(owners).most_common(1)[0]
        return cand, {"method":"repo_owner"}
    return None, {}

# ---------- Email scan DIRECTLY from ZIP (keeps original file times) ----------
EMAIL_RE = re.compile(rb'([A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,})')
INCLUDE_DIRS_FOR_EMAILS = [
    "logs/",
    "Local Storage/leveldb/",
    "IndexedDB/file__0.indexeddb.leveldb/",
]
def detect_zip_prefix(z):
    for n in z.namelist():
        if n.startswith("GitHub Desktop/"):
            return "GitHub Desktop/"
    return ""

def scan_emails_from_zip(zip_path: Path, tz_name="UTC"):
    results = []
    with zipfile.ZipFile(zip_path, 'r') as z:
        prefix = detect_zip_prefix(z)
        for n in z.namelist():
            if n.endswith("/"):
                continue
            rel = n[len(prefix):] if n.startswith(prefix) else n
            if not any(rel.startswith(d) for d in INCLUDE_DIRS_FOR_EMAILS):
                continue
            try:
                data = z.read(n)
            except Exception:
                continue
            for m in EMAIL_RE.finditer(data):
                email = m.group(1).decode('utf-8', errors='ignore')
                start = max(0, m.start()-60); end = min(len(data), m.end()+60)
                snippet = data[start:end].decode('utf-8', errors='ignore').replace("\n"," ").strip()
                zi = z.getinfo(n)
                naive = datetime(*zi.date_time)
                ts = naive.replace(tzinfo=timezone.utc).astimezone(get_tz(tz_name))
                score = (3 if rel.startswith("logs/") else 0) + (2 if "github" in snippet.lower() else 0) + (1 if ("account" in snippet.lower() or "login" in snippet.lower()) else 0)
                results.append({"email": email, "file": rel, "file_modified": ts.isoformat(), "snippet": snippet, "score": score})
    events = []
    for r in results:
        cat = "account:noreply_email" if "users.noreply.github.com" in r["email"] else "account:primary_email"
        events.append({"timestamp": r["file_modified"], "source": "GitHub Account Scan", "category": cat, "description": r["email"], "path": r["file"], "extra": {"score": r["score"]}})
    from collections import defaultdict
    agg = defaultdict(int)
    for r in results: agg[r["email"]] += 1
    primary = None; noreplies = []
    for em, _ in sorted(agg.items(), key=lambda x: -x[1]):
        if "users.noreply.github.com" in em: noreplies.append(em)
        elif primary is None: primary = em
    return {"hits": results, "events": events, "primary_email": primary, "noreply_emails": sorted(list(set(noreplies)))}

# ---------- FS presence markers DIRECTLY from ZIP (generalized, no hardcoded dates) ----------
def scan_fs_markers_from_zip(zip_path: Path, tz_name="UTC"):
    """Emit presence markers for key artefacts using ZIP entry timestamps. No hardcoded filenames."""
    markers = []
    with zipfile.ZipFile(zip_path, 'r') as z:
        prefix = detect_zip_prefix(z)
        interesting = [
            ("Network/Cookies", "Chromium Cookies DB"),
            ("Preferences", "Chromium Preferences"),
            ("Local State", "Chromium Local State"),
            ("WebStorage/QuotaManager", "WebStorage QuotaManager"),
        ]
        # Any log files
        for n in z.namelist():
            if not n.endswith(".log"):
                continue
            rel = n[len(prefix):] if n.startswith(prefix) else n
            if not rel.startswith("logs/"):
                continue
            zi = z.getinfo(n)
            naive = datetime(*zi.date_time)
            ts = naive.replace(tzinfo=timezone.utc).astimezone(get_tz(tz_name))
            markers.append({"timestamp": ts.isoformat(), "source": "GitHub Desktop Log", "category": "file:present", "description": "log present", "path": rel})
        # Specific important files
        for rel, label in interesting:
            n = prefix + rel if prefix else rel
            try:
                zi = z.getinfo(n)
                naive = datetime(*zi.date_time)
                ts = naive.replace(tzinfo=timezone.utc).astimezone(get_tz(tz_name))
                markers.append({"timestamp": ts.isoformat(), "source": label, "category": "file:present", "description": f"{label} present", "path": rel})
            except KeyError:
                pass
        # MANIFESTs
        for n in z.namelist():
            if n.endswith("/"):
                continue
            rel = n[len(prefix):] if n.startswith(prefix) else n
            if "MANIFEST" in rel and ("leveldb" in rel.lower() or "IndexedDB" in rel):
                zi = z.getinfo(n)
                naive = datetime(*zi.date_time)
                ts = naive.replace(tzinfo=timezone.utc).astimezone(get_tz(tz_name))
                markers.append({"timestamp": ts.isoformat(), "source": "LevelDB Manifest", "category": "file:present", "description": "LevelDB manifest present", "path": rel})
    return markers

# ---------- Core analysis ----------
def analyze_zip(zip_path: Path, tz_name="UTC"):
    work_dir = WORK / f"case_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
    extract_dir = work_dir / "extracted"
    extract_dir.mkdir(parents=True, exist_ok=True)

    with zipfile.ZipFile(zip_path, 'r') as z:
        z.extractall(extract_dir)

    root = extract_dir
    if (extract_dir / "GitHub Desktop").exists():
        root = extract_dir / "GitHub Desktop"

    events = []
    parse_desktop_logs(root, events, tz_name=tz_name)
    ck = parse_cookies(root / "Network" / "Cookies", events, tz_name=tz_name)
    parse_json_events(root / "Preferences", "Preferences JSON", events, tz_name=tz_name)
    parse_json_events(root / "Local State", "Local State JSON", events, tz_name=tz_name)
    parse_quota_manager(root / "WebStorage" / "QuotaManager", events, tz_name=tz_name)

    # Username from logs
    gh_user, user_meta = username_from_logs(root)

    # Email + generalized FS markers from ZIP
    email_info = scan_emails_from_zip(zip_path, tz_name=tz_name)
    fs_markers = scan_fs_markers_from_zip(zip_path, tz_name=tz_name)
    events.extend(email_info["events"])
    events.extend(fs_markers)

    # sort + summarize
    events = [e for e in events if e.get("timestamp")]
    events.sort(key=lambda e: e["timestamp"])
    from collections import Counter
    counts = dict(Counter(e["source"] for e in events))

    username = gh_user or (ck.get("dotcom_user") if isinstance(ck, dict) else None)

    summary = {
        "events": len(events),
        "github_username": username,
        "github_username_source": "logs" if gh_user else ("cookie" if username else None),
        "cookie_domains": ck.get("domains", []) if isinstance(ck, dict) else [],
        "counts": counts,
        "primary_email": email_info.get("primary_email"),
        "noreply_emails": email_info.get("noreply_emails", []),
        "tz": tz_name,
    }

    return root, events, summary, work_dir

# ---------- UI ----------
HTML = """
<!doctype html>
<html>
<head>
<meta charset="utf-8">
<title>GitHub Desktop Forensic Timeline</title>
<meta name="viewport" content="width=device-width, initial-scale=1" />
<style>
    body { font-family: system-ui, -apple-system, Segoe UI, Roboto, sans-serif; margin: 24px; }
    h1 { margin-bottom: 0; }
    .meta { color: #666; margin: 4px 0 16px; }
    .container { max-width: 1200px; margin: auto; }
    .upload { border: 2px dashed #cbd5e1; border-radius: 12px; padding: 16px; margin: 16px 0; }
    .cards { display:grid; grid-template-columns: repeat(auto-fit,minmax(220px,1fr)); gap: 12px; margin: 12px 0 24px; }
    .card { border: 1px solid #eee; border-radius: 12px; padding: 12px; box-shadow: 0 1px 4px rgba(0,0,0,.04); }
    .muted { color:#666; font-size: 12px; }
    .tag { display:inline-block; background:#f1f5f9; padding:2px 8px; border-radius:999px; font-size: 12px; margin-right:4px; }
    table { width: 100%; border-collapse: collapse; }
    th, td { padding: 8px; border-bottom: 1px solid #eee; font-size: 14px; }
    th { background: #fafafa; position: sticky; top: 0; }
    .path { color:#555; font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; font-size: 12px; }
    .footer { margin-top: 32px; color:#777; font-size: 12px; }
    .btn { display:inline-block; padding:8px 12px; background:#111827; color:#fff; border-radius:10px; text-decoration:none; }
    .row { margin: 8px 0; }
    .pill { background:#eef; padding:2px 6px; border-radius:8px; }
    .subtle { color:#334155; }
    .tz { font-size: 12px; color:#475569; }
</style>

</head>
<body>
<div class="container">
    <h1>GitHub Desktop Forensic Timeline</h1>
    <div class="meta">Upload a ZIP of C:\\Users\\<User>\\AppData\\Roaming\\GitHub Desktop → visual timeline + username/email discovery.</div>
    <div class="upload">
      <form method="POST" enctype="multipart/form-data">
        <div class="row"><strong>Upload profile ZIP</strong></div>
        <div class="row"><input type="file" name="zipfile" required /></div>
        <div class="row">Timezone:
          <select name="tz">
            <option value="Asia/Seoul">Asia/Seoul</option>
            <option value="UTC">UTC</option>
            <option value="America/Los_Angeles">America/Los_Angeles</option>
            <option value="Europe/London">Europe/London</option>
          </select>
          <button class="btn" style="margin-left:8px;">Analyze</button>
        </div>
      </form>
    </div>

    {% if summary %}
      <div class="tz">Using timezone: {{ summary.tz }}</div>
      <div class="cards">
        <div class="card">
          <div><strong>Total Events</strong></div>
          <div style="font-size:28px;">{{ summary.events }}</div>
          <div class="muted">timeline rows</div>
        </div>
        <div class="card">
          <div><strong>GitHub Username</strong></div>
          <div style="font-size:20px;">{{ summary.github_username or "<span class='muted'>not found</span>" | safe }}</div>
          <div class="muted">source: {{ summary.github_username_source or "n/a" }}</div>
        </div>
        <div class="card">
          <div><strong>Primary Email</strong></div>
          <div class="subtle" style="font-size:16px;">{{ summary.primary_email or "<span class='muted'>not found</span>" | safe }}</div>
          <div class="muted">detected from ZIP contents (original file timestamps)</div>
        </div>
        <div class="card">
          <div><strong>Noreply Emails</strong></div>
          <div>{% if summary.noreply_emails %}{% for d in summary.noreply_emails[:4] %}<span class="pill">{{ d }}</span> {% endfor %}{% else %}<span class="muted">none</span>{% endif %}</div>
        </div>
        <div class="card">
          <div><strong>Sources</strong></div>
          <div>{% for k,v in summary.counts.items() %}<span class="tag">{{k}}: {{v}}</span>{% endfor %}</div>
        </div>
      </div>

      <canvas id="eventsPerDay" height="100"></canvas>

      <h2>Timeline</h2>
      <table>
        <thead><tr><th>Timestamp ({{ summary.tz }})</th><th>Source</th><th>Category</th><th>Description</th><th>Path</th></tr></thead>
        <tbody>
          {% for e in events %}
            <tr>
              <td>{{ e.timestamp }}</td>
              <td>{{ e.source }}</td>
              <td>{{ e.category }}</td>
              <td>{{ e.description }}</td>
              <td class="path">{{ e.path }}</td>
            </tr>
          {% endfor %}
        </tbody>
      </table>
    {% endif %}

    <div class="footer">FS markers are generalized and use ZIP entry times (no hardcoded dates, better across samples).</div>
</div>

{% if events %}
<script>
    const events = {{ events|tojson }};
    const counts = {};
    for (const e of events) {
      const d = e.timestamp.slice(0,10);
      counts[d] = (counts[d] || 0) + 1;
    }
    const labels = Object.keys(counts).sort();
    const data = labels.map(k => counts[k]);
    new Chart(document.getElementById('eventsPerDay').getContext('2d'), {
      type: 'bar',
      data: { labels, datasets: [{ label: 'Events per day', data }] },
      options: { responsive: true, scales: { x: { ticks: { autoSkip: true, maxRotation: 0 }}}}
    });
</script>
{% endif %}
</body>
</html>
"""

app = Flask(__name__)

@app.route("/", methods=["GET","POST"])
def index():
    if request.method == "POST":
        f = request.files.get("zipfile")
        tz = request.form.get("tz", "UTC")
        if not f:
            return "No file", 400
        save_path = UPLOADS / f.filename
        f.save(save_path)
        return redirect(url_for("case", filename=f.filename, tz=tz))
    return render_template_string(HTML, summary=None, events=None)

@app.route("/case/<filename>")
def case(filename):
    tz = request.args.get("tz", "UTC")
    zip_path = UPLOADS / filename
    if not zip_path.exists():
        return "Not found", 404
    root, events, summary, _ = analyze_zip(zip_path, tz_name=tz)
    return render_template_string(HTML, summary=type("Obj",(object,),summary), events=events)

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8000, debug=False)

Table 23 바이브 코딩을 통한 타임라인 분석 소스코드

[2025 DFC] 2025 디지털포렌식 챌린지 - 203 - Ooops, your files have ben encrypted!

pental — Mon, 20 Apr 2026 20:58:15 +0900

Step-by-step methodology:

문제를 풀기에 앞서 대회측에서 제공한 파일의 해시값과 다운로드 받은 해시값이 일치하는지 확인한다.

그림 1 대회에서 주어진 파일 정보

그림 2 HashTab을 이용한 해시 확인

파일의 해시값과 다운로드 받은 파일의 해시값이 A530D2ABDEBF60EE0D81B7DC6ED92C7A으로 동일함을 확인하였다.

반디집 프로그램을 통해 PD12M_dataset.zip.enc 파일을 열어보면 다음과 같은 오류를 확인 할 수 있다.

그림 3 반디집을 통해 PD12M_dataset.zip.enc 파일 열기

오류에서 확인되는 내용은 “이 파일은 손상된 파일입니다.” 이며, 확인 버튼을 클릭하면 일부 파일이 식별된다.

그림 4 그림 3에서 확인 버튼 클릭 후 보여지는 화면

추출할 수 있는 데이터는 다음과 같다.

FileName

012.jpg

013.jpg

014.jpg

015.jpg

016.jpg

017.jpg

018.jpg

019.jpg

020.jpg

표 1 반디집을 통해 PD12M_dataset.zip.enc 에서 추출된 파일

그림 5 그림 4에서 확인된 파일 추출 모습

하지만 추출된 020.jpg 파일에서 확인 할 수 있듯, 제대로 추출되지 않음을 육안으로 확인 할 수 있다. 따라서 손상된 zip 아카이브를 복구 하기 위해 zip도구를 사용한다.

zip도구의 강력모드인 -FF 인자를 통해 복구된 결과를 temp.zip으로 출력하는 명령은 다음과 같다.

zip -FF PD12M_dataset.zip.enc --out temp.zip

그림 6 zip 명령어를 사용한 강제 복구 과정 및 결과

실행 결과는 위 사진과 같으며 temp.zip에서 확인되며 추출할 수 있는 데이터는 다음과 같다.

그림 7 temp.zip 에서 발견된 46개의 데이터

총 46개의 데이터를 확인할 수 있으며, 그중 085번의 파일은 docx파일로 확인되었다. 해당 docx파일에서는 100 – A Key Too Familiar 이라는 문제를 추가적으로 확인 할 수 있다.

203번의 문제를 풀기 위해서는 100번 문제를 필수적으로 풀어야 하기에, 해당 문제 풀이를 먼저 진행한다. 100번 문제에서 확인 할 수 있는 내용은 다음과 같다.

Instructions

Description 당신은 컴퓨터에 존재하는 랜섬웨어 프로그램을 역공학 하였습니다. 결과, 암호화에 사용된 키는 찾아낼 수 없었지만, 랜섬웨어에 취약점이 있음을 확인하였습니다. 암호화된 파일들을 분석하여 FLAG를 찾아내시기 바랍니다.

Hint.

- 랜섬웨어는 스트림 암호를 사용하였습니다.

- FLAG는 바탕화면에 존재하는 FILE_H에 저장되어 있습니다.

- FILE_A ~ FILE_H는 ASCII 문자열로만 구성되어 있습니다.

- FLAG는 FILE_A ~ FILE_H 만으로도 획득 가능합니다.

Target	Hash (MD5)
Disk image (.img)	D330AF1D7D67349334F96B902652945D
Download url: https://www.dropbox.com/scl/fi/9u0jepu2z80mkvgdlg4ub/diskdump.img?rlkey=6x8mfdw557vkd29nmf3deqmpv&st=i9kf1zjy&dl=0

Credits

1) FLAG를 획득함 (100 points)

다운로드 URL을 통해 받은 diskdump.img 파일과 문제에서 주어진 MD5의 해시값이 동일한지 확인한다.

그림 8 HashTab을 이용한 diskdump.img 파일 해시 정보

다운로드 받은 파일이 주어진 해시값 D330AF1D7D67349334F96B902652945D과 동일함을 확인하였다. 해당 img 파일을 FTK Imager에 탑재해 분석을 진행한다.

그림 9 FTK Imager을 사용하여 diskdump.img 인식 모습

FTK Imager을 통해서 [NTFS]/[root]/Users/DFC/Desktop 폴더에서 FILE_A ~ H.txt 파일 총 8개를 확인 할 수 있다. 또한 [NTFS]/[root]/Users/DFC/Downloads 폴더에서 각 프로그램 설치파일 또한 enc 확장자를 가진체 암호화 된 모습을 확인 할 수 있다.

그림 10 Downloads 폴더에서 확인된 암호화된 파일들

분석을 위해서 Everything-1.4.1.1005.x64-Setup.exe, python-3.13.3-amd64.exe, node-v22.16.0-x64.msi 파일을 공식 홈페이지를 통해서 다운로드 했다. 아래는 각 다운로드 버전 및 링크이다.

FileName	Version	URL
Everything	1.4.1.1005.x64	https://www.voidtools.com/ko-kr/support/everything/previous_versions/
python	3.13.3-amd64	https://www.python.org/downloads/release/python-3133/
node	v22.16.0	https://nodejs.org/en/blog/release/v22.16.0/

표 2 분석을 위해 사용된 설치 파일 정보

이 케이스에서는 랜섬웨어가 스트림 암호를 사용했다는 것이 주어졌고, 동일한 키스트림을 여러 파일에 재 사용했다고 전재하고 시작한다. 따라서 각 암호화된 파일과 원본에 대해서 XOR 연산결과를 비교하여 키스트림 추출을 진행한다.

encrypted_file = "python-3.13.3-amd64.exe.enc"
original_file = "python-3.13.3-amd64.exe"
keystream_output = "python-keystream"
with open(encrypted_file, "rb") as enc_fp, open(original_file, "rb") as orig_fp:
enc_data = enc_fp.read()
orig_data = orig_fp.read()
if len(enc_data) != len(orig_data):
print(f"[!] Warning: File sizes are off ({len(enc_data)} vs {len(orig_data)}), will chop to the shorter one.")
length = min(len(enc_data), len(orig_data))
keystream = []
for i in range(length):
keystream.append(enc_data[i] ^ orig_data[i])
xor_result = bytes(keystream)
with open(keystream_output, "wb") as out_fp:
out_fp.write(xor_result)

print(f"[+] XOR complete. Output written to '{keystream_output}' ({len(xor_result)} bytes).")

표 3 XOR 연산을 통한 키스트림 추출 코드

위 코드를 수행한 결과 python-keystream 파일이 생성되었으며 아래는 해당 파일의 해시 값 및 정보이다.

그림 11 추출된 keystream의 해시값 정보

FileName	python-keystream
FileSize	28,640,016 바이트
MD5	232D6D772CBFFA2A512BCB0C90062165
SHA-1	A17A73FAE191A54651C9DABEB4F1A89EB21CAB55

표 4 keystream의 정보

추출된 키스트림을 바탕으로 바탕화면에 존재하는 FILE_A ~ H.txt 파일 복호화를 진행한다. 다음은 복호화에 사용한 코드이다.

import pathlib
keystream_path = "python-keystream"
encrypted_files = [
"FILE_A.txt.enc",
"FILE_B.txt.enc",
"FILE_C.txt.enc",
"FILE_D.txt.enc",
"FILE_E.txt.enc",
"FILE_F.txt.enc",
"FILE_G.txt.enc",
"FILE_H.txt.enc"
]
output_path = "TEMP.txt"
try:
ks_bytes = pathlib.Path(keystream_path).read_bytes()
except Exception as e:
print(f"Error: Couldn't read keystream file – {e}")
exit(1)
with open(output_path, "wb") as out_file:
for enc_filename in encrypted_files:
try:
encrypted_data = pathlib.Path(enc_filename).read_bytes()
except FileNotFoundError:
print(f"(!) Skipping missing file: {enc_filename}")
continue
except Exception as e:
print(f"(!) Error reading {enc_filename}: {e}")
continue
usable_len = min(len(encrypted_data), len(ks_bytes))
decrypted = []
for i in range(usable_len):
decrypted.append(encrypted_data[i] ^ ks_bytes[i])

out_file.write(bytes(decrypted))
print(f"Decryption done. Combined output written to '{output_path}'")

표 5 FILE_A ~ H.txt 파일 복호화를 위해 사용된 코드

해당 코드를 실행한 결과 temp.txt 파일이 생성되었으며 아래는 텍스트 파일에서 발견된 내용이다.

그림 12 temp.txt 에서 확인 된 평문 메시지

Cryptographic algorithms must be used in strict compliance with the recommended requirements.In particular, take care with stream cipher to avoid vulnerabilities such as the many-time pad attack.OTP security dies once pads repeat; treat every pad as a single‑use consumable block of data.
Reusing keystreams can lead to plaintext leaks. Update the key or change the mode before reusing.XORing two reused ciphertexts yields P1^P2; The guessed ciphertext can lead to a recovery.Reused pads turn pairs of ciphertexts into clues. With just one good ciphertext, you can decrypt the rest.By the way, one of the encrypted compressed files that should be on this computer is missing. Where is it?Flag: T29vcHMsIGZsYWch

표 6 temp.txt 파일의 평문

Flag는 T29vcHMsIGZsYWch 으로 적혀있으며 base64를 통해 인코딩 된 것을 확인하였다. base64decode.org 를 통해 온라인 base64 디코딩을 진행한다.

그림 13 base64decode.org를 이용한 복호화

답 : Ooops, flag!

다시 203번 문제로 돌아와 zip파일 암호화에 사용됬을걸로 추정되는 스트림분석을 진행하였다.

그림 14 keystream 분석 과정 좌 node, 우 python

그림 15 27BA74 이후 두 키스트림의 차이

오프셋 27BA74부분까지 node 키스트림과 python 키스트림이 동일한 것을 확인하였다. 하지만 python에서는 27BA74 이후 부분이 00으로 되어 있고, node 부분에는 데이터가 있는 것을 확인하였다. 이 분석을 통해서 키스트림과 널바이트의 상관 관계 분석을 진행하였으며, 그 결과 python-keystream에서는 0x27BA74부분의 2배인 0x4F74E8 부분에 동일하게 키스트림이 있는 것을 확인하였다.

그림 16 오프셋 27BA74에서 확인된 동일한 키스트림

위에서 확인했던 46개의 데이터에서 숫자 연속성이 깨지는 부분을 확인하였으며, 001.jpg ~ 011.jpg, 021.jpg ~ 028.jpg, 038.jpg ~ 046.jpg, 057.jpg ~ 062.jpg, 071.jpg ~ 081.jpg, 092.jpg ~ 100.jpg 가 누락된 것을 확인 할 수 있다. 따라서 주어진 enc 파일에 020.jpg 뒷 부분을 확인한다.

그림 17 020.jpg 를 검색한 모습

020.jpg 다음으로 발견되는 jpg 문자열은 029.jpg이다. 따라서 020.jpg 내용부터 029.jpg가 발견된 부분을 따로 저장해 분석을 진행했다. (0x1DF40F ~ 0x2DE60D)

복호화에 사용한 키스트림의 길이와 시작 위치를 찾기 위해 키스트림 파일(key)을 이용한 XOR 브루트포스 복호화 실험을 수행하였다. 우선 key 파일의 앞부분을 이용해 암호화된 ZIP 파일 전체를 XOR으로 복호화해 보았고, 복호화가 정상적으로 진행되는 시작 지점이 0x1DF40F에서 1079바이트 떨어진 위치임을 확인하였다. 이를 통해 총 키 길이가 0x1DF40F + 1079 = 1,964,102바이트로 추정되었다.

키스트림이 순환 특성을 가지므로 실제 암호화의 시작점이 위에서 구한 길이보다 얼마만큼 더 떨어져 있을 수 있음을 고려해야 했다. 특히 시작 위치가 4096바이트 단위로 어긋날 가능성이 있어, 스크립트를 일반화하고 브루트포스 방식으로 여러 후보 길이를 시도하도록 확장하였다. 키 길이를 늘려가며 각 경우에 대해 복호화 파일을 생성하였다. 그 결과 생성된 ZIP들 가운데 1개 파일이 정상적으로 압축해제 되었고 100장의 이미지 파일을 복구할 수 있었다. 사용한 코드는 다음과 같다.

def _xor_bytes(data, key):
if not key:
raise ValueError("키가 비어있습니다: 'python-keystream' 파일을 확인하세요")
out = bytearray(len(data))
klen = len(key)
for idx in range(len(data)):
out[idx] = data[idx] ^ key[idx % klen]
return bytes(out)

with open('python-keystream', 'rb') as kf:
keystream = kf.read()
with open('PD12M_dataset.zip.enc', 'rb') as ef:
encrypted = ef.read()

for i in range(0, 100) :
part_len = 982051 + 2048 * i
prefix = keystream[:part_len]
pad_unit = b'\x00'
zeros = pad_unit * part_len
predict_key = prefix + zeros

decrypted = _xor_bytes(encrypted, predict_key)
out_name = f'decrypted_{i}.zip'
with open(out_name, 'wb') as out_f:
out_f.write(decrypted)

표 7 복구에 사용된 코드

그림 18 코드 실행 후 100개의 파일이 모두 복구된 모습

그림 19 추출된 100개의 파일

복구 된 파일은 총 100개 이며 각 파일 이름 및 해시값은 다음과 같다.

FileName	SHA256
000.jpg	e55d9e636ce8197ecad3c52b1073de098e28cd9a02c035a1f5ada5c186c3e086
001.jpg	54272c394e867833f17099d1fd2462c9562ff33397eda9795a9a2280808b2915
002.jpg	432e775467541125a8923bad3646a51688ccc7af08562ff5670faba1490ab71f
003.jpg	bad50ba579e971f73942f90a9c014bc52fef02c56155fdc600c6f262a7cd75c4
004.jpg	7602d9134fb58ac8433081e3161de088ba54da857056c31c04b20a9a924629bf
005.jpg	f4136cefc4c29775390075e25eece8fd2a62dccd466969d9f0dcc02d5e11e8df
006.jpg	8488fcfe4dc24d5ffe0d1dcb42dc8662b04978cf55c540c98991177f164fcd64
007.jpg	420da57b90142851499968f85dc99616b103febbb60ace31cab72b64d9076700
008.jpg	e2a648f9729b029f3f53329409aca962d98f7763d8110f93d8ffdd882a402233
009.jpg	41891d418c99586c508cf3947426761933f200e37c68ef4776816b8fe0c6e2b4
010.jpg	73b060e408f0bf8c2133d6b5bb4fefb191ccfcd108f28e90b98331797c743016
011.jpg	93e76032b7a0f0db464b5e004859f09576485e5370fdab102b7305d63638354a
012.jpg	65c682f04647569debbc5f321d43a18c10617ea180e7db6cf45e23c0f1090e7a
013.jpg	75116d1266299dd256eb9e00dffeae90054c725c9b7b4718d9903f9537675711
014.jpg	a1e51ea589d0d69757065365b845fe550a1848c962dccd4f8b81d1f0ddef1155
015.jpg	25121a3273ee88f0df1337d35aad7f3b7f10b84edfa1814b298eed43f88bd11a
016.jpg	12ed595337cef2251e9fc6ac12d592264847ffbc9e07e788988b8bf54ee5db38
017.jpg	9517cfe1e757e16eff5e3259ef8ee83fd98a40af9b954e807894382bac3fc9c0
018.jpg	d378aa5496e30b4f2f498966e5f7c608c3b86bd1c0f1d748ea1c487db8dac335
019.jpg	677ec871700acd0e0ce6b0e1f3068109438f88ce3d0cd39b895ae53c000c9042
020.jpg	283f9dba470570467c661b18dbba9cf1007d7342334e8187437ff9ea7fe2429a
021.jpg	54b63d61782c384e4bed74b7b0e984f4d7ac6e954f649f8542450cd074060366
022.jpg	32f8e76a8973c98b1400634c84917c5d6ef1468dfbbd44f271823e3cca708f42
023.jpg	bc2396495058e8b02717a58be4fad9d1c14ddcf4319e611093d30b5736851083
024.jpg	a123d84525160846f58bb2551e6a01091c871f10e835f9bb65299734bbbcabec
025.jpg	70a0678489b8dc88b63803110ec8d1b8b34888607da479b5d7b102bb6725a759
026.jpg	5ef67a9a3b0f7c1f404f82f17365fe1991f44a94d85f84eeee651c252bae4575
027.jpg	e553fbb2d611ec2fc617c5b5e4f4e08e5b8094b55ac594191b6e1e4c4eea4d13
028.jpg	7cd5ca48fca223a182bc10e0730247e85e4694e21f19444382c23f6df90912c3
029.jpg	119bf2d66f4226b8309dfc1e3763de5061bea8bec3379f76a17a12380db0fc7e
030.jpg	3e2863569378a3c1ad574352e5c040ace6146956f1fd70f7b03c52f292bce673
031.jpg	8db8a962144e815483844703ac04e5668b994289a631f4a47ac436b9d2bc5a20
032.jpg	1a29041185e7ceaa3684f91edcfead59a17b9b392e0aa21c97a340e4e01abb8e
033.jpg	54402ef3e746e4fafe11b8e62851f37901e3186277f75227d346d8007f2f9fe6
034.jpg	952a3b521a166c9a0298ecd6b4b6c984e64dd230cc2780d3b7eb0e74207e9956
035.jpg	e4fa96b54edd334969c1befabc50642caf4ea317f34b4c6137353b58a20c3a7f
036.jpg	95a1dc9c7b613f7692d12cb9af04b9148fdafe122cea4b4bce72cf582c96e43c
037.jpg	8a121ea8fe8a812f70e25d39eac401e4e76d6dd7097a3be33b23b8d1de47008e
038.jpg	51e688aa7eba6be0fec1986f23b3a621ac8186c2d26bbe9955e58063713d5599
039.jpg	f63c4e097b374e37256e5343a5d6c7258fd0403ce3e7e635baa6f949c4be37cc
040.jpg	f8fe607f1299b595fc6284fa9f806b1214ff4fab6eae45f07a162d884dbdf378
041.jpg	ad29d72b517e64d96553ade02aa3d9a315f539c84bed72c904a70398754a2f67
042.jpg	1941f33daa2ed8ed046d449bf1e30bfa7b0b89bc55f4561d667c2147997df53d
043.jpg	4f2e8ccafa0b37ee96729e4510f32d9f945dc5fdf46059f90d96cdb233883fe5
044.jpg	cfade6a2cf26ea6b398605510d1365d17968439d70f4eede484e4a74a0dfd083
045.jpg	743e154ee31a780647770869fe1e81985430a403bf3d876932a34d309524970d
046.jpg	5d2d7a738f6f7f2434e412ae13ff698e7e630f128db597ec7af219616d3a41ff
047.jpg	4ae608c262f4a3690f76b6a4c43ce670b2a156be00dce90d1430fbadc21b1d68
048.jpg	575ef9765c2545e85391e608fdf9cd0f514f92bad34e6f8eb52ad4a6e3877750
049.jpg	f5bc9f8cc2ed62e53dcb29c3cd8085c4015d2fbd59551dafd6ff0ef35b9efe9b
050.jpg	f8a57d0643609ff2b7dd29a1a6b1a04a866540422d5d2113c717968147da157e
051.jpg	9c47048b9f4cb927639a50b5ccec067f77b44eef7097cf827d6dd537066a4bd7
052.jpg	e38209e2ad3df0b5c36b8cbf408d7063cca58c8e256686452535829d38aedf28
053.jpg	ddaea6d062b8d2b5cf2c5a8971d6a5e90670c7b3181478b348f17feab8c0ac50
054.jpg	b2a813f44fda174f4dc553b9dea1f0349f526e3cde54ce0b09f7c30ad61349ef
055.jpg	43a721782cf0aa8153dd1208d96df75913b7cc1c4fa36e7c26160d7b1a3892bb
056.jpg	4096de8557452cd4340a39f490d83d73db063379a1faa0c3aca56c676c3c358e
057.jpg	6b2173ac8b74273df65bc6198ed78fe0ffa974a512ffe2a2ca219ccedc0fccd1
058.jpg	c0ec02162ead5297f463abcdc21d10f391f3e3f53f0520253407cd6f37fb0008
059.jpg	f4881a1ddd87ae81366f9b67548fc62f9f27617d2c1b7599c7ec2cf164cf8976
060.jpg	69a1f40718d35c4c5cd3394b6063e2c9f0160d3610210d4ee9d222f3fa12f393
061.jpg	63919b22fdff3796c193bf7c22e8ef5f230088a62b3053fee5b865ebe0331a6d
062.jpg	6f408488ab51d95d4b88ee3c3f950e4d30e096b7a8ee30b04e46e5719eafbaee
063.jpg	f223e40609779931c233d3e520281083427d8dd21c767a837f283f9b354d9b2b
064.jpg	34c60e55adc557b77bda9a6bad312de6aa6d0cb5d9fd0ddecf83be2eaa82edf8
065.jpg	6f70487ffb30962d737d3580ffcdeb0e980c93af9e015fa79d7f799f593967fb
066.jpg	5e3fdc8a1c6348d990bcc164d0513d504d20d29374e3f2cff28b68eb18b02c57
067.jpg	e16e05553c6f69260b463a16077a6601071bbde3ec9bdceae72f1066d25c871f
068.jpg	9dc9d7d8476883476e517cfbcb9a3b56fc793d464403cb222f72696ab4034791
069.jpg	dd5cae541faaaa5e51e649699838278e2374f4b496169756236a3c67b3b2d1e2
070.jpg	ad7ffba7bae55a0772b4fdf74f960c687170a9c381c3781d7a332ab72340a873
071.jpg	b879856dc38bf5a0de6955ffc872811254f81783f47bf78449f771c598ce4066
072.jpg	17ba314bf7b7d5537edd42f1c5d93c2a25f3ba7af65487aa1bfbf9ca1b030ca0
073.jpg	f0f3e4f2f2bc57a49d4d761ac603d4a079fac7702396dcb0ee3cb1c7fd1d893d
074.jpg	ec915beb9e12f32d467298388ba678d933ba539cf92e104aaa2b281a5b3fe083
075.jpg	b1069fee3cdc995f2f93447501af29cdc8bbb8c8ee690f66757f6ab3415c89d6
076.jpg	6e3baf882e5d310cdb59d95de5fd71baf6345b68c99d4eb2a205fea5f4759407
077.jpg	f5eecbd13cd597ee214ab788ccf9574f6d4ecb7d0da845678b0cf4605f8abebe
078.jpg	2341b398277d2211453e6a8a4df61a6480a1643c5bee639bee3dbcedfca754cf
079.jpg	7188c9059aabedcbd01770ba34184fd7ed3d7f02c5d6cadb29fd441b7c932602
080.jpg	49ad230c6c11ac9124768566f6b3cb57350a2648609251ddaebe5a5793eee2af
081.jpg	9fb35e59bed3ada2069b707047a30c77d2fc4b5c5ccc0fc6aa15846564dcc8fa
082.jpg	2383505b28b2b5e01d2457d646e50aa06843880607c54c957c2e5fe6d28b158f
083.jpg	e0c55fbca33757cdde58c28a073e2ec6d8d18fb89f522c9a0e344b3c1939149d
084.jpg	7c705703060c68b8af61dadcadaf497ef90541681711af66d2e41c6976516f8c
085 - A Key Too Familiar(ko,en).docx	70bf4cf76692accca06779b384d2281b3d96a9386ac593d75b3d7da55fac9a22
086.jpg	15d43227afc5cdbba30e36cd68c521d8132859d09a1e4c6963e61fe4f07a7f8b
087.jpg	26c866c5e9bdeaf211d52dbca62113bd167f5ef6f3226e0604639e8a35d1e6c3
088.jpg	1a3ffe670cbe0603b53e2be18349578807495b0c4e92abea2f7c0f06e8df5b4c
089.jpg	76caa577d7f8a72bc16121f94ae9d8639353e354f52d5ade6de5114117cb1f38
090.jpg	c9dcd8d000bab94e0e4694d1fae8d52c09e91a55778dd6f28ae3f0b04ebf3c44
091.jpg	ad8e0b8ee16970db43d683d82f5463eab8ae3dad260f8f51a924c71291821ac8
092.jpg	cf2e5b962894e317a139d8fcc66fcbcceec0c8e8d62c9627cb402f28e86f35c6
093.jpg	66e787c1d66cab51602ed86b3efe9b445105b1f624627f5203a46c8aff9b12b8
094.jpg	04b4b5b135e1da4848697bb7baef7cd8332a3b3d3e0ed716fa24ac7721a23046
095.jpg	e66a9a404bb8980e4bd498b8533bb6cdce4bf9a260e9692f07e5aad4414843ea
096.jpg	2d228defbfafa7ba082be19dd25a51196d5136acde510fcc997b4523e96a6afe
097.jpg	0d1a2f1354b0a13ef2f6c66b2b7465f749d18aa24b64d8870788e60a078b30ab
098.jpg	848e1b11a6030a4d61672b9ad3fbba1309abd978e42f66f17016274e3c173f76
099.jpg	9bdc53c96af007c5887c33dbf8dfa5aee4e81a928ae3a9e8b4514cc02169ab0b

[2025 DFC] 2025 디지털포렌식 챌린지 - 201 - Look at the Quote

pental — Mon, 20 Apr 2026 20:55:31 +0900

Step-by-step methodology:

문제 풀이에 앞서 대회에서 주어진 해시값과 다운로드 받은 해시값이 동일한지 확인한다.

그림 1 대회에서 주어진 해시값 목록

그림 2 hashtab 을 사용한 nal_unit.zip 의 해시 값

그림 3hashtab 을 사용한 sps-pps.zip 의 해시 값

대회에서 주어진 해시값과 다운 받은 파일을 HashTab을 통해 해시값이 동일함을 확인하였다.

각각 주어진 압축파일을 해제하면 다음과 같은 파일을 확인 할 수 있다.

그림 4 nal-unit.zip 압축 해제 파일

nal-unit,zip을 압축 해제하면 2개의 파일을 확인 할 수 있으며, 각각 파일에 대한 정보는 다음과 같다.

FileName	problem1.avi
FileSize	9,717,752 바이트
MD5	00E3BCFC9FA9961F53999B6D836C5070

표 1 problem1.avi 파일 정보

FileName	problem2.mp4
FileSize	6,194,586 바이트
MD5	0596CB493827E7F830B6D3EA3EE70D6D
비디오 길이	00:02:34
데이터 속도	252kbps
총 비트 전송률	253kbps
프레임 속도	15.00 프레임/초

표 2 problem2.mp4 파일 정보

두 파일 모두 재생이 불가능한 상태를 나타내고 있다.

sps-pps.zip 파일을 압축 해제하면 30개의 파일을 확인 할 수 있다.

그림 5 sps-pps.zip 압축 해제 파일

문제 풀이에 앞서 H.264 코덱의 설명은 다음과 같다.

H.264/AVC(Advanced Video Coding)는 ITU-T Video Coding Experts Group과 ISO/IEC Moving Picture Experts Group에 의해 공동 개발된 비디오 압축 표준이다. H.264는 이전 표준 대비 약 50%의 비트레이트 절약을 제공하면서도 동일한 화질을 유지할 수 있는 고효율 압축 기술이다.

특징	설명
계층적 구조	Network Abstraction Layer(NAL)와 Video Coding Layer(VCL)로 분리
유연한 참조 프레임	다중 참조 프레임 지원으로 압축 효율성 향상
적응적 인트라 예측	9가지 4×4 예측 모드와 4가지 16×16 예측 모드
가변 블록 크기	16×16부터 4×4까지 다양한 블록 크기 지원
엔트로피 코딩	CAVLC(Context Adaptive Variable Length Coding)와 CABAC(Context Adaptive Binary Arithmetic Coding) 지원

표 3 H.264의 특징 정리

H.264/AVC는 현대 비디오 코덱의 표준 중 하나로, 디코딩을 위해서는 SPS/PPS와 같은 메타데이터가 반드시 필요하다. 전송/저장 과정에서 이들 Parameter Set이 누락될 경우 디코더는 화질 손상이나 전혀 디코딩하지 못하는 상태가 된다.

1. SPS는 영상의 해상도, 프레임 레이트, 인코딩 레벨 등 전체 스트림의 전역적 특성을 정의한다.

2. PPS는 슬라이스 단위의 디코딩 파라미터(엔트로피 코딩 모드, 참조 프레임 설정 등)를 지정한다.

이 두 메타데이터가 누락될 경우 디코더는 올바른 프레임 해석이 불가능해져, 화질 손상 또는 디코딩 불능 상태에 이르게 된다. 특히 네트워크 전송 과정이나 컨테이너 추출 과정에서 SPS/PPS가 손실되는 사례가 발생할 수 있으며, 이 경우 원본 스트림은 존재하더라도 재생이 불가능하다.

본 문제풀이를 위해서 컨테이너 레벨에서 H.264 NAL 스트림은 존재하나 SPS/PPS가 빠진 케이스를 대상으로, 외부에서 수집한 Parameter Set 후보(HED 파일)들을 조합하여 올바른 매칭을 찾아내는 방법이 필요하다.

Question 1. 첫 번째로 주어진 H.264(problem1.avi)의 SPS, PPS가 없는 NAL 유닛을 디코딩 하여 영상에 기록된 철학자의 이름과 명언을 적어 제출 하시요.(50 points)

problem1.avi 분석과정은 다음과 같다.

먼저 ffprobe를 통해서 다음과 같은 특징을 확인 할 수 있다.

$ ./ffprobe.exe -v quiet -print_format json -show_format -show_streams nal_unit/problem1.avi

표 4 ffprobe를 이용한 problem1.avi 특징 분석 명령어

{
    "streams": [
        {
            "index": 0,
            "codec_name": "h264",
            "codec_long_name": "H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10",
            "codec_type": "video",
            "codec_tag_string": "x264",
            "codec_tag": "0x34363278",
            "width": 1280,
            "height": 720,
            "coded_width": 1280,
            "coded_height": 720,
            "has_b_frames": 0,
            "level": -99,
            "refs": 1,
            "is_avc": "false",
            "nal_length_size": "0",
            "r_frame_rate": "25/1",
            "avg_frame_rate": "25/1",
            "time_base": "1/25",
            "start_pts": 0,
            "start_time": "0.000000",
            "duration_ts": 0,
            "duration": "0.000000",
            "disposition": {
                "default": 0,
                "dub": 0,
                "original": 0,
                "comment": 0,
                "lyrics": 0,
                "karaoke": 0,
                "forced": 0,
                "hearing_impaired": 0,
                "visual_impaired": 0,
                "clean_effects": 0,
                "attached_pic": 0,
                "timed_thumbnails": 0,
                "non_diegetic": 0,
                "captions": 0,
                "descriptions": 0,
                "metadata": 0,
                "dependent": 0,
                "still_image": 0,
                "multilayer": 0
            }
        },
        {
            "index": 1,
            "codec_name": "adpcm_ima_wav",
            "codec_long_name": "ADPCM IMA WAV",
            "codec_type": "audio",
            "codec_tag_string": "[17][0][0][0]",
            "codec_tag": "0x0011",
            "sample_fmt": "s16p",
            "sample_rate": "8000",
            "channels": 1,
            "bits_per_sample": 4,
            "initial_padding": 0,
            "r_frame_rate": "0/0",
            "avg_frame_rate": "0/0",
            "time_base": "8/125",
            "start_pts": 0,
            "start_time": "0.000000",
            "bit_rate": "32000",
            "extradata_size": 2,
            "disposition": {
                "default": 0,
                "dub": 0,
                "original": 0,
                "comment": 0,
                "lyrics": 0,
                "karaoke": 0,
                "forced": 0,
                "hearing_impaired": 0,
                "visual_impaired": 0,
                "clean_effects": 0,
                "attached_pic": 0,
                "timed_thumbnails": 0,
                "non_diegetic": 0,
                "captions": 0,
                "descriptions": 0,
                "metadata": 0,
                "dependent": 0,
                "still_image": 0,
                "multilayer": 0
            }
        }
    ],
    "format": {
        "filename": "nal_unit/problem1.avi",
        "nb_streams": 2,
        "nb_programs": 0,
        "nb_stream_groups": 0,
        "format_name": "avi",
        "format_long_name": "AVI (Audio Video Interleaved)",
        "start_time": "0.000000",
        "size": "9717752",
        "probe_score": 100
    }
}

표 5 ffprobe를 통한 problem1.avi 결과

위 결과를 요약하면 다음과 같다.

컨테이너: AVI (format_name: avi), 파일 크기 ≈ 9.7 MB.

비디오: H.264 (codec_tag x264), 1280×720, 25 fps, has_b_frames=0, refs=1.

비디오 메타 특이: is_avc: "false", nal_length_size: "0", level: -99 (FFprobe가 level을 읽지 못함/미상).

오디오: adpcm_ima_wav (ADPCM IMA WAV), 8 kHz, mono, bit_rate 32000 (≈32 kbps), bits_per_sample 4.

문제표시: duration이 0.000000으로 나옴 즉, 컨테이너에 타이밍(index/PTS) 정보가 없거나 FFprobe가 읽지 못함.

AVI 컨테이너에서 순수 H.264 스트림을 추출하여 NAL Unit 구조를 분석했다.

$ ./ffmpeg -i nal_unit/problem1.avi -c copy -bsf:v h264_mp4toannexb extracted_h264
.h264

표 6 ffmpeg를 통해 H.264 스트림 추출 명령어

그림 6 ffmpeg를 통한 스트림 추출 과정 사진

ffmpeg의 h264_mp4toannexb 비트스트림 필터로 AVI 컨테이너에서 원시 H.264 스트림을 성공적으로 추출하였다. 추출 과정에서 ‘non-existing PPS 0 referenced’ 경고가 다수 발생했는데, 이는 입력 스트림에 필수 Parameter Set(SPS/PPS)이 포함되지 않았음을 의미하며, 디코딩 불능의 원인을 확인해 준다. 결과물 extracted_h264.h264는 Annex-B 형식의 원시 스트림으로, 이후 외부 HED 파일의 SPS/PPS를 prepend하여 디코딩 가능성을 브루트포스로 검증하는 단계로 진행하였다.

SPS/PPS 누락으로 디코딩이 불가한 H.264 스트림에 대해, 외부 후보(HED 파일)의 SPS·PPS를 모든 조합으로 대입하여 올바른 파라미터 세트를 탐색하는 절차를 코드로 구현하였다.

1. 후보 집합: sps-pps/ 디렉터리 내 HED 파일 30개(각각 SPS+PPS 포함)

2. 총 조합 수: 30 × 30 = 900 (SPS 30개 × PPS 30개, 크로스 매칭)

3. 접근 방식: 각 조합에 대해 Start Code(Annex‑B) 방식으로 SPS, PPS를 원시 H.264 스트림 앞에 prepend 후 디코딩 시도

위 방식을 통해 코드를 작성하면 다음과 같다.

import os
import subprocess
from pathlib import Path

def setup_folders():
folders = ['videos', 'thumbnails']
for folder in folders:
Path(folder).mkdir(exist_ok=True)

def test_h264(problem_file, sps_file, pps_file, problem_num, use_length_prefix=False):
"""H.264 조합 테스트"""
try:
# 파일 읽기
with open(sps_file, 'rb') as f:
sps_data = f.read()
with open(pps_file, 'rb') as f:
pps_data = f.read()
with open(problem_file, 'rb') as f:
video_data = f.read()

# 파일명 생성
sps_num = Path(sps_file).stem
pps_num = Path(pps_file).stem
video_file = f"videos/problem{problem_num}_sps{sps_num}_pps{pps_num}.h264"
thumb_file = f"thumbnails/problem{problem_num}_sps{sps_num}_pps{pps_num}.png"

# H.264 파일 생성
with open(video_file, 'wb') as f:
if use_length_prefix:
# Length prefix 방식
f.write(len(sps_data).to_bytes(4, 'big'))
f.write(sps_data)
f.write(len(pps_data).to_bytes(4, 'big'))
f.write(pps_data)
else:
# Start code 방식
f.write(b'\x00\x00\x00\x01')
f.write(sps_data)
f.write(b'\x00\x00\x00\x01')
f.write(pps_data)
f.write(video_data)

# ffmpeg로 썸네일 생성
cmd = ['./ffmpeg.exe', '-y', '-i', video_file, '-vframes', '1', '-loglevel', 'quiet', thumb_file]
result = subprocess.run(cmd, capture_output=True)

if result.returncode == 0 and os.path.exists(thumb_file):
print(f"Problem {problem_num}: SPS={sps_num}, PPS={pps_num}")
return True
else:
# 실패하면 파일 삭제
if os.path.exists(video_file):
os.remove(video_file)
if os.path.exists(thumb_file):
os.remove(thumb_file)
return False

except Exception:
return False

def main():

setup_folders()

# 파일 목록
hed_files = sorted([f for f in os.listdir("sps-pps") if f.endswith('.hed')])
print(f"Found {len(hed_files)} HED files")

success_count = 0
total_tests = 0

# Problem 1 (Start code)
print("\nProblem 1 (Start code)")
for sps_file in hed_files:
for pps_file in hed_files:
total_tests += 1
sps_path = f"sps-pps/{sps_file}"
pps_path = f"sps-pps/{pps_file}"

print(f"[{total_tests:3d}] SPS:{sps_file} + PPS:{pps_file}", end=" ")

if test_h264("nal_unit/problem1.avi", sps_path, pps_path, 1, False):
success_count += 1

if __name__ == "__main__":
main()

표 7 problem1.avi 파일을 복구하기 위해 사용한 코드

그림 7 표 7을 수행 한 결과 thumnails에 저장된 사진

코드를 실행하면 thumbnails 폴더에 각각의 사진이 추출된다. 다음은 성공 판별 기준을 통하여 얻은 파일의 조합 목록이다.

파일명	SPS	PPS
problem1_sps01_pps24.png	01	24
problem1_sps02_pps24.png	02	24
problem1_sps03_pps24.png	03	24
problem1_sps04_pps24.png	04	24
problem1_sps05_pps24.png	05	24
problem1_sps06_pps24.png	06	24
problem1_sps07_pps24.png	07	24
problem1_sps08_pps24.png	08	24
problem1_sps09_pps24.png	09	24
problem1_sps10_pps24.png	10	24
problem1_sps11_pps24.png	11	24
problem1_sps12_pps24.png	12	24
problem1_sps13_pps24.png	13	24
problem1_sps14_pps24.png	14	24
problem1_sps15_pps24.png	15	24
problem1_sps16_pps24.png	16	24
problem1_sps17_pps24.png	17	24
problem1_sps18_pps24.png	18	24
problem1_sps19_pps24.png	19	24
problem1_sps20_pps24.png	20	24
problem1_sps21_pps24.png	21	24
problem1_sps22_pps24.png	22	24
problem1_sps23_pps24.png	23	24
problem1_sps24_pps03.png	24	03
problem1_sps24_pps06.png	24	06
problem1_sps24_pps10.png	24	10
problem1_sps24_pps11.png	24	11
problem1_sps24_pps24.png	24	24
problem1_sps24_pps27.png	24	27
problem1_sps24_pps30.png	24	30
problem1_sps25_pps24.png	25	24
problem1_sps26_pps24.png	26	24
problem1_sps27_pps24.png	27	24
problem1_sps28_pps24.png	28	24
problem1_sps29_pps24.png	29	24
problem1_sps30_pps24.png	30	24

표 8 복구에 성공한 SPS, PPS 조합 및 파일명

그림 8 복구된 problem1.avi에서 발견된 명언

철학자 이름	Immanuel Kant
명언	Thoughts without content are empty, intuitions without concepts are blind

표 9 Question 1의 정답

Question 2. 두 번째로 주어진 H.264(problem2.mp4)의 SPS, PPS가 없는 NAL 유닛을 디코딩 하여 영상에 기록된 철학자의 이름과 명언을 적어 제출 하시요.(150 points)

problem2.mp4 분석과정은 다음과 같다.

먼저 ffprobe를 통해서 다음과 같은 특징을 확인 할 수 있다.

$ ./ffprobe.exe -v quiet -print_format json -show_format -show_streams nal_unit/problem2.mp4

표 10 ffprobe를 통해 problem2.mp4 파일 분석 명령어

{
    "streams": [
        {
            "index": 0,
            "codec_name": "pcm_mulaw",
            "codec_long_name": "PCM mu-law / G.711 mu-law",
            "codec_type": "audio",
            "codec_tag_string": "ulaw",
            "codec_tag": "0x77616c75",
            "sample_fmt": "s16",
            "sample_rate": "8000",
            "channels": 1,
            "bits_per_sample": 8,
            "initial_padding": 0,
            "id": "0x1",
            "r_frame_rate": "0/0",
            "avg_frame_rate": "0/0",
            "time_base": "1/8000",
            "start_pts": 3688,
            "start_time": "0.461000",
            "duration_ts": 1235560,
            "duration": "154.445000",
            "bit_rate": "63964",
            "nb_frames": "3859",
            "extradata_size": 4,
            "disposition": {
                "default": 1,
                "dub": 0,
                "original": 0,
                "comment": 0,
                "lyrics": 0,
                "karaoke": 0,
                "forced": 0,
                "hearing_impaired": 0,
                "visual_impaired": 0,
                "clean_effects": 0,
                "attached_pic": 0,
                "timed_thumbnails": 0,
                "non_diegetic": 0,
                "captions": 0,
                "descriptions": 0,
                "metadata": 0,
                "dependent": 0,
                "still_image": 0,
                "multilayer": 0
            },
            "tags": {
                "language": "eng",
                "handler_name": "ADPCM Audio Handle",
                "vendor_id": "[0][0][0][0]"
            }
        },
        {
            "index": 1,
            "codec_name": "h264",
            "codec_long_name": "H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10",
            "codec_type": "video",
            "codec_tag_string": "avc1",
            "codec_tag": "0x31637661",
            "width": 1920,
            "height": 1080,
            "coded_width": 1920,
            "coded_height": 1080,
            "closed_captions": 0,
            "film_grain": 0,
            "has_b_frames": 0,
            "level": -99,
            "refs": 1,
            "is_avc": "true",
            "nal_length_size": "4",
            "id": "0x2",
            "r_frame_rate": "15/1",
            "avg_frame_rate": "6948000/463157",
            "time_base": "1/90000",
            "start_pts": 0,
            "start_time": "0.000000",
            "duration_ts": 13894710,
            "duration": "154.385667",
            "bit_rate": "252210",
            "nb_frames": "2316",
            "extradata_size": 53,
            "disposition": {
                "default": 1,
                "dub": 0,
                "original": 0,
                "comment": 0,
                "lyrics": 0,
                "karaoke": 0,
                "forced": 0,
                "hearing_impaired": 0,
                "visual_impaired": 0,
                "clean_effects": 0,
                "attached_pic": 0,
                "timed_thumbnails": 0,
                "non_diegetic": 0,
                "captions": 0,
                "descriptions": 0,
                "metadata": 0,
                "dependent": 0,
                "still_image": 0,
                "multilayer": 0
            },
            "tags": {
                "language": "eng",
                "handler_name": "AVC Video Handler",
                "vendor_id": "[0][0][0][0]",
                "encoder": "AVC Coding"
            }
        }
    ],
    "format": {
        "filename": "/Users/pental/Downloads/201_attachments/nal_unit/problem2.mp4",
        "nb_streams": 2,
        "nb_programs": 0,
        "nb_stream_groups": 0,
        "format_name": "mov,mp4,m4a,3gp,3g2,mj2",
        "format_long_name": "QuickTime / MOV",
        "start_time": "0.000000",
        "duration": "154.906000",
        "size": "6194586",
        "bit_rate": "319914",
        "probe_score": 100,
        "tags": {
            "major_brand": "mobi",
            "minor_version": "0",
            "compatible_brands": "mobiavc1mp42isom"
        }
    }
}

표 11 ffprobe를 통한 problem2.mp4 분석 결과

ffprobe 분석 결과 avcC(AVC configuration box)에 SPS/PPS 메타데이터는 존재하지만 샘플 단위(NAL)에는 SPS/PPS NAL이 포함되지 않은 전형적인 케이스였다. 또한 비디오의 전체 비트레이트가 1080p 대비 매우 낮고(약 252 kbps), 오디오 트랙은 G.711 μ-law(8kHz)로 시작 시간이 약 0.461초 지연되어 있어 AV 동기 관련 특이점이 관찰되었다. 이런 특성 때문에 raw H.264(Annex-B)로 단순 추출/재생하면 SPS/PPS 누락으로 디코더가 프레임을 제대로 해석하지 못하고 재생 실패 또는 깨진 화면이 발생할 수 있었다.

현재의 문제점을 요약하면 다음과 같다.

1. SPS/PPS가 스트림 내부에 없고 avcC에만 존재: MP4 내부 avcC에 SPS/PPS 정보만 들어 있고 각 프레임 앞에 SPS/PPS가 붙어 있지 않으면 일부 플레이어나 파싱 도구가 초기화 정보를 찾지 못하고 있다.

2. NAL 포맷 차이(AVCC vs Annex-B): MP4는 길이정보(4바이트 길이 프리픽스) 방식(AVCC)을 사용하므로 raw Annex-B(0x00000001 start code) 포맷으로 변환/전환이 필요하다.

3. 메타 불일치 표시: ffprobe에서 level=-99 등 레벨 정보가 비정상으로 표기되어 SPS 내부의 level_idc를 정상적으로 읽지 못한 흔적이 있다(비표준/손상 가능성 또는 파서 표시 문제).

4. 오디오 시작 지연(AV 오프셋): 오디오 start_time=0.461으로 영상과의 초기 동기 차이가 존재할 수 있다(재생/동기화 고려 필요).

5. 저비트레이트(화질 저하 우려): 1080p 해상도에 대해 비트레이트가 낮아 화질이 거칠 수 있다.

따라서 해결 방법을 다음과 같이 진행하였다.

핵심 아이디어는 올바른 SPS/PPS를 비디오 비트스트림 앞에 넣어 디코더가 초기화하도록 만드는 것이다. SPS/PPS 후보를 다수(브루트포스)로 조합해 넣어보고, 각 조합으로 생성한 raw H.264 파일을 ffmpeg로 디코딩해 썸네일(프레임 이미지)을 얻어 ‘의미 있는 프레임’을 판별함으로써 올바른 SPS/PPS 조합을 찾는 방법을 택했다. 이는 SPS/PPS가 손상되었거나 원본 avcC 내 값이 정확치 않을 때 유용하다.

먼저 mp4 파일을 Annex-B로 변환하는 과정을 진행하였다. 다음은 변환에 사용한 명령어이다.

ffmpeg -i nal_unit/problem2.mp4 -c copy -bsf:v h264_mp4toannexb nal_unit/extracted_h264.h264

표 12 ffmpeg를 통한 mp4파일을 Annex-B로 변환하는 명령어

이 명령은 MP4 내부의 AVCC(길이 프리픽스) 기반 NAL들을 start-code(0x00000001) 방식(Annex-B)로 변환해 extracted_h264.h264에 저장한다. 다만 avcC 내 SPS/PPS가 별도 박스에만 존재하는 경우(또는 샘플에 포함되어있지 않은 경우) 변환 후에도 유효한 SPS/PPS가 앞에 붙어있지 않을 수 있다.

추출된 Annex-B 파일(extracted_h264.h264)은 이후 브루트포스 조합의 대상이 된다. 이 단계에서는 여러 개의 HED 파일에서 분리해낸 SPS와 PPS 후보들을 서로 조합하여, 각각을 Annex-B 스트림의 맨 앞에 삽입한 새로운 H.264 파일을 생성한다.

각 조합된 H.264 파일은 FFmpeg을 이용해 첫 번째 프레임을 이미지로 덤프하고, 이어서 Pillow 라이브러리로 분석된다. 분석 과정에서는 고유 색상 수, 이미지 해상도, 파일 해시와 같은 메타데이터가 계산된다. 이렇게 얻어진 지표를 기준으로 실제 영상 프레임인지 여부를 판별한다. 예를 들어, 색상 수가 일정 기준(예: 100 이상)을 넘으면 의미 있는 결과로 간주하며, 500 이상이면 매우 신뢰할 수 있는 성공 사례로 판단한다.

성공으로 판정된 조합은 bruteforce_results/successful 디렉터리에 .h264와 .png 형태로 보존되며, 각 결과는 조합명(spsXX_ppsYY), 생성 시각, 분석 메타정보와 함께 기록된다. 이후 사용자는 수동 재생을 통해 복구된 스트림의 품질과 연속성을 직접 확인할 수 있다.

사용한 코드는 다음과 같다.

import subprocess
from pathlib import Path
from PIL import Image
import hashlib
from datetime import datetime

class H264BruteForce:
    def __init__(self):
        self.sps_pps_dir = Path("sps-pps")
        self.h264_file = Path("nal_unit/extracted_h264.h264")

        self.base_output_dir = Path("bruteforce_results")
        self.videos_dir = self.base_output_dir / "videos"
        self.thumbnails_dir = self.base_output_dir / "thumbnails"
        self.successful_dir = self.base_output_dir / "successful"

        for directory in [self.videos_dir, self.thumbnails_dir, self.successful_dir]:
            directory.mkdir(parents=True, exist_ok=True)

        self.results = []
        self.successful_combinations = []

    def read_hed_file(self, hed_path):
        with open(hed_path, 'rb') as f:
            data = f.read()

        nal_units = []
        i = 0
        while i < len(data) - 4:
            if data[i:i+4] == b'\x00\x00\x00\x01':
                nal_start = i + 4
                nal_type = data[nal_start] & 0x1F

                next_start = len(data)
                for j in range(i + 4, len(data) - 3):
                    if data[j:j+4] == b'\x00\x00\x00\x01':
                        next_start = j
                        break

                nal_data = data[i:next_start]
                nal_units.append({
                    'type': nal_type,
                    'data': nal_data,
                    'size': len(nal_data)
                })

                i = next_start
            else:
                i += 1

        return nal_units

    def extract_sps_pps(self, nal_units):
        sps_data = None
        pps_data = None

        for nal in nal_units:
            if nal['type'] == 7:
                sps_data = nal['data']
            elif nal['type'] == 8:
                pps_data = nal['data']

        return sps_data, pps_data

    def create_combined_h264(self, sps_data, pps_data, sps_num, pps_num):
        with open(self.h264_file, 'rb') as f:
            h264_data = f.read()

        combined_data = bytearray()
        combined_data.extend(sps_data)
        combined_data.extend(pps_data)
        combined_data.extend(h264_data)

        output_path = self.videos_dir / f"sps{sps_num:02d}_pps{pps_num:02d}.h264"
        with open(output_path, 'wb') as f:
            f.write(combined_data)

        return output_path, len(combined_data)

    def generate_thumbnail(self, h264_path, sps_num, pps_num):
        thumbnail_path = self.thumbnails_dir / f"sps{sps_num:02d}_pps{pps_num:02d}.png"

        cmd = [
            'ffmpeg', '-y', '-v', 'quiet',
            '-i', str(h264_path),
            '-vframes', '1',
            '-f', 'image2',
            str(thumbnail_path)
        ]

        try:
            result = subprocess.run(cmd, capture_output=True, timeout=30)
            return thumbnail_path, result.returncode == 0 and thumbnail_path.exists(), result.stderr.decode() if result.stderr else "Unknown error"
        except:
            return thumbnail_path, False, "Timeout or error"

    def analyze_thumbnail(self, thumbnail_path):
        img = Image.open(thumbnail_path)

        if img.mode == 'RGB':
            colors = img.getcolors(maxcolors=256*256*256)
        else:
            img_rgb = img.convert('RGB')
            colors = img_rgb.getcolors(maxcolors=256*256*256)

        unique_colors = len(colors) if colors else 0

        with open(thumbnail_path, 'rb') as f:
            file_hash = hashlib.md5(f.read()).hexdigest()

        return {
            'resolution': img.size,
            'unique_colors': unique_colors,
            'file_hash': file_hash,
            'file_size': thumbnail_path.stat().st_size,
            'is_meaningful': unique_colors > 100,
            'is_highly_meaningful': unique_colors > 500,
            'mode': img.mode
        }

    def copy_successful_files(self, sps_num, pps_num, analysis):
        if not analysis.get('is_meaningful', False):
            return

        combo_name = f"sps{sps_num:02d}_pps{pps_num:02d}"

        video_src = self.videos_dir / f"{combo_name}.h264"
        thumbnail_src = self.thumbnails_dir / f"{combo_name}.png"

        video_dst = self.successful_dir / f"{combo_name}_{analysis['unique_colors']}colors.h264"
        thumbnail_dst = self.successful_dir / f"{combo_name}_{analysis['unique_colors']}colors.png"

        import shutil
        if video_src.exists():
            shutil.copy2(video_src, video_dst)
        if thumbnail_src.exists():
            shutil.copy2(thumbnail_src, thumbnail_dst)

    def test_single_combination(self, sps_num, pps_num, sps_data, pps_data):
        print(f"테스트 중: SPS{sps_num:02d} + PPS{pps_num:02d}", end=" ... ")

        h264_path, h264_size = self.create_combined_h264(sps_data, pps_data, sps_num, pps_num)
        thumbnail_path, thumbnail_success, error = self.generate_thumbnail(h264_path, sps_num, pps_num)

        result = {
            'sps_num': sps_num,
            'pps_num': pps_num,
            'combination': f"sps{sps_num:02d}_pps{pps_num:02d}",
            'h264_path': str(h264_path),
            'h264_size': h264_size,
            'thumbnail_path': str(thumbnail_path),
            'thumbnail_success': thumbnail_success,
            'timestamp': datetime.now().isoformat()
        }

        if thumbnail_success:
            analysis = self.analyze_thumbnail(thumbnail_path)
            result.update(analysis)

            self.copy_successful_files(sps_num, pps_num, analysis)

            colors = analysis.get('unique_colors', 0)
            if analysis.get('is_highly_meaningful', False):
                print(f" {colors}개 색상")
                self.successful_combinations.append(result)
            elif analysis.get('is_meaningful', False):
                print(f"✅ {colors}개 색상")
                self.successful_combinations.append(result)
            else:
                print(f"⚪ {colors}개 색상")
        else:
            print(f"❌ 실패")
            result['error'] = error

        self.results.append(result)
        return result

    def run_bruteforce_analysis(self):
        print("H.264 브루트포스 분석 시작")
        print("=" * 60)

        hed_files = {}
        for hed_file in sorted(self.sps_pps_dir.glob("*.hed")):
            file_num = int(hed_file.stem)
            nal_units = self.read_hed_file(hed_file)
            hed_files[file_num] = nal_units

        print(f"HED 파일: {len(hed_files)}개")

        file_numbers = sorted(hed_files.keys())
        total_combinations = len(file_numbers) ** 2

        print(f"총 조합: {total_combinations}개")
        print("=" * 60)

        tested = 0
        for sps_num in file_numbers:
            for pps_num in file_numbers:
                tested += 1
                progress = (tested / total_combinations) * 100

                print(f"[{tested:3d}/{total_combinations}] ({progress:5.1f}%) ", end="")

                sps_data, _ = self.extract_sps_pps(hed_files[sps_num])
                _, pps_data = self.extract_sps_pps(hed_files[pps_num])

                if sps_data and pps_data:
                    self.test_single_combination(sps_num, pps_num, sps_data, pps_data)
                else:
                    print(f"SPS{sps_num:02d} + PPS{pps_num:02d} ... ❌ 데이터 추출 실패")

        print("=" * 60)
        print("분석 완료!")

def main():
    bf = H264BruteForce()

    try:
        bf.run_bruteforce_analysis()
    except Exception as e:
        print(f"오류: {e}")

if __name__ == "__main__":
    main()

표 13 problem2.mp4 파일을 복구하기 위한 코드

그림 9 표 13 코드를 수행하는 과정 사진 1

그림 10 표 13 코드를 수행하는 과정 사진 2

그림 11 bruteforce_results/thumnails 폴더에 저장된 사진

코드를 실행하면 bruteforce_results/thumnails 폴더에 각각의 사진이 추출된다. 다음은 성공 판별 기준을 통하여 얻은 파일의 조합 목록이다.

파일명	SPS	PPS
sps20_pps05.png	20	05
sps20_pps06.png	20	06
sps20_pps12.png	20	12
sps20_pps27.png	20	27
sps20_pps29.png	20	29

표 14 명언을 확인 할 수 있는 SPS, PPS 조합 및 파일명

그림 12 복구된 problem2.mp4에서 발견된 명언

철학자 이름	Baruch Spinoza
명언	The highest activity a human being can attain is learning for understanding, because to understand is to be free.

표 15 Question2의 정답

palera1n을 통한 아이폰 탈옥 및 SSH 접근

pental — Mon, 23 Feb 2026 00:04:18 +0900

우연치 않게 아이폰 X를 구하게 되어서 오랜만에 탈옥을 진행해보려고 한다.

요즘 탈옥은 palera1n 및 도파민을 통해서 많이 진행한다고 하며, 이 포스팅에서는 palera1n을 통해서 탈옥을 진행한다.

https://palera.in/

palera1n

palera1n includes tools like dropbear (port 44), a (rather insecure) telnet option if specified, and a binpack with basic command line utilities

palera.in

필자는 맥북을 사용하고 있으며, 터미널을 통해서 진행했다.

sudo /bin/sh -c "$(curl -fsSL https://static.palera.in/scripts/install.sh)"

설치가 완료되면 터미널에서 palera1n 명령을 통해서 실행시킬수 있다.

아이폰을 연결하고, palera1n을 실행시키면 다음과 같이 작동한다.
하지만 -f (rootful)의 경우는 필자는 잘 작동하지 않았다. -l 옵션인 rootless를 통해서 탈옥을 진행했다.

자동으로 리커버리모드에 진입하고, 리커버리모드에 진입했을때, 직접 DFU 모드로 들어가줘야한다.

아이폰 X의 DFU 접근방법은 볼륨아래 + 전원 5초 누르고, 5초후 전원버튼만 떼고 볼륨 아래 버튼만 누르고 있으면 된다.

palera1n 자체에서 직접 탈옥을 진행해주고, 이때 아이폰 X에서는 실시간으로 통신이 진행된다.

탈옥이 완료되면 탈옥된 폰에서는 palera1n 앱을 확인할 수 있고, 실행해서 Sileo, Zebra를 설치한다.

설치 후 Sileo를 실행시켜, SSH 서버를 구성한다.

해당 패키지는 설치 후 설정 - Wifi - 연결된 Wifi 상세보기 후 탈옥된 폰에 연결된 ip주소를 확인한다.

현재 탈옥된 폰에서는 192.168.1.63을 사용하고 있고, ssh mobile@192.168.1.63 을 통해서 SSH를 접근한다.

palera1n에서 미리 sudo 비밀번호를 설정해줘야한다. 그리고 바로 ssh root@192.168.1.63은 케바케로 안될 확률이 높고, mobile 계정으로 접근 후 su 를 통해서 권한 상승을 진행한다.

루트로 접근이 됐으면 passwd를 통해서 sudo 비밀번호를 새로 지정한다. (root로 직접 접근 하는 가장 쉬운 방법이라고 생각된다.)

sudo 비밀번호 재설정이 완료되면, root로 접근을 진행해본다.

접근이 정상적으로 되는것을 확인할 수 있고, scp를 통해서 파일을 빼보는 작업을 한다.

scp -r root@[IP주소]:[경로]

위 커맨드를 통해서 파일 추출이 정상적으로 가능한 것을 확인 할 수 있었다.

[25년 2회차] 제11회 빅데이터분석기사 합격 후기 (필기 & 실기)

pental — Thu, 25 Dec 2025 00:13:09 +0900

어쩌다보니 응시하게 된 "빅데이터분석기사" 어떨결에 합격했다. 이로써 정보처리기사, 정보보안기사, 빅데이터분석기사 총 3개의 기사를 가지게 되었다.

아래는 내가 가지고 있는 자격 목록들,,

정보처리기사, 정보보안기사, 빅데이터분석기사
디지털포렌식 전문가 2급
컴퓨터활용능력 1급, 워드프로세서
리눅스마스터 2급, SQLD, FTK Ace v6,7

자격증 리스트가 계속해서 추가되고 있다,,,, 자격증이 하나둘 추가되다 보니 “이제 뭐가 본업인지 모르겠다”는 생각도 가끔 들지만, 그래도 그 과정 자체는 분명 의미가 있었다.

이번 글에서는 빅데이터분석기사 필기·실기를 한 번에 합격하면서 느낀 점, 그리고 짧게나마 공부 방법과 소소한 팁을 기록용으로 남겨보려 한다. 앞으로 준비하시는 분들께 조금이나마 도움이 되길 바란다.

빅데이터분석기사의 과목이랑 내용은 다음과 같다.

빅데이터분석기사 자격시험은 필기시험과 실기시험으로 구성되어 있으며 필기시험 합격기준 및 응시자격 요건을 충족하면 실기시험에 응시할 수 있다. 실기시험은 CBT(Computer Based Test) 방식의 시험으로 자격을 검정하며, 실기시험의 합격자는 최종합격자로 분류되어 빅데이터분석기사 자격이 부여된다. 검정 과목 및 내용은 아래와 같다.

빅데이터분석기사 자격시험은 필기시험 + 실기시험으로 구성되어 있다.
- 필기시험 합격 기준을 충족하면 실기시험 응시 가능
- 실기시험은 CBT(Computer Based Test) 방식
- 실기시험 합격 시 최종합격으로 자격증이 부여된다
즉, 필기만 붙어도 끝이 아니라 실기까지 통과해야 진짜 합격이다. (기사 자격시험의 특성)

필기시험 출제 문항 수 및 합격 기준

과목당 20문항, 총 80문항
객관식 4지선다형
과목별 40점 이상
전 과목 평균 60점 이상 시 합격

한 과목이라도 40점 미만이면 과락이라 특정 과목만 파고들기보다는 전 과목 균형이 중요하다.

필기 공부 방법

공부기간 : 약 2-3주

필기 책 : 2025 이기적 빅데이터분석기사 필기 기본서 (https://www.aladin.co.kr/shop/wproduct.aspx?ItemId=344700450)

- 개념 위주로 빠르게 1회독
- 기출문제 반복
- 애매한 통계·모델 개념만 따로 정리

정보처리기사, SQLD 경험이 있다면 필기 난이도는 크게 부담되지 않는 편이다.

나는 노션에 정리하면서 푸는 방식으로 진행했으며, 기출문제를 거의 3회독 하고 갔다. 3회독 하면서 어디 과목이 문제인디 점수가 어떻게 되는지 확인하면서 진행했고, 대부분의 기사시험이나 자격증은 기출문제 3회독은 하고 가자는 마인드를 가지고 있다.

3회독을 하면서 어느 과목이 약한지, 평균 점수가 어느 정도 나오는지를 계속 체크했다.

개인적으로 대부분의 기사시험이나 자격증은 “기출문제 3회독은 하고 가자”라는 마인드를 가지고 있다.

어차피 개념이 제대로 잡히지 않은 문제는 몇 번을 풀어도 다시 틀리게 되어 있다. 그래서 오답 노트를 따로 만들어 틀린 문제만 집중적으로 반복하는 방식으로 보완했다.

실기 공부 방법

공부기간 : 약 2~3주

실기 책 : 2025 이기적 빅데이터분석기사 실기 Python (https://www.aladin.co.kr/shop/wproduct.aspx?ItemId=361150212)

- 전처리 흐름 이해 (결측치, 이상치)
- 기본적인 pandas 코드 해석
- 평가 지표 의미 정리 (Accuracy, Precision, Recall 등)
- 회귀, 분류 확인 (Classifier, Regressor)

코드를 외우기보다는 읽을 수 있어야 한다는 점이 핵심인것 같다.

실기도 마찬가지로 노션에 정리하면서 진행했다. 작업형 1유형부분은 데이터 전처리 등을 다루고 있어서 데이터마님에 있는 문제로 열심히 풀었다.

2유형은 거즘 짜진 템플릿이 있어서 해당 템플릿을 외워갔고, 거의 무적공식이라고 불리던 코드에 배신당했다.

이번회차 2유형에서는 랜덤포레스트 + 분류를 단순히 진행하면 25/40 밖에 주지 않았고, 이로 인해서 커뮤니티에서는 왜 25점밖에 안나오냐, 같은 모델을 썼는데 누군 왜 30점이냐,, 이런식의 반응이었다.

이 경험을 통해 느낀 점은 “템플릿은 안전장치일 뿐, 절대 정답은 아니다”라는 것. 앞으로는 템플릿을 외우되, 문제에서 요구하는 맥락을 더 잘 읽는 연습이 필요하다고 느꼈다.

내가 사용한 코드는 아래와 같은 형식이었다.

import pandas as pd
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import f1_score

train = pd.read_csv("train.csv")
test = pd.read_csv("test.csv")

le = LabelEncoder()
train['type'] = le.fit_transform(train['type'])
test['type'] = le.transform(test['type'])

x_tr, x_val, y_tr, y_val = train_test_split(train, y, test_size=0.2, random_state=42)
rf = RandomForestClassifier(random_state=42)
rf.fit(x_tr, y_tr)
pred = rf.predict(x_val)
print(f1_score(y_val, pred)

result = rf.predict(test)
submit = pd.DataFrame({"pred" : result}).to_csv("result.csv")

3유형은 진짜 공부를 열심히 해야한다고 느꼈다.

어쩌다 시작했지만, 결과적으로는 나름 만족스러운 자격증이었다.

빅데이터분석기사를 준비하고 계신 분들 모두 너무 겁먹지 말고, 기본 개념 + 기출 중심으로 차근차근 준비하시면 분명 좋은 결과가 있을 거라 생각한다.

이 글이 누군가에게 조금이라도 참고 자료가 되길 바라며, 준비하시는 모든 분들 합격을 응원합니다

[브론즈 2] 백준 2703 - Cryptoquote (파이썬)

pental — Wed, 19 Nov 2025 19:04:00 +0900

import sys

t = int(sys.stdin.readline().strip())

for _ in range(t):
    encrypted = sys.stdin.readline().rstrip("\n")
    rule = sys.stdin.readline().strip()

    result_chars = []

    for ch in encrypted:
        if ch == " ":
            result_chars.append(" ")
        else:
            idx = ord(ch) - ord('A')
            result_chars.append(rule[idx])

    print("".join(result_chars))

[빅데이터분석기사] 실기 대비 4일차 - 기출문제 4회

pental — Thu, 6 Nov 2025 10:48:01 +0900

본 글은 개인적으로 공부하려고 작성한 내용입니다.
만일 저작권 및 다른 이유로 인해 문제가 발생할 소지가 있다면
pental@kakao.com 으로 메일 또는 해당 게시물에 댓글을 달아주시면 처리하도록 하겠습니다.

본 내용은 빅데이터분석기사-2차실기 / 장은진 교수님의 강의를 듣고 개인적으로 추가 공부가 필요한 내용에 대해서 정리한 글입니다.

작업형 1유형 문제 1

- 주어진 데이터의 age 컬럼의 3사분위수와 1사분위수의 차를 절대값으로 구하고 정수형태로 출력하시오

- data : basic1.csv

먼저 import pandas 와 같이 기본적인 작업을 진행하고 데이터의 정보를 확인한다.

import pandas as pd
df = pd.read_csv("./bigdata_csvfile/basic1.csv")
df

id	age	city	f1	f2	f3	f4	f5
0	id01	2.0	서울	NaN	0	NaN	ENFJ
1	id02	9.0	서울	70.0	1	NaN	ENFJ
2	id03	27.0	서울	61.0	1	NaN	ISTJ
3	id04	75.0	서울	NaN	2	NaN	INFP
4	id05	24.0	서울	85.0	2	NaN	ISFJ
...	...	...	...	...	...	...	...
95	id96	92.0	경기	53.0	1	NaN	ENTJ
96	id97	100.0	경기	NaN	0	NaN	INFP
97	id98	39.0	경기	58.0	2	NaN	INFP
98	id99	1.0	경기	47.0	0	NaN	ESFJ
99	id100	47.0	경기	53.0	0	vip	ESFP

총 100개의 행이 있으며 8개의 컬럼으로 이루어져 있다.

문제에서는 age컬럼의 3사분위수와 1사분위수의 차의 절대값으로 구하라 했기에, quantile 함수를 통해서 3사분위수와 1사분위의를 구한다.

Q3 = df['age'].quantile(0.75)
Q1 = df['age'].quantile(0.25)
# print(Q3) # 77.0
# print(Q1) # 26.875

절대값 및 정수로 출력하기 위해서 다음과 같이 진행하였다.

result = int(abs(Q3 - Q1)) # 50
print(result)

답 : 50

# 다른 답안
Q3 = df.age.quantile(.75)
Q1 = df.age.quantile(.25)
result = abs(Q3 - Q1)
print(int(result))

작업형 1유형 문제 2

주어진 소셜 데이터에서 (loves 컬럼 + wows 컬럼) / (reactions 컬럼) 비율이 0.4보다 크고 0.5보다 작으면서, type = 'video'인 데이터의 개수를 구하시오
data : fb.csv

import pandas as pd
df = pd.read_csv("./bigdata_csvfile/fb.csv")
display(df)

id	type	reactions	comments	shares	likes	loves	wows	hahas	sads	angrys
0	1	video	529	512	262	432	92	3	1	1
1	2	photo	150	0	0	150	0	0	0	0
2	3	video	227	236	57	204	21	1	1	0
3	4	photo	111	0	0	111	0	0	0	0
4	5	photo	213	0	0	204	9	0	0	0
...	...	...	...	...	...	...	...	...	...	...
7045	7046	photo	89	0	0	89	0	0	0	0
7046	7047	photo	16	0	0	14	1	0	1	0
7047	7048	photo	2	0	0	1	1	0	0	0
7048	7049	photo	351	12	22	349	2	0	0	0
7049	7050	photo	17	0	0	17	0	0	0	0

이 데이터는 7050행, 11개의 컬럼으로 이루어져 있다.

먼저 문제에서 주어진 것처럼 데이터를 계산하기 위해서 `calc` 컬럼을 새로 만들어 (loves + wows) / reactions 의 값을 계산해주었다.

df['calc'] = (df['loves'] + df['wows']) / df['reactions']
display(df['calc'])

0       0.179584
1       0.000000
2       0.096916
3       0.000000
4       0.042254
          ...   
7045    0.000000
7046    0.062500
7047    0.500000
7048    0.005698
7049    0.000000
Name: calc, Length: 7050, dtype: float64

다음으로는 문제에서 주어진 조건식을 세워주었다.

cond1 = df['calc'] > 0.4
cond2 = df['calc'] < 0.5
cond3 = df['type'] == 'video'
print(len(df[cond1 & cond2 & cond3])) # 50

나는 cond를 따로 나누어 조건식을 세웠지만 loc로도 작업이 가능하다.

df.loc[(df['calc'] > 0.4) & (df['calc'] < 0.5) & (df['type'] == 'video')]

답 : 50

# 다른 풀이
df['ratio'] = (df.loves + df.wows) / df.reactions
result = (df.type == 'video') & (df.ratio > 0.4) & (df.ratio < 0.5) 
print(result.sum())

작업형 1유형 문제 3

주어진 미디어 데이터에서 data_added가 2018년 1월 이면서 country가 United Kingdom 단독 제작인 데이터의 개수를 구하시오
data : nf.csv

import pandas as pd
df = pd.read_csv("./bigdata_csvfile/nf.csv")

display(df)

show_id	type	title	director	cast	country	date_added	release_year	rating	duration	listed_in
0	s1	Movie	Dick Johnson Is Dead	Kirsten Johnson	NaN	United States	September 25, 2021	2020	PG-13	90 min
1	s2	TV Show	Blood & Water	NaN	Ama Qamata, Khosi Ngema, Gail Mabalane, Thaban...	South Africa	September 24, 2021	2021	TV-MA	2 Seasons
2	s3	TV Show	Ganglands	Julien Leclercq	Sami Bouajila, Tracy Gotoas, Samuel Jouy, Nabi...	NaN	September 24, 2021	2021	TV-MA	1 Season
3	s4	TV Show	Jailbirds New Orleans	NaN	NaN	NaN	September 24, 2021	2021	TV-MA	1 Season
4	s5	TV Show	Kota Factory	NaN	Mayur More, Jitendra Kumar, Ranjan Raj, Alam K...	India	September 24, 2021	2021	TV-MA	2 Seasons
...	...	...	...	...	...	...	...	...	...	...
8802	s8803	Movie	Zodiac	David Fincher	Mark Ruffalo, Jake Gyllenhaal, Robert Downey J...	United States	November 20, 2019	2007	R	158 min
8803	s8804	TV Show	Zombie Dumb	NaN	NaN	NaN	July 1, 2019	2018	TV-Y7	2 Seasons

먼저 date_added 컬럼을 pd.to_datetime 함수를 통해서 pandas에서 자동으로 날짜 형식으로 변환시키도록 한다,

df['date_added'] = pd.to_datetime(df['date_added'])
display(df['date_added'])

0      2021-09-25
1      2021-09-24
2      2021-09-24
3      2021-09-24
4      2021-09-24
          ...    
8802   2019-11-20
8803   2019-07-01
8804   2019-11-01
8805   2020-01-11
8806   2019-03-02
Name: date_added, Length: 8807, dtype: datetime64[ns]

이렇게 되면 `df[’date_added’]` 컬럼은 데이터타입이 `datetime64`로 변하게 된다. ← 이건 중요

또한 연과 월을 구해야하기 때문에 `df[’date_added_month’]`, `df[’date_added_year’]` 컬럼을 새로 생성해주었다. 이때, `.dt.month`, `.dt.year`을 사용하여 연과 월을 계산했다.

df['date_added_month'] = df['date_added'].dt.month
df['date_added_year'] = df['date_added'].dt.year

또한 조건식을 3개 세워서 2018년이면서 1월, 그리고 국가가 United Kingdom 인 경우의 조건 3개를 세워줬다.

cond1 = df['date_added_month'] == 1
cond2 = df['date_added_year'] == 2018
cond3 = df['country'] == "United Kingdom"

조건식에 & 필터링을 걸어서 계산한 결과를 출력한다.

result = df[cond1 & cond2 & cond3]
print(len(result)) # 6

답 : 6

# 다른 풀이
df.date_added = pd.to_datetime(df.date_added)
con1 = df['date_added'].dt.year == 2018
con2 = df['date_added'].dt.month == 1
con3 = df['country'] == "United Kingdom"

result = con1 & con2 & con3
print(result.sum())

작업형 2유형

주어진 데이터를 활용하여 목표 변수 Segmentation에 대해 ID별로 Segmentation의 클래스를 예측해서 저장 후 제출하시오.
단, 제출 데이터 컬럼은 ID와 Segmentation 두 개만 존재해야하고, index는 포함하지 않는다.
평가지표는 macro f1 score로 하고, 제출 파일 이름은 4th_test_type2.csv로 한다.
train data : test4_type2_train.csv
test data : test4_type2_test.csv

import pandas as pd

train = pd.read_csv("./bigdata_csvfile/test4_type2_train.csv")
test = pd.read_csv("./bigdata_csvfile/test4_type2_test.csv")

# EDA
display(train.head())
display(test.head())

ID	Gender	Ever_Married	Age	Graduated	Profession	Work_Experience	Spending_Score	Family_Size	Var_1	Segmentation
0	464357	Male	No	40	Yes	Artist	7.0	Low	1.0	Cat_6
1	459624	Male	No	18	No	Healthcare	NaN	Low	5.0	Cat_4
2	462672	Male	No	25	No	Healthcare	7.0	Low	4.0	Cat_4
3	463360	Female	Yes	46	Yes	Artist	2.0	Low	1.0	Cat_6
4	462420	Male	No	27	Yes	Healthcare	1.0	Low	3.0	Cat_6

	ID	Gender	Ever_Married	Age	Graduated	Profession	Work_Experience	Spending_Score	Family_Size	Var_1
0	460406	Male	Yes	36	Yes	Healthcare	3.0	Low	2.0	Cat_6
1	466890	Male	Yes	47	Yes	Artist	0.0	Average	6.0	Cat_7
2	466145	Male	Yes	56	No	Entertainment	1.0	Average	3.0	Cat_6
3	465805	Male	Yes	50	Yes	Engineer	NaN	Low	1.0	Cat_3
4	466137	Female	NaN	31	No	Healthcare	0.0	Low	4.0	Cat_6

각각 `train`, `test`의 `head`를 보여주고 있다. `탐색적 EDA`를 진행한다. (기본 정보 및 결측값 확인)

먼저 결측값을 확인했다.

print(train.isnull().sum())
print()
print(test.isnull().sum())

ID                   0
Gender               0
Ever_Married        96
Age                  0
Graduated           51
Profession          64
Work_Experience    513
Spending_Score       0
Family_Size        192
Var_1               50
Segmentation         0
dtype: int64

ID                   0
Gender               0
Ever_Married        22
Age                  0
Graduated           16
Profession          23
Work_Experience    142
Spending_Score       0
Family_Size         68
Var_1               12
dtype: int64

현재 train과 test 모두 결측값이 다량 존재한다. 이 값들을 모두 제거하기로 한다.

# 결측값은 제거

train.dropna(axis = 0, inplace = True)
test.dropna(axis = 0, inplace = True)

print(train.isnull().sum())
print(test.isnull().sum())


ID                 0
Gender             0
Ever_Married       0
Age                0
Graduated          0
Profession         0
Work_Experience    0
Spending_Score     0
Family_Size        0
Var_1              0
Segmentation       0
dtype: int64
ID                 0
Gender             0
Ever_Married       0
Age                0
Graduated          0
Profession         0
Work_Experience    0
Spending_Score     0
Family_Size        0
Var_1              0
dtype: int64

`dropna` 및 `axis = 0`을 통해서 결측값 행을 모두 삭제해주었다. 이로 인해서 행 갯수가 변하게 되었다.

`train`의 경우 결측값 제거전 4881개의 행, 결측값 제거 후 4018행을 나타내고 있다. 대략 800개의 행이 제거되었다.

`info` 함수를 통해서 라벨인코딩 전 어떤 값이 `object` 타입인지 알기 위해서 진행했다.

print(train.info())

<class 'pandas.core.frame.DataFrame'>
Index: 4018 entries, 0 to 4879
Data columns (total 11 columns):
 #   Column           Non-Null Count  Dtype  
---  ------           --------------  -----  
 0   ID               4018 non-null   int64  
 1   Gender           4018 non-null   object 
 2   Ever_Married     4018 non-null   object 
 3   Age              4018 non-null   int64  
 4   Graduated        4018 non-null   object 
 5   Profession       4018 non-null   object 
 6   Work_Experience  4018 non-null   float64
 7   Spending_Score   4018 non-null   object 
 8   Family_Size      4018 non-null   float64
 9   Var_1            4018 non-null   object 
 10  Segmentation     4018 non-null   object 
dtypes: float64(2), int64(2), object(7)
memory usage: 376.7+ KB
None

object 타입인 친구들을 미리 알아두고 라벨인코딩을 진행한다. 라벨인코딩의 경우 sklearn의 LabelEncoder을 사용했다. 아래는 사용한 코드이다.

from sklearn.preprocessing import LabelEncoder
cols = ['Gender', 'Ever_Married', "Graduated", "Profession", "Spending_Score", "Var_1"]

le = LabelEncoder()

for col in cols :
    le.fit(train[col])
    train[col] = le.transform(train[col])
    test[col] = le.transform(test[col])

print(train.info())
print(test.info())

<class 'pandas.core.frame.DataFrame'>
Index: 4018 entries, 0 to 4879
Data columns (total 11 columns):
 #   Column           Non-Null Count  Dtype  
---  ------           --------------  -----  
 0   ID               4018 non-null   int64  
 1   Gender           4018 non-null   int64  
 2   Ever_Married     4018 non-null   int64  
 3   Age              4018 non-null   int64  
 4   Graduated        4018 non-null   int64  
 5   Profession       4018 non-null   int64  
 6   Work_Experience  4018 non-null   float64
 7   Spending_Score   4018 non-null   int64  
 8   Family_Size      4018 non-null   float64
 9   Var_1            4018 non-null   int64  
 10  Segmentation     4018 non-null   object 
dtypes: float64(2), int64(8), object(1)
memory usage: 376.7+ KB
None
<class 'pandas.core.frame.DataFrame'>
Index: 1288 entries, 0 to 1541
Data columns (total 10 columns):
 #   Column           Non-Null Count  Dtype  
---  ------           --------------  -----  
 0   ID               1288 non-null   int64  
...
 9   Var_1            1288 non-null   int64  
dtypes: float64(2), int64(8)
memory usage: 110.7 KB

여기서 놓치기 쉬운점은 `train`에 대해서만 라벨인코딩을 진행하는것이 아닌 `test` 데이터에도 라벨 인코딩을 진행해야한다.

모든 `object` 타입들이 `int64`로 변경된것을 확인할 수 있다. 이제 본격적으로 학습을 진행한다.

from sklearn.model_selection import train_test_split
X = train.drop(columns = ["Segmentation", "ID"])
y = train["Segmentation"]

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 123)
print(X_train.shape, X_test.shape, y_train.shape, y_test.shape)

(3214, 9) (804, 9) (3214,) (804,)

X는 독립변수 y는 종속변수이다. X에 `Segmentation`은 삭제하는게 당연하다. 종속변수이기 때문이다. 그런데 ID는 삭제한 이유는 학습에 도움이 되지 않는 값이기 때문에 `Segmentation`과 `ID` 모두 삭제했다.

y는 종속변수이기에 `train[”Segmentation”]`의 단일 열을 가지도록 한다.

from sklearn.ensemble import RandomForestClassifier

rfc = RandomForestClassifier(n_estimators = 95, max_depth = 6, random_state = 123)
rfc.fit(X_train, y_train)
pred = rfc.predict(X_test)
print(pred[:5])

['A' 'C' 'C' 'D' 'A']

랜덤포레스트를 통해서 학습을 진행한다. 문제에서는 f1_score의 결과를 평가지표로 사용한다 했기에 f1 값을 계산한다.

from sklearn.metrics import f1_score, accuracy_score

f1 = f1_score(pred, y_test, average = "macro")
print("f1: ", f1) # f1:  0.505136752530129

acc = accuracy_score(pred, y_test)
print("acc : ", acc) # acc :  0.5211442786069652

accuracy_score는 그냥 정확도 확인을 위해서 사용했다.

여기서 또 놓치기 쉬운점은 지금은 학습데이터로 예측을 한것이고, 실제 제출에서는 테스트 데이터를 사용해서 제출해야한다는 점이다. 따라서 test 데이터에서도 동일하게 ID를 삭제한다.

data = test.drop(columns = "ID")
result = rfc.predict(data)
df = pd.DataFrame(
    {
        "ID" : test["ID"],
        "Segentation" : result
    }
).to_csv("4th_test_type2.csv", index = False)

display(pd.read_csv("4th_test_type2.csv"))

ID	Segentation
0	460406	D
1	466890	C
2	466145	B
3	467572	C
4	460767	B
...	...	...
1283	463734	A
1284	466055	B
1285	465689	D
1286	460401	A
1287	465215	B
1288 rows × 2 columns

또한 `ID` 및 `Segmentation`을 제출하라 했기에, `test[”ID”]`를 통해서 ID값을 추가했다.

근데 모델의 평가지표가 너무 낮아서 모델 향상을 진행해보려고 한다.

import pandas as pd

train = pd.read_csv("./bigdata_csvfile/test4_type2_train.csv")
test = pd.read_csv("./bigdata_csvfile/test4_type2_test.csv")

cols = ['Ever_Married', "Graduated", "Profession", "Work_Experience", "Family_Size", "Var_1"]

for col in cols :
    train[col] = train[col].fillna(train[col].mode()[0])
    test[col] = test[col].fillna(test[col].mode()[0])

결측값을 제거하는 것이 아닌 최빈값으로 대체하는 방법을 사용해보았다.

train.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 4881 entries, 0 to 4880
Data columns (total 11 columns):
 #   Column           Non-Null Count  Dtype  
---  ------           --------------  -----  
 0   ID               4881 non-null   int64  
 1   Gender           4881 non-null   object 
 2   Ever_Married     4881 non-null   object 
 3   Age              4881 non-null   int64  
 4   Graduated        4881 non-null   object 
 5   Profession       4881 non-null   object 
 6   Work_Experience  4881 non-null   float64
 7   Spending_Score   4881 non-null   object 
 8   Family_Size      4881 non-null   float64
 9   Var_1            4881 non-null   object 
 10  Segmentation     4881 non-null   object 
dtypes: float64(2), int64(2), object(7)
memory usage: 419.6+ KB

위와 동일하게 라벨인코딩을 진행한다.

from sklearn.preprocessing import LabelEncoder
cols = ["Gender", "Ever_Married", "Graduated", "Profession" ,"Spending_Score", "Var_1"]

le = LabelEncoder()
for col in cols :
    le.fit(train[col])
    train[col] = le.transform(train[col])
    test[col] = le.transform(test[col])

from sklearn.model_selection import train_test_split
X = train.drop(columns = ["ID", "Segmentation"])
y = train["Segmentation"]

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 42)

from sklearn.ensemble import RandomForestClassifier
rfc = RandomForestClassifier(n_estimators = 95, max_depth = 6, random_state = 42)
rfc.fit(X_train, y_train)
pred = rfc.predict(X_test)

from sklearn.metrics import f1_score, accuracy_score

f1 = f1_score(pred, y_test, average = 'macro')
acc = accuracy_score(pred, y_test)
print("F1 : ", f1) # F1 :  0.4509502343284842
print("ACC : ", acc) # ACC :  0.46980552712384854

결측값을 제거했을때와 최빈값으로 대체했을때의 평가지표의 결과를 확인하면 오히려 결측값을 대체했을때 평가점수가 더 낮은 것을 확인 할 수 있다. ~~이러면 나가리인데~~

다음은 `LabelEncoder`을 사용하지 않고, `pd.get_dummies()`함수를 사용해보고자 한다.

import pandas as pd

train = pd.read_csv("./bigdata_csvfile/test4_type2_train.csv")
test = pd.read_csv("./bigdata_csvfile/test4_type2_test.csv")

cols = ['Ever_Married', "Graduated", "Profession", "Work_Experience", "Family_Size", "Var_1"]

for col in cols :
    train[col] = train[col].fillna(train[col].mode()[0])
    test[col] = test[col].fillna(test[col].mode()[0])
    
cols = ["Gender", 'Ever_Married', "Graduated", "Profession", "Spending_Score", "Var_1"]
train = pd.get_dummies(train, columns = cols)
test = pd.get_dummies(test, columns = cols)

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 42)
from sklearn.metrics import f1_score, accuracy_score
from sklearn.ensemble import RandomForestClassifier
rf = RandomForestClassifier(n_estimators = 95, max_depth = 6, random_state=42)
rf.fit(X_train, y_train)
pred = rf.predict(X_test)

f1 = f1_score(pred, y_test, average = 'macro')
acc = accuracy_score(pred, y_test)
print(f1, acc) # 0.4509502343284842 0.46980552712384854

똑같다.. 이러면 LabelEncoder와 pd.get_dummies()가 같은건가,,?

[빅데이터분석기사] 실기 대비 3일차 - 기출문제 3회

pental — Wed, 5 Nov 2025 10:53:54 +0900

본 내용은 빅데이터분석기사-2차실기 / 장은진 교수님의 강의를 듣고 개인적으로 추가 공부가 필요한 내용에 대해서 정리한 글입니다.

작업형 1유형 문제 1

주어진 데이터 중 컬럼들의 결측값을 전부 제거한 후 데이터를 처음부터 순서대로 70%를 추출하여 housing_median_age 컬럼의 1분위수를 산출해라.
(단, 출력 결과는 정수형태로 한다.)

import pandas as pd
df = pd.read_csv("./bigdata_csvfile/california_housing.csv")
display(df.head())

longitude	latitude	housing_median_age	total_rooms	total_bedrooms	population	households	median_income	median_house_value	ocean_proximity
0	-122.23	37.88	41.0	880.0	129.0	322.0	126.0	8.3252	452600.0
1	-122.22	37.86	21.0	7099.0	1106.0	2401.0	1138.0	8.3014	358500.0
2	-122.24	37.85	52.0	1467.0	190.0	496.0	177.0	7.2574	352100.0
3	-122.25	37.85	52.0	1274.0	235.0	558.0	219.0	5.6431	341300.0
4	-122.25	37.85	52.0	1627.0	280.0	565.0	259.0	3.8462	342200.0

pd를 통해서 데이터를 읽어온다. california_housing.csv 파일.

이 켈리포니아 하우스 데이터는 어디서나 쓰이는거 같은데,,, 좀더 분석해두면 좋을 것 같다.

먼저 문제에서 결측값을 전부 제거하라 했기 때문에 `.isnull()` 함수를 통해서 결측값을 모두 제거한다. 먼저 결측값의 데이터를 확인한다.

print(df.isnull().sum())

longitude               0
latitude                0
housing_median_age      0
total_rooms             0
total_bedrooms        207
population              0
households              0
median_income           0
median_house_value      0
ocean_proximity         0
dtype: int64

데이터 분석 결과 total_bedrooms 컬럼에서 207개의 결측값이 확인 되었다. 이 값을 모두 날리기 위해서 .dropna() 함수를 통해서 결측값을 제거한다.

df = df.dropna(axis = 0)
print(df.isnull().sum())

longitude             0
latitude              0
housing_median_age    0
total_rooms           0
total_bedrooms        0
population            0
households            0
median_income         0
median_house_value    0
ocean_proximity       0
dtype: int64

현재 위 isnull 결과와 같이 결측값이 모두 삭제 된것을 확인 하루 수 있으며, 전체 데이터의 갯수를 확인하기 위해서 len() 함수를 통해 확인하였다.

print(len(df)) # 전체 : 20433

전체 행 갯수는 20433개로 확인되었으며 아래와 같이 70%로 나누기 위해서 전체 행 * 0.7을 통해서 70%의 행을 계산했다.

print(len(df) * 0.7) # 70% 행 : 14303.09999999

70% 행을 슬라이싱 하기 위해서 iloc을 통해 14303개의 행만 따로 분리 후 quantile을 통해서 1분위수를 산출한다.

df = df.iloc[:14303, :]
print(int(df['housing_median_age'].quantile(0.25))) # 19

답 : 19

작업형 1유형 문제 2

4개년도 (2000, 2006, 2012, 2021)에 대한 국가별 기아의 수치 데이터에서 2000년 전체 기아 수치의 평균을 구하고, 2000년 데이터를 대상으로 연산된 평균보다 큰 값을 갖는 국가의 수를 산출하시오

df = pd.read_csv("./bigdata_csvfile/global_hunger_data.csv")
display(df.head())

Entity	Code	Year	Global Hunger Index
0	Afghanistan	AFG	2000
1	Afghanistan	AFG	2006
2	Afghanistan	AFG	2012
3	Afghanistan	AFG	2021
4	Albania	ALB	2000

기아의 수치 데이터에서 2000년 전체 기아수치의 평균을 구하기 위해서 다음과 같이 조건식을 세운다.

조건식을 세우고 `Global Hunger Index` 컬럼의 평균을 계산한다.

cond = df['Year'] == 2000
hunger_avg = (df[cond]['Global Hunger Index'].mean())
print(hunger_avg) # 24.439285714285717

이 결과 24.439285714285717라는 수치가 나왔으며 이 값은 hunger_avg 변수에 저장한다.

평균을 구했기 때문에 2000년 이며 평균 수치보다 큰 국가의 갯수를 계산하기 위해서 다음과 같이 조건식 2개를 세운다.

cond1 = df['Year'] == 2000
cond2 = df['Global Hunger Index'] > hunger_avg

print(len(df[cond1 & cond2])) # 50

답 : 50

다른 풀이로는 다음과 같이 짤수 있다.

# 다른 답안
df = pd.read_csv("./bigdata_csvfile/global_hunger_data.csv")
df.sort_values('Year', ascending = True, inplace = True)
data_2000 = df.loc[df['Year'] == 2000]
mean = data_2000['Global Hunger Index'].mean()
# print(mean)
result = data_2000['Entity'].loc[data_2000['Global Hunger Index'] > mean].size
print(result)

작업형 1유형 문제 3

주어진 데이터의 컬럼별로 결측값들의 비율을 확인하여 결측값의 비율이 가장 높은 변수명을 출력하시오

df = pd.read_csv("./bigdata_csvfile/titanic.csv")
display(df.head())

PassengerId	Survived	Pclass	Name	Sex	Age	SibSp	Parch	Ticket	Fare	Cabin	Embarked
0	1	0	3	Braund, Mr. Owen Harris	male	22.0	1	0	A/5 21171	7.2500	NaN
1	2	1	1	Cumings, Mrs. John Bradley (Florence Briggs Th...	female	38.0	1	0	PC 17599	71.2833	C85
2	3	1	3	Heikkinen, Miss. Laina	female	26.0	0	0	STON/O2. 3101282	7.9250	NaN
3	4	1	1	Futrelle, Mrs. Jacques Heath (Lily May Peel)	female	35.0	1	0	113803	53.1000	C123
4	5	0	3	Allen, Mr. William Henry	male	35.0	0	0	373450	8.0500	NaN

결측값을 확인하기 위해서 isnull() 함수를 사용했다.

print(df.isnull().sum())

PassengerId      0
Survived         0
Pclass           0
Name             0
Sex              0
Age            177
SibSp            0
Parch            0
Ticket           0
Fare             0
Cabin          687
Embarked         2
dtype: int64

print(df.info())

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 891 entries, 0 to 890
Data columns (total 12 columns):
 #   Column       Non-Null Count  Dtype  
---  ------       --------------  -----  
 0   PassengerId  891 non-null    int64  
 1   Survived     891 non-null    int64  
 2   Pclass       891 non-null    int64  
 3   Name         891 non-null    object 
 4   Sex          891 non-null    object 
 5   Age          714 non-null    float64
 6   SibSp        891 non-null    int64  
 7   Parch        891 non-null    int64  
 8   Ticket       891 non-null    object 
 9   Fare         891 non-null    float64
 10  Cabin        204 non-null    object 
 11  Embarked     889 non-null    object 
dtypes: float64(2), int64(5), object(5)
memory usage: 83.7+ KB
None

info의 갯수에서 총 891개의 행이 존재하며, cabin 컬럼에서는 687개의 결측값이 존재한다고 한다.

이러면 답은 Cabin 컬럼에서 결측값이 제일 많이 때문에 Cabin 컬럼이 정답이다.

age_data = (sum(df['Age'].isna()) / 891) * 100
print(age_data) # 19.865319865319865
cabin_data = (sum(df['Cabin'].isna()) / 891) * 100
print(cabin_data) # 77.10437710437711
embarked_data = (sum(df['Embarked'].isna()) / 891) * 100
print(embarked_data) # 0.22446689113355783

작업형 2유형

다음은 여행객 정보 데이터를 기반으로 여행보험 상품가입 여부(TravelInsurance)가 1일 확률을 예측하시오.

단, 평가지표는 roc_auc_score로 하고, 제출 파일의 컬름은 cust_id(인덱스 번호), Insurance(가입여부) 두 개만 존재해야 하며, 제출 파일 이름은 3rd_test_type2.csv로 한다.

train = test3_type2_train.csv
test = test3_type2_test.csv

먼저 train과 test 데이터를 불러온다.

import pandas as pd

train = pd.read_csv("./bigdata_csvfile/test3_type2_train.csv")
test = pd.read_csv("./bigdata_csvfile/test3_type2_test.csv")

기본적으로 EDA 를 진행하여, 결측값, 이상치 등을 모두 확인한다.

print(train.info())

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1490 entries, 0 to 1489
Data columns (total 10 columns):
 #   Column               Non-Null Count  Dtype 
---  ------               --------------  ----- 
 0   ID                   1490 non-null   int64 
 1   Age                  1490 non-null   int64 
 2   Employment Type      1490 non-null   object
 3   GraduateOrNot        1490 non-null   object
 4   AnnualIncome         1490 non-null   int64 
 5   FamilyMembers        1490 non-null   int64 
 6   ChronicDiseases      1490 non-null   int64 
 7   FrequentFlyer        1490 non-null   object
 8   EverTravelledAbroad  1490 non-null   object
 9   TravelInsurance      1490 non-null   int64 
dtypes: int64(6), object(4)
memory usage: 116.5+ KB
None

print(test.info())

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 497 entries, 0 to 496
Data columns (total 9 columns):
 #   Column               Non-Null Count  Dtype 
---  ------               --------------  ----- 
 0   ID                   497 non-null    int64 
 1   Age                  497 non-null    int64 
 2   Employment Type      497 non-null    object
 3   GraduateOrNot        497 non-null    object
 4   AnnualIncome         497 non-null    int64 
 5   FamilyMembers        497 non-null    int64 
 6   ChronicDiseases      497 non-null    int64 
 7   FrequentFlyer        497 non-null    object
 8   EverTravelledAbroad  497 non-null    object
dtypes: int64(5), object(4)
memory usage: 35.1+ KB
None

print(train.isnull().sum())

ID                     0
Age                    0
Employment Type        0
GraduateOrNot          0
AnnualIncome           0
FamilyMembers          0
ChronicDiseases        0
FrequentFlyer          0
EverTravelledAbroad    0
TravelInsurance        0
dtype: int64

print(test.isnull().sum())

ID                     0
Age                    0
Employment Type        0
GraduateOrNot          0
AnnualIncome           0
FamilyMembers          0
ChronicDiseases        0
FrequentFlyer          0
EverTravelledAbroad    0
dtype: int64

결측값도 이상이 없고, 다른 특이적인 EDA는 발견되지 않았기에 학습 준비를 시작한다. 문제에서도 주어졌듯이 `roc_auc_score`를 사용하라 했으며, 분류 확률을 예측하는 모델을 생성하는 것이다. 이 말은 즉슨, 분류를 사용하라는 것이다.

`train.info()` 결과에서 `object`타입으로 되어 있는 데이터들의 `value_counts`를 계산해 보았다.

cols = ["Employment Type", "GraduateOrNot", "FrequentFlyer", "EverTravelledAbroad"]
for col in cols :
    print(train[col].value_counts())

Employment Type
Private Sector/Self Employed    1061
Government Sector                429
Name: count, dtype: int64
GraduateOrNot
Yes    1262
No      228
Name: count, dtype: int64
FrequentFlyer
No     1185
Yes     305
Name: count, dtype: int64
EverTravelledAbroad
No     1207
Yes     283
Name: count, dtype: int64

각각의 컬럼에서는 0 또는 1로 분류될수 있는 데이터들로 이루어져있기 때문에 sklearn의 preprocessing의 LabelEncoder를 사용한다.

from sklearn.preprocessing import LabelEncoder

for col in cols :
    le = LabelEncoder()
    le.fit(train[col])
    train[col] = le.transform(train[col])

for col in cols :
    le = LabelEncoder()
    le.fit(test[col])
    test[col] = le.transform(test[col])

중요한 점은 train데이터에 라벨인코딩을 할 경우, test 데이터에도 동일하게 라벨인코딩을 진행해주어야한다.

이부분에서 잘못됐다. train과 test를 합치고 라벨인코딩하고 다시 합쳤어야했다고 한다.

그리고 종속변수와 독립변수를 나눈다.

from sklearn.model_selection import train_test_split
X = train.drop(columns = ["TravelInsurance"])
y = train['TravelInsurance']

train_test_split 함수를 통해서 X_train, X_test, y_train, y_test를 나누고, RandomForestClassifier을 통해서 분류를 진행한다.

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 123)
print(X_train.shape, X_test.shape, y_train.shape, y_test. shape)
from sklearn.ensemble import RandomForestClassifier
rfc = RandomForestClassifier(n_estimators = 200, max_depth = 25, random_state = 123)
rfc.fit(X_train, y_train)
pred = rfc.predict_proba(X_test)[:, 1]
from sklearn.metrics import roc_auc_score
roc = roc_auc_score(y_test, pred)
print(roc)

(1192, 9) (298, 9) (1192,) (298,)
0.8137515644555694

81%라는 높은 정확도를 가지고 있으며, 여기서 중요한점은 1일 확률을 계산하라 했기 때문에 `predict_proba`를 통해서 예측하였다.

이때 진짜 중요한점은 `predict(X_test)`와 달리 `predict_proba(X_test)[:, 1]`이 되어야 한다.

그 이유는 `predict_proba`는 이딴식으로 되어 있기 때문,,, 아마 0일 확률을 계산하라 했으면 `[:, 0]` 이 되어야 할것이다.

array([[0.875     , 0.125     ],
       [0.71      , 0.29      ],
       [0.89      , 0.11      ],
       [0.9       , 0.1       ],
       [0.69      , 0.31      ],
       [0.82      , 0.18      ],

pred = rfc.predict_proba(test)[:, 1]
pd.DataFrame(
    {
        'cust_id' : test.index,
        'insurance' : pred
    }
).to_csv("3rd_test_type2.csv", index = False)

print(pd.read_csv("3rd_test_type2.csv").head())

   cust_id  insurance
0        0      0.240
1        1      0.260
2        2      0.345
3        3      0.135
4        4      0.415

train데이터로 진행을 했으니 test데이터로 마지막 과정을 진행한다.

test.index 메모.

[빅데이터분석기사] 실기 대비 2일차 - 기출문제 2회

pental — Mon, 3 Nov 2025 15:17:49 +0900

본 내용은 빅데이터분석기사-2차실기 / 장은진 교수님의 강의를 듣고 개인적으로 추가 공부가 필요한 내용에 대해서 정리한 글입니다.

작업형 1유형 문제 1번

주어진 Dataset에서 'CRIM' 값이 가장 큰 10개의 지역을 구하고 10개의 지역의 'CRIM' 값을 그 중 가장 작은 값으로 대체한 후, 'AGE' 컬럼 값이 80이상인 행의 'CRIM' 평균을 구하시오 (단, 출력 결과는 정수형으로 한다.)

import pandas as pd
df = pd.read_csv("./bigdata_csvfile/boston_housing_data.csv")
df

데이터는 총 506개의 행, 14개의 열로 이루어져있다.

문제에서는 CRIM 값이 가장 큰 10개의 지역을 구하라고 했기에 sort_values 함수를 이용해서 내림차순 정렬을 진행했다. (내림차순의 경우 ascending = False 옵션을 통해 진행한다.)

df.sort_values("CRIM", ascending = False, inplace = True)

정렬 결과를 df 자체에 결과하기 위해서 inplace = True 옵션을 통해서 df에 바로 반영되도록 했다.

10개의 지역이 뽑혔기 때문에, 이 중 CRIM 값이 제일 작은것은 9번 인덱스에 있는 행일 것이다. 그에 따라 iloc[9]을 통해서 최소 CRIM을 따로 변수에 저장한다.

min_crim = df.iloc[9]['CRIM']

그리고 이 최소 CRIM 값을 가장 큰 10개의 지역에 모두 대체해야 하기 때문에 다음과 같이 iloc를 통해서 min_crim으로 대체했다. [:10, 0] 을 사용한 이유는 10개까지의 행에 대해서 0번 컬럼(CRIM)의 값을 min_crim 으로 대체한다는 것이다.

df.iloc[:10, 0] = min_crim
result = df.loc[df['AGE'] >= 80, 'CRIM'].mean()
print(int(result))

답 : 5

작업형 1유형 문제 2번

주어진 Dataset에서 첫번째 행 부터 순서대로 80% 까지의 데이터를 추출 후'total_bedrooms' 컬럼의 중앙값으로 해당 컬럼의 중앙값으로 행당 컬럼의 결측치를 대체하고 'total_bedrooms' 컬럼의 대치 전후의 표준편차 차이를 구하시오

df = pd.read_csv("./bigdata_csvfile/california_housing.csv")
df.head()

먼저 데이터를 불러오고 어떻게 생겼는지 확인한다. 일단 80%의 데이터를 추출해야하기 때문에 전체 행의 갯수에서 0.8을 통해서 자를 위치를 구했다.

len(df) * 0.8 # 16512.0
df = df.iloc[:16512, :]

df.iloc를 통해서 전체 열에 대해서 16512행까지의 결과를 df에 저장한다.

std1 = df['total_bedrooms'].std()
median = df['total_bedrooms'].median()

그리고나서 표준편차와 중앙값을 구하기 위해서 .std(), .median() 을 사용했다.

df['total_bedrooms'] = df['total_bedrooms'].fillna(median)

구한 median 값을 결측값에 대치하기 위해서 .fillna()를 통해서 결측값을 중앙값으로 모두 넣어주었다. 그리고 결측값을 처리 후 표준편차를 비교하기 위해서 동일하게 .std()를 사용해서 표준편차를 계산한다.

std2 = df['total_bedrooms'].std()

위에서 구해놓은 std1과 std2의 차를 계산한다.

print(std1 - std2)

답 : 1.975147291645726

작업형 1유형 문제 3번

주어진 데이터의 population 컬럼의 평균으로부터 1.5x표준편차를 벗어나는 영역을 이상치라 판단하고 이상치들의 합을 구하시오. (단, 출력 결과는 정수형태로 하고 이상치는 '평균 - 1.5x표준편차 미만' 또는 '평균 + 1.5x표준편차 초과' 로 연산한다.)

데이터를 먼저 확인한다.

df = pd.read_csv("./bigdata_csvfile/california_housing.csv")
df.head()

std = df['population'].std()
mean = df['population'].mean()
print(std, mean) # np.float64(1132.462121765341), np.float64(1425.4767441860465)

표준편차를 계산하기 위해서 df[’population’].std()를 통해서 표준편차를 계산했고, 평균을 구하기 위해서는 .mean() 함수를 사용했다.

lower = mean - 1.5 * std
upper = mean + 1.5 * std

print(lower, upper) # -273.2164384619648 3124.169926834058

원래는 비슷한 유형으로 IQR 이상치 계산이 나오는걸로 기억하는데, 이 문제는 특이하게도 평균 - 1.5*표준편차 식으로 계산하라고 되어 있다. 따라서 lower와 upper 변수를 생성하여 이상치의 범위를 미리 계산해두었다.

cond1 = df['population'] < lower
cond2 = df['population'] > upper

계산 해둔 결과르 바탕으로 조건식을 세운다. 평균 +- 1.5 * 표준편차의 조건을 총 2개를 세웠다.

print(int(df[cond1 | cond2]['population'].sum())) # 5607295

위와 같이 `OR` 연산일 경우는 `|` 를 쓴다.

다른 방법으로 조건 계산하는 식이 있지만 나는 별로 좋아하는 방법은 아니다.

# 다른 방법 조건 계산
result = df['population'].loc[(df['population'] > upper) | (df['population'] < lower)].sum()
print(int(result)) # 5607295

답만 잘 나오면 장땡 아닌교~

답 : 5607295

작업형 2유형

주어진 E-Commerce_Shipping 데이터를 사용해서 고객이 주문한 물품의 제시간 도착여부(Reached.on.Time_Y.N)를 예측하는 분류 모델을 생성하여 결과를 제출하시오.
단, 평가기준은 roc_auc_score이고, 제출 형태는 'cust_id' : id, 'reached_ontime' : value로 하며, 제출 파일 이름은 2nd_test_type2.csv로 한다.
단, 학습데이터와 테스트 데이터는 각각 10000개, 999개로 나눈다.

df = pd.read_csv("./bigdata_csvfile/E-Commerce_Shipping.csv")
display(df.head())

이제 데이터를 읽어오는건 너무나 당연하게 쉬워진것 같다. 근데 구분자가 | ,- ,# 등으로 나오면 데이터 읽는 것부터 난이도 떡상~

print(df.info())

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 10999 entries, 0 to 10998
Data columns (total 12 columns):
 #   Column               Non-Null Count  Dtype 
---  ------               --------------  ----- 
 0   ID                   10999 non-null  int64 
 1   Warehouse_block      10999 non-null  object
 2   Mode_of_Shipment     10999 non-null  object
 3   Customer_care_calls  10999 non-null  int64 
 4   Customer_rating      10999 non-null  int64 
 5   Cost_of_the_Product  10999 non-null  int64 
 6   Prior_purchases      10999 non-null  int64 
 7   Product_importance   10999 non-null  object
 8   Gender               10999 non-null  object
 9   Discount_offered     10999 non-null  int64 
 10  Weight_in_gms        10999 non-null  int64 
 11  Reached.on.Time_Y.N  10999 non-null  int64 
dtypes: int64(8), object(4)
memory usage: 1.0+ MB

먼저 10999개로 모두 동일 한것을 확인해보니 결측값은 없는것으로 확인된다. 단 4개의 컬럼에서 Dtype에 object로 되어 있는 것으로 보아 날리던지 One-Hot-Encoding을 하던지 고민해야하는 부분이다.

df.isnull().sum()

ID                     0
Warehouse_block        0
Mode_of_Shipment       0
Customer_care_calls    0
Customer_rating        0
Cost_of_the_Product    0
Prior_purchases        0
Product_importance     0
Gender                 0
Discount_offered       0
Weight_in_gms          0
Reached.on.Time_Y.N    0
dtype: int64

혹시라도 결측값이 있는지에 대해서 확인해보려고 `df.isnull().sum()`을 사용했으며 위 결과와 같이 결측값은 존재하지 않는다.

문제에서 분류라고 딱 줬는데, 이렇게 주는 경우는 드물다고 한다. 평가 지표를 바탕으로 분류인지 회귀인지 구별할 수 있다고 한다.

RMSE, MSE, F2 → 회귀 문제, ROC, ACC → 분류 문제

df['Reached.on.Time_Y.N'].value_counts()

Reached.on.Time_Y.N
1    6563
0    4436
Name: count, dtype: int64

일단 분류를 총 몇가지로 해야하는지 확인하기 위해서 `.value_counts()`를 사용하였다.

분류로 도출해야하는 종류는 0 또는 1로 딱 떨어지는 분류문제이다.

일단 위에서 확인했던 `object` 타입에 대해서는 라벨 인코딩을 진행해야한다. 그 이유는 다음과 같다.

columns = ['Warehouse_block', 'Mode_of_Shipment', 'Product_importance', 'Gender']
for col in columns :
    print(df[col].value_counts())
    
Warehouse_block
F    3666
D    1834
A    1833
B    1833
C    1833
Name: count, dtype: int64
Mode_of_Shipment
Ship      7462
Flight    1777
Road      1760
Name: count, dtype: int64
Product_importance
low       5297
medium    4754
high       948
Name: count, dtype: int64
Gender
F    5545
M    5454
Name: count, dtype: int64

각각 단순히 2 ~ 5개 정도의 값만 반복되기 때문에 라벨인코딩을 진행하면 좋을것 같다고 판단해서 라벨인코딩을 진행한다.

from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()

columns = ['Warehouse_block', 'Mode_of_Shipment', 'Product_importance', 'Gender']

for col in columns :
    le.fit(df[col])
    df[col] = le.transform(df[col])

print(df.info())

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 10999 entries, 0 to 10998
Data columns (total 12 columns):
 #   Column               Non-Null Count  Dtype
---  ------               --------------  -----
 0   ID                   10999 non-null  int64
 1   Warehouse_block      10999 non-null  int64
 2   Mode_of_Shipment     10999 non-null  int64
 3   Customer_care_calls  10999 non-null  int64
 4   Customer_rating      10999 non-null  int64
 5   Cost_of_the_Product  10999 non-null  int64
 6   Prior_purchases      10999 non-null  int64
 7   Product_importance   10999 non-null  int64
 8   Gender               10999 non-null  int64
 9   Discount_offered     10999 non-null  int64
 10  Weight_in_gms        10999 non-null  int64
 11  Reached.on.Time_Y.N  10999 non-null  int64
dtypes: int64(12)
memory usage: 1.0 MB

`pd.get_dummies()`와 뭐가 다른지도 확인이 필요하다. (TODO)

일단 전처리가 완료 되었으면, 문제 지문과 같이 `train`과 `test` 데이터를 각각 10000, 999개로 나눈다.

train = df.iloc[0:10000]
test = df.iloc[10000:10999]

from sklearn.model_selection import train_test_split
X = train.drop(columns = ['ID', 'Reached.on.Time_Y.N'])
y = train['Reached.on.Time_Y.N']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 123)

또한 `train_test_split`을 통해서 `X_train`, `X_test`, `y_train`, `y_test`를 각각 나누어 주었다.

X의 경우는 독립변수로써, 우리가 구해야하는 `Reached.on.Time_Y.N`을 뺀 모든 컬럼이다. (ID는 학습에 도움이 되지 않으니 뺐다.)

y의 경우는 종속변수로써, 우리가 구해야하는 `Reached.on.Time_Y.N`만 가지고 있는다.

from sklearn.ensemble import RandomForestClassifier

rfc = RandomForestClassifier(n_estimators = 170, max_depth = 30, random_state = 123)
rfc.fit(X_train, y_train)
pred = rfc.predict(X_test)

from sklearn.metrics import roc_auc_score, accuracy_score
roc = roc_auc_score(y_test, pred)
acc = accuracy_score(y_test, pred)
print(roc)
print(acc)

당연하게 `RandomForest`를 사용한다. (근데 오탈자 주의해야한다. 가끔씩 오탈자가 발생하는것 같다.) 이문제는 분류 문제이기 때문에 `RandomForestClassifier`을 사용했다.

또한 문제에서는 성능평가 지표로 `roc_auc_score`를 사용하라 했기에 `roc_auc_score`도 출력하고 정확도도 궁금하기 때문에 `accuracy_score`도 `import`해서 출력해봤다.

근데 지금 `n_estimators`가 170, `max_depth`가 30으로 줬을때 `roc`와 `acc`의 값는 각각 0.680, 0.681이다.

from sklearn.ensemble import RandomForestClassifier

rfc = RandomForestClassifier(random_state = 123)
rfc.fit(X_train, y_train)
pred = rfc.predict(X_test)

from sklearn.metrics import roc_auc_score, accuracy_score
roc = roc_auc_score(y_test, pred)
acc = accuracy_score(y_test, pred)
print(roc)
print(acc)

랜덤포레스트에 `하이퍼파라미터` 튜닝을 하지 않고 그냥 돌렸을때의 `roc`와 `acc`의 값은 0.684, 0.683이다. (이러면 하이퍼파라미터 튜닝을 하지 않는게 더 좋은거 아닌가?)

여기서 마치는게 아니라 이게 테스트 데이터에 대해서도 예측을 진행하고 저장까지 해야한다.

test_data_X = test.drop(columns = ['ID', 'Reached.on.Time_Y.N'])
test_data_y = test['Reached.on.Time_Y.N']
pred2 = rfc.predict(test_data_X)

따라서 test데이터에서 위에서 진행했던 train_test_split 전 종속, 독립 변수를 나눈것처럼 test에서도 동일하게 ID와 Reach.on.Time_Y.N을 날려준다. 그리고 기존에 생성해준 모델을 이용해서 test_data_X를 예측한다. 이때 예측에 사용되는 독립변수는 ID, Reach.on.Time.Y_N을 제외한 모든 데이터이다.

result = pd.DataFrame(
    {
        'ID' : test['ID'],
        'reached_ontime' : pred2
    }
)
result.to_csv("2nd_test_type2.csv", index = False)
print(pd.read_csv('2nd_test_type2.csv').head())

      ID  reached_ontime
0  10001               1
1  10002               0
2  10003               0
3  10004               1
4  10005               0

결과를 저장할때, ID도 포함해서 CSV를 생성하라 했기 때문에 `test[’ID’]`를 그대로 가져와서 사용했다. 다른 문제에서도 몇번 보이던 패턴이었고, 대체적으로 `pred` 열로 생성하라 하는데 이 문제는 특이하게도 `reached_ontime`의 이름으로 열을 생성하라 했다.

또한 `result.csv` 가 아닌 `2nd_test_type2.csv`로 저장하는것도 조금 특이한 부분이라 생각된다.

즉, 문제를 제대로 확인해야 한다는 생각이 든다.

추가 공부해야하는 것

1. 이 문제를 풀면서 생각된 것은 원핫인코딩과 라벨인코딩이 뭐가 다른것인지?
2. sklearn.preprocessing.LabelEncoder과 pandas.get_dummies가 무엇이 다른지?
3. 문제를 제대로 읽고 회귀인지 분류인지 파악하기
4. RMSE, MSE, F1, ACC, ROC 를 통해서 회귀인지 분류인지 파악할수 있다.
5. 만약 그래도 모르겠다 싶으면 종속변수를 .value_counts를 통해서 1~4개 등으로 나타나는지 아니면 각각 다 다른값인지를 확인하면 회귀인지 분류인지 확인 할 수 있다.
6. 학습데이터로 예측만하고 그 데이터를 그대로 제출하지 말고 test 데이터에 대해서 예측하고 결과 저장하고 확인까지 하기

[빅데이터분석기사] 실기 대비 1일차 - 모의고사

pental — Mon, 3 Nov 2025 10:58:15 +0900

본 내용은 빅데이터분석기사-2차실기 / 장은진 교수님의 강의를 듣고 개인적으로 추가 공부가 필요한 내용에 대해서 정리한 글입니다.

작업형 1유형 1번 문제

문제에 대한 정의는 따로 되어 있지 않았음, 단 코드상으로 예측한 문제는 다음과 같다.해당 정보를 바탕으로 사망자가 제일 많은 도시의 사망자와, 사망자가 뒤에서 5번째로 많은 도시의 사망자의 차이를 구하시오

import pandas as pd
import numpy as np
df = pd.read_csv("./bigdata_csvfile/covid_death_bycountry.csv")
display(df.head())

print(df.info())

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 217 entries, 0 to 216
Data columns (total 3 columns):
 #   Column   Non-Null Count  Dtype 
---  ------   --------------  ----- 
 0   Country  217 non-null    object
 1   Deaths   217 non-null    object
 2   Cases    217 non-null    int64 
dtypes: int64(1), object(2)
memory usage: 5.2+ KB
None

사실 데이터의 마지막 부분에는 아래와 같이 “-” 으로 되어 있는 부분이 있다.
해당 부분 때문에 info의 Deaths의 타입이 object로 나타나고 있다.따라서 해당 부분을 교체하고, 정수형으로 변경하기 위해서 다음과 같이 작업한다.

import pandas as pd
import numpy as np
df = pd.read_csv("./bigdata_csvfile/covid_death_bycountry.csv")
display(df.head())

df['Deaths'] = df['Deaths'].str.replace('—', '0')
df['Deaths'] = df['Deaths'].astype(int)
print(df.info())

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 217 entries, 0 to 216
Data columns (total 3 columns):
 #   Column   Non-Null Count  Dtype 
---  ------   --------------  ----- 
 0   Country  217 non-null    object
 1   Deaths   217 non-null    int64 
 2   Cases    217 non-null    int64 
dtypes: int64(2), object(1)
memory usage: 5.2+ KB
None

그 후 사망자가 제일 많은 순으로 정렬하기 위해서 df의 기본 함수인 sort_values를 사용하였다.

df = df.sort_values('Deaths', ascending = False)

또한 최소 최대의 경우 sort_values를 통해서 이미 최소, 최대가 구해졌기 때문에 iloc을 통해서 첫번째 행과, -5번째 행의 결과를 가져온다. 이때 df[’Deaths’]에서 바로 iloc를 사용하면 값만 가져와 진다.

max = df['Deaths'].iloc[0]
min = df['Deaths'].iloc[-5]

result = max - min
print(result)

답 : 1110232

작업형 1유형 2번 문제

다음은 2000년부터 2022년까지 국내의 지역별 출생률, 사망률, 이혼률, 혼인률, 자연 성장률에 대한 데이터이다.
2008년 7월 1일 데이터 중 출생률이 가장 높은 지역의 이름을 출력하시오.
(단, 결측값이 포함된 경우 결측값은 해당 컬럼의 중앙값으로 대체한다.)

df = pd.read_csv("./bigdata_csvfile/Korean_demographics_2000-2022.csv")

df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 4860 entries, 0 to 4859
Data columns (total 12 columns):
 #   Column               Non-Null Count  Dtype  
---  ------               --------------  -----  
 0   Date                 4860 non-null   object 
 1   Region               4860 non-null   object 
 2   Birth                4716 non-null   float64
 3   Birth_rate           4709 non-null   float64
 4   Death                4716 non-null   float64
 5   Death_rate           4709 non-null   float64
 6   Divorce              4716 non-null   float64
 7   Divorce_rate         4709 non-null   float64
 8   Marriage             4716 non-null   float64
 9   Marriage_rate        4709 non-null   float64
 10  Natural_growth       4716 non-null   float64
 11  Natural_growth_rate  4709 non-null   float64
dtypes: float64(10), object(2)
memory usage: 455.8+ KB

print(df.isnull().sum())

Date                     0
Region                   0
Birth                  144
Birth_rate             151
Death                  144
Death_rate             151
Divorce                144
Divorce_rate           151
Marriage               144
Marriage_rate          151
Natural_growth         144
Natural_growth_rate    151
dtype: int64

결측값이 상당수 존재하는 것을 확인 할 수 있으며, 먼저 Date의 데이터 타입이 object로 되어 있기 때문에 해당 값을 pandas의 기본 함수인 to_datetime 을 통해서 Date 의 데이터 타입을 변경한다.

df['Date'] = pd.to_datetime(df['Date'])
print(df.info())

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 4860 entries, 0 to 4859
Data columns (total 12 columns):
 #   Column               Non-Null Count  Dtype         
---  ------               --------------  -----         
 0   Date                 4860 non-null   datetime64[ns]
 1   Region               4860 non-null   object        
 2   Birth                4716 non-null   float64       
 3   Birth_rate           4709 non-null   float64       
 4   Death                4716 non-null   float64       
 5   Death_rate           4709 non-null   float64       
 6   Divorce              4716 non-null   float64       
 7   Divorce_rate         4709 non-null   float64       
 8   Marriage             4716 non-null   float64       
 9   Marriage_rate        4709 non-null   float64       
 10  Natural_growth       4716 non-null   float64       
 11  Natural_growth_rate  4709 non-null   float64       
dtypes: datetime64[ns](1), float64(10), object(1)
memory usage: 455.8+ KB

birth_rate부분에 결측값이 있기 때문에, 해당 값은 그 컬럼의 중앙값으로 채우라고 했기 때문에 median()을 통해서 중앙값으로 채워준다.

df['Birth_rate'].fillna(df['Birth_rate'].median(), inplace = True)

이후 cond라는 변수를 생성해 df[’Date’] == ‘2008-07-01’ 의 조건을 추가하고 df2에 저장했다.

cond1 = df['Date'] == '2008-07-01'
print(len(df[cond1]))
display(df[cond1].head(5))
df2 = df[cond1]

df2를 sort_values 기능을 통해서 Birth_rate를 기준으로 내림차순 정렬 후 iloc을 통해서 도시 이름을 출력한다.

df2 = df2.sort_values('Birth_rate', ascending = False)
display(df2.head())
print(df2['Region'].iloc[0])

답 : Gyeonggi-do

작업형 1유형 3번 문제

주어진 수면 데이터에서 수면시간(Sleep Duration) 컬럼과 가장 높은 상관계수를 갖는 변수의 최빈값을 출력하시오.
(단, Blood pressure 컬럼과 Sleep Disorder 컬럼은 분석에서 제외한다.)

df = pd.read_csv("./bigdata_csvfile/Sleep_health_and_lifestyle_dataset.csv")
df = df.drop(columns = ['Blood Pressure', 'Sleep Disorder'])

one_hot_data = pd.get_dummies(df[['Gender', 'Occupation', 'BMI Category']])
df = pd.concat([df, one_hot_data], axis = 1)
df = df.drop(columns=['Gender', 'Occupation', 'BMI Category'])
print(df.info())

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 374 entries, 0 to 373
Data columns (total 25 columns):
 #   Column                           Non-Null Count  Dtype  
---  ------                           --------------  -----  
 0   Person ID                        374 non-null    int64  
 1   Age                              374 non-null    int64  
 2   Sleep Duration                   374 non-null    float64
 3   Quality of Sleep                 374 non-null    int64  
 4   Physical Activity Level          374 non-null    int64  
 5   Stress Level                     374 non-null    int64  
 6   Heart Rate                       374 non-null    int64  
 7   Daily Steps                      374 non-null    int64  
 8   Gender_Female                    374 non-null    bool   
 9   Gender_Male                      374 non-null    bool   
 10  Occupation_Accountant            374 non-null    bool   
 11  Occupation_Doctor                374 non-null    bool   
 12  Occupation_Engineer              374 non-null    bool   
 13  Occupation_Lawyer                374 non-null    bool   
 14  Occupation_Manager               374 non-null    bool   
 15  Occupation_Nurse                 374 non-null    bool   
 16  Occupation_Sales Representative  374 non-null    bool   
 17  Occupation_Salesperson           374 non-null    bool   
 18  Occupation_Scientist             374 non-null    bool   
 19  Occupation_Software Engineer     374 non-null    bool   
...
 24  BMI Category_Overweight          374 non-null    bool   
dtypes: bool(17), float64(1), int64(7)
memory usage: 29.7 KB

먼저 불필요한 열 Blood_pressure, Sleep Disorder 열을 삭제해주고, one_hot 인코딩을 진행했다.
그 후 concat으로 원핫인코딩된 데이터와 기존 데이터프레임을 합쳐주고, 원핫인코딩 전 데이터의 열을 삭제한다.
그 후 상관 계수를 구하기 위해서 다음과 같이 작성한다.

corr = df.corr()
print(corr)

Sleep Duration 컬럼과 가장 큰 상관 관계를 가지는 컬럼은 Quality of Sleep 이기 때문에 해당 값의 최빈 값을 가음과 같이 출력한다.

result = df['Quality of Sleep'].mode()[0]
print(result)

답 : 8

작업형 2유형

다음은 중고차 가격 관련 데이터셋이다. 다음과 같은 주의사항을 확인하고, 결과를 제출하도록 한다. used_cars_price_data.csv 전체 데이터 목록 4009행 중 3800행을 학습용 데이터로 사용하고, 나머지를 테스트 데이터로 사용할 수 있도록 데이터를 슬라이싱한다. 학습용 데이터를 활용하여 예측 모델을 모델링 하고, 테스트 데이터를 적용하여 목표변수(price)를 예측하고, 예측 결과를 제출한다. 모델 평가지표는 RMSE로 한다. 모델 예측 결과는 price 컬럼을 갖고, 예측 결과를 나타내며, index는 표시하지 않는다. 모델 예측 결과 파일명은 다음과 같이 하여 제출한다. (파일명 : result.csv)

df = pd.read_csv("./bigdata_csvfile/used_cars_price_data.csv")

전처리가 필요함. df.isnull().sum()에서 이상치가 있는 컬럼이 3개 있었고, 그 3개의 컬럼에 대해서 결측값을 최빈 값으로 fillna 함

df['fuel_type'].fillna(df['fuel_type'].mode()[0], inplace = True)
df['accident'].fillna(df['accident'].mode()[0], inplace = True)
df['clean_title'].fillna(df['clean_title'].mode()[0], inplace = True)

price 부분에서는 $ / , 와 같은 특수문자가 있기 때문에 str.replace를 이용해서 모두 변경한다.

df['price'] = df['price'].str.replace("$", "")
df['price'] = df['price'].str.replace(",", "")
df['price'] = df['price'].astype(int)

그리고 info를 통해서 확인 한 경우 모두 잘 나온것을 확인 할 수 있다.

df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 4009 entries, 0 to 4008
Data columns (total 12 columns):
 #   Column        Non-Null Count  Dtype 
---  ------        --------------  ----- 
 0   brand         4009 non-null   object
 1   model         4009 non-null   object
 2   model_year    4009 non-null   int64 
 3   milage        4009 non-null   object
 4   fuel_type     4009 non-null   object
 5   engine        4009 non-null   object
 6   transmission  4009 non-null   object
 7   ext_col       4009 non-null   object
 8   int_col       4009 non-null   object
 9   accident      4009 non-null   object
 10  clean_title   4009 non-null   object
 11  price         4009 non-null   int64 
dtypes: int64(2), object(10)
memory usage: 376.0+ KB

나머지 열에 대해서는 LabelEncoder를 돌면서 라벨인코딩을 진행한다.

from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()

columns = ['brand', 'model', 'milage', 'fuel_type', 'engine', 'transmission', 'ext_col', 'int_col', 'accident', 'clean_title']

for col in columns :
    le.fit(df[col])
    df[col] = le.transform(df[col])

라벨인코딩을 하고, train과 test를 나누었다.

train = df.iloc[:3800, :]
test = df.iloc[-209:, :]

sklearn.model_selection의 train_test_split을 통해서 X_train, X_test, y_train. y_test를 나눈다.

from sklearn.model_selection import train_test_split
X = train.drop(columns = 'price') # 독립변수
y = train['price'] # 종속변수

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 123)
X_train.shape, X_test.shape, y_train.shape, y_test.shape

((3040, 11), (760, 11), (3040,), (760,))

마법의 랜덤포렌스트회귀를 통해서 차량 가격에 대해서 예측한다.

from sklearn.ensemble import RandomForestRegressor
rfr = RandomForestRegressor(n_estimators = 150, max_depth = 20, random_state = 123)
rfr.fit(X_train, y_train)
pred = rfr.predict(X_test)

평가지표의 경우 rmse를 통해서 구했기 때문에 root_mean_squared_error을 통해서 rmse를 계산한다.

from sklearn.metrics import root_mean_squared_error
rmse = root_mean_squared_error(y_test, pred)
print('rmse', rmse)

rmse 38204.54661207414

마지막 제출읠 경우는 test에서 price 열을 날리고, 테스트 데이터에 대해서 예측한다.

test_X_data = test.drop(columns = 'price')
pred2 = rfr.predict(test_X_data)

pd.DataFrame({'pred' : pred2}).to_csv("result.csv", index = False)
print(pd.read_csv("result.csv").head())

작업형 3유형 1번 문제

제공되는 심혈관 질환 데이터를 활용하여 심혈관 질환 발생 여부(cardio)를 예측하고자한다.
각문항의 답을 제출형식에 맞게 제출하시오
data = cardiovascular_heart_disease_data.csv

1. alco, cardio 변수 간의 독립성 검정을 실시할 때, 카이제곱 통계량을 구하시오.
2. gender, weight, smoke, cholesterol을 독립변수로 사용하여 로지스틱 회귀모형으로 분석할 때, smoke 변수의 계수 값을 구하시오
3. 2번 문제에서 생성한 로지스틱 회귀모형에서 gender 변수가 한 단위 증가할 때 심혈관 질환이 발생할 오즈비의 값을 구하시오,
(단, 모든 문제의 정답은 반올림하여 소수점 네 자리까지 출력한다)

df = pd.read_csv("./bigdata_csvfile/cardiovascular_heart_disease_data.csv")
display(df)
print(df.info())

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 70000 entries, 0 to 69999
Data columns (total 14 columns):
 #   Column       Non-Null Count  Dtype  
---  ------       --------------  -----  
 0   index        70000 non-null  int64  
 1   id           70000 non-null  int64  
 2   age          70000 non-null  int64  
 3   gender       70000 non-null  int64  
 4   height       70000 non-null  int64  
 5   weight       70000 non-null  float64
 6   ap_hi        70000 non-null  int64  
 7   ap_lo        70000 non-null  int64  
 8   cholesterol  70000 non-null  int64  
 9   gluc         70000 non-null  int64  
 10  smoke        70000 non-null  int64  
 11  alco         70000 non-null  int64  
 12  active       70000 non-null  int64  
 13  cardio       70000 non-null  int64  
dtypes: float64(1), int64(13)
memory usage: 7.5 MB
None

1. alco, cardio 변수 간의 독립성 검정을 실시할 때, 카이제곱 통계량을 구하시오.
카이제곱이 나온다? → 무조건 scipy.stats의 chi2_contingency 사용하기

from scipy.stats import chi2_contingency
data = pd.crosstab(df.alco, df.cardio)
print(data)

cardio      0      1
alco                
0       33080  33156
1        1941   1823

카이 제곱 통계량 수행하기

chi2, p_value, dof, exp = chi2_contingency(data)
print(round(chi2, 4))

답 : 3.6965

gender, weight, smoke, cholesterol을 독립변수로 사용하여 로지스틱 회귀모형으로 분석할 때, smoke 변수의 계수 값을 구하시오

이렇게 있으면 일단 로지스틱 회귀모형으로 분석하는거고 여기선 from statsmodels.formula.api import logit 사용하기

그리고 회귀식 작성할때, ~, + 잘 확인하기, 즉 여기서는 cardio를 0 또는 1로 분석하는데, cardio가 **종속변수** 그 외 gender, weight, smoke, cholesterol을 독립변수로 사용하기에 + 붙여서 식 세우기

from statsmodels.formula.api import logit
result = logit('cardio ~ gender + weight + smoke + cholesterol', data = df).fit().params

Optimization terminated successfully.
         Current function value: 0.654936
         Iterations 5
         
print(round(result.smoke, 4))

답 : -0.2174

2번 문제에서 생성한 로지스틱 회귀모형에서 gender 변수가 한 단위 증가할 때 심혈관 질환이 발생할 오즈비의 값을 구하시오,

이 경우 np.exp 사용하기 → np.exp(result)

answer = np.exp(result)
print(round(answer.gender, 4))

답 : 1.0002

사실 3번 문제는 잘 이해가 안됨, 조금더 추가 공부 필요

작업형 3유형 2번 문제

제공되는 심장 질환 데이터를 활용하여 심장질환 발생 여부(target)를 예측하고자 한다. 각 문항의 답을 제출형식에 맞게 제출하시오. data = pd.read_csv("heart_disease_data.csv")

독립변수를 exang, trestbps, ca로 하고, 목표변수를 target으로 하는 로지스틱 회귀분석을 진행했을 때, ca변수의 표준오차를 구하시오.
fbs, thalach, chol, sex를 독립변수로 target을 분류하는 로지스틱 회귀분석 모형을 생성했을때, 학습(train) 데이터의 오분류율을 구하시오. (단, 전체 데이터 중 800행을 학습(train) 데이터로 사용하고, train_test_split의 test_size는 0.2로 하며, random_state는 123으로 한다.)
2번 문제 모델의 심장질환 발생(1)에 대한 정밀도를 구하시오. (단, 모든 문제의 정답은 반올림하여 소수점 두 번째 자리까지 출력한다.)

독립변수를 exang, trestbps, ca로 하고, 목표변수를 target으로 하는 로지스틱 회귀분석을 진행했을 때, ca변수의 표준오차를 구하시오.

df = pd.read_csv("./bigdata_csvfile/heart_disease_data.csv")
print(df.info())
display(df.head())

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1025 entries, 0 to 1024
Data columns (total 14 columns):
 #   Column    Non-Null Count  Dtype  
---  ------    --------------  -----  
 0   age       1025 non-null   int64  
 1   sex       1025 non-null   int64  
 2   cp        1025 non-null   int64  
 3   trestbps  1025 non-null   int64  
 4   chol      1025 non-null   int64  
 5   fbs       1025 non-null   int64  
 6   restecg   1025 non-null   int64  
 7   thalach   1025 non-null   int64  
 8   exang     1025 non-null   int64  
 9   oldpeak   1025 non-null   float64
 10  slope     1025 non-null   int64  
 11  ca        1025 non-null   int64  
 12  thal      1025 non-null   int64  
 13  target    1025 non-null   int64  
dtypes: float64(1), int64(13)
memory usage: 112.2 KB
None

이 문제에서 독립변수를 ~~ 로 하고, 목표변수를 target으로 하는~~ 이런식으로 나왔기 때문에 얘도 동일하게 식 작성해야함

from statsmodels.formula.api import logit
result = logit('target ~ exang + trestbps + ca', data = df).fit().summary()
print(result)

Optimization terminated successfully.
         Current function value: 0.516009
         Iterations 6
                           Logit Regression Results                           
==============================================================================
Dep. Variable:                 target   No. Observations:                 1025
Model:                          Logit   Df Residuals:                     1021
Method:                           MLE   Df Model:                            3
Date:                Thu, 30 Oct 2025   Pseudo R-squ.:                  0.2552
Time:                        09:48:21   Log-Likelihood:                -528.91
converged:                       True   LL-Null:                       -710.12
Covariance Type:            nonrobust   LLR p-value:                 3.046e-78
==============================================================================
                 coef    std err          z      P>|z|      [0.025      0.975]
------------------------------------------------------------------------------
Intercept      3.1733      0.598      5.305      0.000       2.001       4.346
exang         -2.1073      0.167    -12.629      0.000      -2.434      -1.780
trestbps      -0.0138      0.004     -3.095      0.002      -0.023      -0.005
ca            -0.8756      0.083    -10.574      0.000      -1.038      -0.713
==============================================================================

답 : 0.083

2. fbs, thalach, chol, sex를 독립변수로 target을 분류하는 로지스틱 회귀분석 모형을 생성했을때, 학습(train) 데이터의 오분류율을 구하시오. (단, 전체 데이터 중 800행을 학습(train) 데이터로 사용하고, train_test_split의 test_size는 0.2로 하며, random_state는 123으로 한다.)

왜 갑자기 훈련 시키는거지? 문제가 원래 이렇게 나오나??

# Q2
train = df.iloc[:800, :]
test = df.iloc[-225:, :]
print(train.info())
print(test.info())

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 800 entries, 0 to 799
Data columns (total 14 columns):
 #   Column    Non-Null Count  Dtype  
---  ------    --------------  -----  
 0   age       800 non-null    int64  
 1   sex       800 non-null    int64  
 2   cp        800 non-null    int64  
 3   trestbps  800 non-null    int64  
 4   chol      800 non-null    int64  
 5   fbs       800 non-null    int64  
 6   restecg   800 non-null    int64  
 7   thalach   800 non-null    int64  
 8   exang     800 non-null    int64  
 9   oldpeak   800 non-null    float64
 10  slope     800 non-null    int64  
 11  ca        800 non-null    int64  
 12  thal      800 non-null    int64  
 13  target    800 non-null    int64  
dtypes: float64(1), int64(13)
memory usage: 87.6 KB
None
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 225 entries, 800 to 1024
Data columns (total 14 columns):
...
 13  target    225 non-null    int64  
dtypes: float64(1), int64(13)
memory usage: 24.7 KB
None

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import confusion_matrix, classification_report, roc_auc_score

X = train[['fbs', 'thalach', 'chol', 'sex']]
y = train['target']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 123)
print(X_train.shape, X_test.shape, y_train.shape, y_test.shape)

(640, 4) (160, 4) (640,) (160,)

lr = LogisticRegression()
lr.fit(X_train, y_train)
pred = lr.predict(X_test)

confussion = confusion_matrix(y_test, pred)
print(confussion)

roc = roc_auc_score(y_test, pred)
print(roc)

[[59 19]
 [28 54]]
0.7074734208880551

print(round(1 - roc, 2))

답 : 0.29

3. 2번 문제 모델의 심장질환 발생(1)에 대한 정밀도를 구하시오.

정밀도의 경우 classification_report를 통해서 확인해야함.

# Q3 
cla_re = classification_report(y_test, pred)
print(cla_re)

              precision    recall  f1-score   support

           0       0.68      0.76      0.72        78
           1       0.74      0.66      0.70        82

    accuracy                           0.71       160
   macro avg       0.71      0.71      0.71       160
weighted avg       0.71      0.71      0.71       160

답 : 0.74

[포렌식] 카카오톡 수정된 메시지 및 삭제된 메시지 분석 및 복구 (25.10.07)

pental — Tue, 7 Oct 2025 01:35:25 +0900

“지금 보낸 그 메시지, ‘수정’ 버튼 한 번이면 싹 바뀔 수 있다.”

최근 카카오톡의 대대적 업데이트 이후, 메시지 수정 기능이 새롭게 도입되면서 많은 이용자들이 기대와 우려 사이에 놓여 있다. 특히 이 기능이 “말 바꾸기” 또는 “증거 삭제”의 수단으로 악용될 가능성도 제기되며, 카카오톡이 가진 커뮤니케이션의 신뢰성에도 균열이 생길지 모른다는 목소리가 커지고 있다.

실제로 일부 이용자들은 “그럼 앞으로 카톡을 증거로 사용할 수 없겠네… 신뢰성 떨어진다” 라는 반응을 보이기도 했는데 이처럼 메시지 수정 기능은 단순한 편의성의 연장선이 아니라, 커뮤니케이션의 본질과 책임의 경계를 다시 묻게 만드는 변화다.

이 글에서는 카카오톡 업데이트의 핵심 변화와 더불어, 메시지 수정 기능이 초래할 수 있는 문제점들을 짚어보고자 한다.

먼저 최근 추가된 수정 기능에 대해서 시나리오를 하나 세워보았다.

먼저 A가 상대방(이하 B라고 칭한다)에게 "나 10만원만 한국은행 1234-5678-90 으로 보내주라" 라고 보낸 메시지이다. 이부분에서는 정상적으로 10만원을 빌려달라는 메시지가 정상적으로 보이게 된다.

B는 A가 10만원을 보내달라는 메시지를 받고, 그 즉시 10만원을 송금한 것으로 확인된다. 하지만 이제 A가 이 문자 메시지를 변경하는 것이다.

물론 "수정됨" 이라는 문구와 함께, 메시지의 내용이 10만원에서 1만원으로 변경된 것을 확인 할 수 있으며, 이 부분에 대해서는 큰 문제가 발생할 수 있는 소지가 있다.

문제는 단순히 10만원 → 1만원이 아니다. 만약 과거에 “500만원을 빌려달라”는 메시지가 있었는데, 이후 “50만원”으로 변경된다면 어떨까?

먼저 금전거래 증거로 제출된 메시지가 법적 분쟁 상황에서 효력을 상실할 수 있다. 또한, “수정됨”이라는 표식이 있더라도 원문 내용이 확인되지 않는 이상, 상대방에게 불리하게 작용할 수 있다. 결과적으로 카카오톡 대화의 증거 신뢰성이 흔들리며, 분쟁 상황에서 악용될 소지가 커진다.

나는 이 부분에 초점을 두고 분석을 진행하였다. 분석은 iOS 환경을 이용하여 진행하였으며, 아래는 분석에 관한 내용이다.

분석 환경의 경우 Mac + Python 3.13.7 버전을 사용하였으며 B의 휴대전화를 사용하여 분석을 진행한다.

B의 카카오톡 버전은 25.8.4를 사용하고 있다.

먼저 아이폰 논리백업을 통해서 카카오톡 채팅 데이터베이스를 추출하였다. 기존 포스팅에서 언급한것 처럼 아래 논문을 사용하여, 복호화 작업을 진행하였다.

https://pental.tistory.com/538

[포렌식] 아이폰 카카오톡 복호화 분석 및 구현

본 글은 언제든지 비공개 되거나, 삭제될수 있음을 미리 알려드립니다. (뭐,, 카카오톡 본사에서 글 내려라 하지 않는 이상 없어지진 않지 않을까...?)모바일 메신저는 디지털 포렌식에서 핵심적

blog.system32.kr

논리 백업 파일에서 카카오톡 데이터베이스 추출 과정에 대해서는 생략한다. (자세한 과정은 이전 포스팅 참고)

이번 분석에서는 Message.sqlite 파일의 message 테이블을 활용하여, userid와 message 컬럼을 기준으로 단순 메시지 복호화를 진행하였다.

먼저 가장 크게 눈에 띄는 부분은 "나 10만원만 한국은행 1234-5678-90으로 보내주라"라고 A가 B에게 보냈지만, 실질적으로 B의 휴대전화에서 남는 기록은 "나 1만원만 한국은행 1234-5678-90으로 보내주라" 라고 수정된 메시지만 남게된다.

즉, 수정 이후에는 변경된 메시지 내용만 보이게 된다.

이때 데이터베이스에는 다음과 같은 로그가 남는다.

{"logId":3681151639662792706,"targetRevision":1,"hidden":true,"feedType":25}

여기서 targetRevision: 1 은 메시지가 수정되었음을 의미한다. 그리고 logId는 직전 메시지를 가리키는 지표 역할을 한다.

직전의 메시지를 나타내는 지표이다. 사용한 코드는 다음과 같다.

conn = sqlite3.connect("after")
cursor = conn.cursor()
cursor.execute("SELECT prevId, userid, message FROM message WHERE prevId = 3681151639662792706")
row = cursor.fetchall()
print(decrypt(row[0][1], row[0][2]))

그렇다면 수정된 메시지는 원래 내용을 확인할수 없는것인가? 답은 원본 메시지도 확인 할 수 있다는 것이다.

카카오톡에서는 위에서 언급한 가상의 시나리오 처럼 "수정" 기능을 악용하는 소지를 방지하기 위해 extrainfo 칼럼에 원본 메시지를 저장하고 있다.

{
  "scrapURL": "N/A",
  "cv": "1.0",
  "modifyHistory": [
    {
      "revision": 0,
      "message": "PsdqQvX+keRqNW0vIIklOi6/CUsKnpXQRmri78qnRBHiWM9pViqc/PJAWOKxDfZ2\r\n/PSZ5aM/bTTY/AX+Lb/h/A==",
      "encrypted": true
    }
  ],
  "revision": 1
}

위 내용에서 먼저 눈에 띄는것은 다른 메시지와는 다르게 revision값이 1로 변경되어 있다는 점이다.

다른 평범한 메시지의 경우 다음과 같은 extraInfo를 가지고 있다.

{"cv":"1.0","revision":0,"scrapURL":"N\/A"}
{"scrapURL":"N\/A","cv":"1.0"}
{"scrapURL":"N\/A","revision":0,"cv":"1.0","byHost":false}

위 modifyHistory 부분에서는 revision 키를 인덱스로 사용하여, 수정이 여러번 되어도 그 내용을 기록하는 형태를 가지고 있다. message 키에서는 \, \r, \r 등의 개행 문자 등은 처리하고 userid를 사용하여 복호화 하면 기존의 메시지를 확인 할 수 있다.

print(decrypt(123456789, "PsdqQvX+keRqNW0vIIklOi6/CUsKnpXQRmri78qnRBHiWM9pViqc/PJAWOKxDfZ2/PSZ5aM/bTTY/AX+Lb/h/A=="))

위에서 사용한 123456789는 가상의 userId이며, 실제 복호화에는 실제 userId를 사용해야한다.

그 결과 원본 메시지에서는 "나 10만원만 한국은행 1234-5678-90 으로 보내주라" 라는 메시지를 확인 할 수 있다.

즉, 카카오톡은 단순히 메시지를 덮어쓰는 방식이 아니라, extraInfo에 수정 이력(History)을 함께 저장하여 원본 추적이 가능하도록 설계되어 있다.

결론적으로, 위의 예시와 같이 메시지가 “수정”된 경우에도 B가 탈퇴하거나 대화방을 완전히 나가지 않는 이상, 혹은 특정 대화를 직접 삭제하지 않는 이상, 원본 메시지 확인이 가능하다는 점이다. 다시 말해, 설령 사용자가 발뺌을 하더라도 데이터베이스 상에는 안전장치가 마련되어 있는 셈이다.

다만 이러한 원본 추적 과정은 일반 사용자가 바로 확인할 수 있는 것이 아니며, 디지털 포렌식 분석이나 법적 증거 제출 절차를 거쳐야만 한다. 따라서 실제 분쟁 상황에서는 시간과 비용이 소요될 수 있다는 한계도 존재한다.

번외로, 삭제된 메시지가 실제로 데이터베이스에서는 어떻게 남는지 확인해보았다. (사실 이전 포스팅에서 다룬 내용이기도 하다.)

위 사진은 삭제하기 전 사진이다. (정상적으로 메시지가 존재하며, 일반 메시지처럼 복호화 가능하다.)

위 사진은 삭제한 후 사진이다. (화면상에는 “메시지가 삭제되었습니다.”라는 문구로 표시된다.)

그럼 이 메시지들은 데이터베이스에서 어떻게 처리되는지 확인해보자.

위에서 언급한 포스팅 내에 있는 논문에서도 언급 됐듯, type 칼럼이 16385로 변경되며, message원본값은 변경되지 않은 상태이다. 즉, type 16835인 경우 프론트단에서 "메시지가 삭제되었습니다."로 표시해주는것 같다는 추측이다.

위 사진과 같이 삭제된 메시지는 모두 보이게 되며, 단 로그로 "hidden":true가 추가된다. (삭제한 시점을 기반으로) 이 경우 type은 0이다.

위에서 따로 언급은 하지 않았지만, type 26의 경우 "답장" 기능에 대한 요청이다.

conn = sqlite3.connect("after")
cursor = conn.cursor()
cursor.execute("SELECT * FROM message WHERE message = 'jXYeIo8wBkxZ7eGCRG3LmoAhjWDBg2qETWRHkyFJ4Pk='")
rows = cursor.fetchall()
print(rows)

pental@pentalui-MacBookAir kakaotalk-decryption % /opt/homebrew/bin/python3 /Users/pental/Desktop/kakaotalk-decryption/test.py
[(16, 0, None, 1, None, '', 3681152882208575489, None, None, None, 781457625, None, '{"revision":0,"cv":"1.0"}', 1759764825.827979, 3681152932582166529, 26, 1759762522, 781457625.824429, 'jXYeIo8wBkxZ7eGCRG3LmoAhjWDBg2qETWRHkyFJ4Pk=', None, 0, 384935297767633, None, None, None, None, None, 'L/+N0joqNZxbQulWgmdTGexNYOwlzWfQPTVUr6dtj8q9WmWHBGlMu8+H6MvVZeea\r\nISS/cr6EsPq481909nqa8NvEmuukEGVmPjnhQ28uN+JiRwn+JuurTvWRhEoj7FVi\r\n5FqlQZI8CTSJ27BwcMjPm1+x+fTxiD8ewK0ZYzHHpE08P7g1an2RCJ5bqo2VMbvE\r\nxvHiLYYoUqpcacPcFX9K5g==', 0, 123456789, 1, None)]

이때 message 테이블에서 확인한 주요 변화는 다음과 같다.

1. type 값 변경

삭제된 메시지는 type 값이 16385로 바뀌며,
메시지 원본 값은 그대로 남아 있다.
즉, type = 16835인 경우 프론트단(클라이언트)에서만
“메시지가 삭제되었습니다.” 라는 문구를 표시한다고 추측할 수 있다.

2. hidden 플래그

삭제된 메시지는 log에 "hidden": true 값이 추가된다.
이 플래그는 삭제 시점을 기준으로 표시 여부를 제어하는 역할을 하는 것으로 보인다.
이 경우 type 값은 0으로 기록된다.

3. 기타 type 값

type = 26 은 “답장(reply)” 기능을 나타낸다.

이번 분석을 통해 확인할 수 있었던 사실은 크게 두 가지다.

1. 메시지 수정 기능

겉으로는 “수정됨”이라는 표시와 함께 변경된 내용만 보이지만,
내부적으로는 extraInfo 컬럼과 modifyHistory를 통해 원본 메시지가 그대로 저장되고 있어 복구가 가능하다.
다만, 일반 사용자가 직접 확인할 수는 없고 디지털 포렌식 분석 과정을 거쳐야만 원문을 확인할 수 있다.

2. 메시지 삭제 기능

화면에서는 “메시지가 삭제되었습니다.”라는 문구가 표시되지만,
데이터베이스에서는 type 값과 hidden 플래그로만 상태가 바뀌고, 원본 메시지는 여전히 존재한다.
따라서 삭제된 메시지 역시 복호화를 통해 확인할 수 있다.

결론적으로, 카카오톡은 사용자 편의를 위해 메시지 수정·삭제 기능을 제공하지만, 데이터베이스 차원에서는 안전장치(원본 보존 기록) 를 두어 원본 메시지 추적이 가능하도록 설계되어 있다.

이는 “말 바꾸기”나 “증거 인멸”과 같은 악용 가능성을 일정 부분 방지하는 장치가 되지만, 실제 법적 증거로 활용하려면 전문가의 분석, 시간, 비용이 필요하다는 점에서 여전히 한계가 존재한다.

결국 카카오톡 대화는 편리한 소통 도구이자 동시에 법적·사회적 증거로서 중요한 가치를 가진다. 그렇기에 사용자는 수정·삭제 기능을 가볍게 생각하기보다, 책임성과 신뢰성을 전제로 한 커뮤니케이션이 필요하다고 생각된다.

[58회] SQLD 합격 후기

pental — Sat, 20 Sep 2025 12:55:30 +0900

이번 58회차 SQLD 자격증을 합격했습니다.

이번 58회차는 역대급으로 어려웠다는 소문이 돌기도 하고,
전공자이긴 하지만 SQL 부분은 다뤄본적이 많이 있지 않아서 조금 어려웠습니다.

짧게나마 제 공부 방법과 느낀점, 그리고 소소한 팁들을 기록용으로 남겨봅니다.

앞으로 준비하시는 분들꼐 조금이나마 도움이 되길 바랍니다.

SQLD(SQL Developer)는 한국데이터산업진흥원(Kdata)에서 주관하는 국가공인 자격증입니다.

데이터베이스의 구조와 원리를 이해하고, SQL을 실제로 다루는 능력을 검증하는 시험이라서 IT 개발자뿐만 아니라 데이터 분석가, 기획자에게도 필수 스펙으로 꼽힙니다.

공부 과정

저는 2025년 여름, 약 두 달 동안 SQLD를 준비했어요. 아이패드로 기본서를 1회독하고,

노랭이 요약집과 모의고사까지 꾸준히 풀어 나갔습니다.

공부 일지

6월 21일: 아이패드 기본서 1회독 시작
6월 26일~30일: 실전 모의고사 1~5회 풀기 완료
7월 1일~8일: 노랭이, 홍쌤 인강 1~5강 모두 수강
7월 9일~17일: 기본서 P1, P2 전체 복습 완료
7월 18일~25일: 실전 모의고사 TEST 1~5회차 풀이
7월 28일~8월 21일: 노랭이 + SQLD.KR 모의고사 반복 풀이 (점수 50점대 → 90점대 상승!)

이렇게 꾸준히 기록하면서 점수가 점차 오르는 게 눈에 보였고, 마지막에는 90점 이상까지 도달했습니다.

공부 방법

기본서 1회독으로 개념 정리
처음에는 시대에듀 유선배 SQL개발자 교재로 큰 틀을 잡았습니다.
노랭이 반복 학습
자주 나오는 포인트와 키워드 위주로 빠르게 회독, 틀린 문제는 다시 표시해서 복습했습니다.
인강(홍쌤 강의)
혼자 이해하기 어려운 부분은 인강으로 보충. “정규식, 서브쿼리, NULL 처리” 같은 파트가 특히 도움 됐어요.
모의고사 실전 훈련
- 초반 점수: 50~60점대
- 후반 점수: 80~90점대
- 반복하다 보니 시험장에서 시간 관리와 문제 접근법이 훨씬 편해졌습니다.

합격 소감

처음에는 막막했지만, 기본서 → 노랭이 → 인강 → 모의고사 순으로 루틴을 돌리면서 자신감이 붙었습니다.

특히 점수가 오르는 게 눈에 보일 때 정말 뿌듯했고, 시험장에서는 무난하게 풀고 나올 수 있었습니다.

SQLD 합격은 끝이 아니라 시작!!!

이 자격증을 기반으로 데이터 분석과 개발을 공부할 때 큰 도움이 될 것 같아요.

SQLD 준비하는 분들께 ✏️

처음엔 무조건 이해 위주 → 암기하려 하지 말고 흐름 잡기

기출 반복 → 최소 3번은 풀어야 안정적인 합격권

SQL 직접 쳐보기 → 손으로 안 치면 절대 안 외워집니다

꾸준히 하면 누구든 합격할 수 있는 시험이니, 저처럼 일정 잡고 꾸준히 따라가 보시길 추천드립니다

[브론즈 2] 백준 1673 - 치킨 쿠폰 (파이썬)

pental — Fri, 12 Sep 2025 10:48:36 +0900

https://www.acmicpc.net/problem/1673

치킨 한마리를 먹으면 쿠폰을 1장 준다. 요즘도 쿠폰을 주는 치킨집이 있던가,,

쿠폰 K장을 모으면 치킨 1마리로 교환할 수 있다. 처음에 가진 치킨 수 N이 주어졌을 때, 총 몇마리의 치킨을 먹을 수 있는지 구하는 문제이다.

3 2
4 3

예시로 다음과 같은 입력이 주어졌다면 분석하면 다음과 같다.

처음에 3마리를 주문 했고, 쿠폰 3장을 지급 받았다. 1마리를 교환 했고, 쿠폰이 1장 남아있다.

근데 1마리를 주문하면서 쿠폰 1장을 더 받았기에, 남은 쿠폰은 2개가 되어 한마리를 더 주문할 수 있다.

총 5마리를 먹을 수 있는 셈이다. 완전 부럽다.

4 3 의 경우 처음에 4마리를 먹었고, 쿠폰 4장을 지급 받았다. 이 치킨 집은 3장당 한마리로 바꿔주기에, 4장 중에 3장을 써서 1마리를 더 먹을 수 있다. 즉 5마리를 먹을수 있는 것이다.

# [브론즈 2] 백준 1673 - 치킨 쿠폰

while True :
    try :
        N, K = map(int, input().split())
        result = 0
        result += N
        while N // K :
            result += N // K
            N = N // K + N % K
        print(result)
    except :
        break

[브론즈 2] 백준 1718 - 암호 (파이썬)

pental — Fri, 12 Sep 2025 09:59:40 +0900

https://www.acmicpc.net/problem/1718

핵심은 평문을 주어진 KEY로 암호화한 문장을 해독하는 것인데, 여기서 중요한 포인트는 키 값에서 +1 처리를 반드시 해줘야 한다는 점이다.

S = input().rstrip()
KEY = input().rstrip()

LONG_KEY = ""
while len(LONG_KEY) < len(S):
    LONG_KEY += KEY

암호화할 평문 S와 키 KEY를 입력받는다.
키는 평문보다 짧을 수 있기 때문에 평문의 길이에 맞게 반복해서 이어 붙인다.

result = []
for i in range(len(S)):
    if S[i] == " ":
        result.append(" ")
    else:
        c = ord(S[i]) - ord('a')
        k = ord(LONG_KEY[i]) - ord('a')
        dec = (c - (k+1)) % 26
        result.append(chr(dec + ord('a')))

평문이 공백 " "이면 그대로 결과에 넣는다.
알파벳일 경우:
- 평문의 문자를 숫자로 변환(a=0, b=1, …).
- 키의 문자를 숫자로 변환.
- 암호문을 만들 때는 (평문 + 키+1) % 26으로 암호화

# [브론즈 2] 백준 1718 - 암호

S = input().rstrip()
KEY = input().rstrip()

LONG_KEY = ""
while len(LONG_KEY) < len(S):
    LONG_KEY += KEY

result = []
for i in range(len(S)):
    if S[i] == " ":
        result.append(" ")
    else:
        c = ord(S[i]) - ord('a')
        k = ord(LONG_KEY[i]) - ord('a')
        dec = (c - (k+1)) % 26
        result.append(chr(dec + ord('a')))

print("".join(result))

[브론즈 2] 백준 1592 - 영식이와 친구들 (파이썬)

pental — Thu, 11 Sep 2025 09:53:50 +0900

https://www.acmicpc.net/problem/1592

총 N명의 친구들이 원형으로 앉아 있다. 공을 가진 사람이 공을 던질 때, 현재 그 사람이 받은 횟수가 홀수라면 오른쪽 L번째 있는 사람에게, 짝수라면 왼쪽으로 L번째 있는 사람에게 공을 던진다.

특정 친구가 공을 M번 받으면 게임이 끝나고, 공을 총 몇 번 던졌는지 출력하는 문제이다.

먼저 배열로 각 친구의 공 받은 횟수를 기록한다.

N, M, L = map(int, input().split())
A = [0] * N

최초의 배열은 [0]으로 초기화 하였으며, N, M, L 은 map을 통해서 입력 받는다.

while max_ball != M :
    A[index] += 1
    max_ball = max(max_ball, A[index])
    if max_ball == M :
        break
    if A[index] < M and A[index] % 2 == 1 :
        index += L
        if index >= N :
            index -= N
    elif A[index] < M and A[index] % 2 == 0 :
        index -= L
        if index < 0 :
            index += N
    result += 1

핵심 로직은 위 부분이다. 먼저 공을 줬기 때문에 A의 현재 인덱스에 1을 증가시키고, 현재의 공의 갯수와, 가장 많은 공을 잡은 사람의 횟수를 비교하여 M과 동일하다면 종료한다.

왼쪽과 오른쪽으로 나누기 위해서 만약 N명의 범위가 초과 하거나 미만인경우 적절하게 +-를 통해서 N으로 증감해주었다.

사실은 인덱스 갱신 부분을 더 깔끔하게 쓰려면 mod 연산을 바로 사용하면 된다.

if A[index] % 2 == 1:   # 홀수
    index = (index + L) % N
else:                   # 짝수
    index = (index - L) % N

전체 코드

# [브론즈 2] 백준 1592 - 영식이와 친구들

N, M, L = map(int, input().split())
A = [0] * N
# A[0] = 1
max_ball = 0
index = 0
result = 0
while max_ball != M :
    A[index] += 1
    max_ball = max(max_ball, A[index])
    if max_ball == M :
        break
    if A[index] < M and A[index] % 2 == 1 :
        index += L
        if index >= N :
            index -= N
    elif A[index] < M and A[index] % 2 == 0 :
        index -= L
        if index < 0 :
            index += N
    result += 1
print(result)

[브론즈 1] 백준 1524 - 세준세비 (파이썬)

pental — Wed, 10 Sep 2025 10:06:29 +0900

https://www.acmicpc.net/problem/1524

세준(S)과 세비(B)가 각각 병사를 가지고 있다. 병사들끼리 전투를 하는데, 가장 약한 병사들끼리 싸운다.

전투 규칙은 다음과 같다.

1. 세준의 최약체 ≥ 세비의 최약체 → 세비의 병사가 죽는다.

2. 세준의 최약체 < 세비의 최약체 → 세준의 병사가 죽는다.

둘 중 한 쪽의 병사가 전멸할 때까지 반복한다.

이 문제에서 조건에 따라서 양쪽 진영의 최약체만 비교하면 된다. 파이썬 리스트 기본 함수인 pop을 사용했으며 O(1)의 시간복잡도를 가진다.

또한 정렬을 미리 해주었기 떄문에 -1 번 인덱스의 값이 항상 최약체의 값이다.

아래 코드는 내가 작성하였지만 사실 이 문제는 시뮬레이션을 다 돌릴 필요가 없는 문제이다. 규칙상 세준이의 최약제 >= 세비의 최약체 라면 세비만 계속 죽기 때문이다.

즉, 양 진영의 최강 병사 중 더 강한 쪽이 반드시 승리한다고 생각 할 수 있다.

T = int(input())
for _ in range(T) :
    input()  # 공백 줄 처리
    N, M = map(int, input().split())  # 세준, 세비 병사 수
    sejuns = list(map(int, input().split()))  # 세준 병사 힘
    sebis = list(map(int, input().split()))   # 세비 병사 힘

    # 강한 순서로 정렬
    sejuns.sort(reverse = True)
    sebis.sort(reverse = True)
    
    # 전투 시뮬레이션
    while sejuns and sebis :
        if sejuns[-1] >= sebis[-1] :  # 세준의 최약체가 세비의 최약체보다 강하거나 같음
            sebis.pop()  # 세비 병사 제거
        else :
            sejuns.pop()  # 세준 병사 제거
    
    # 결과 판별
    if sejuns : 
        print("S")
    elif sebis :
        print("B")
    else :
        print("C")

T = int(input())
for _ in range(T):
    input()
    N, M = map(int, input().split())
    sejuns = max(map(int, input().split()))
    sebis = max(map(int, input().split()))

    if sejuns >= sebis:
        print("S")
    else:
        print("B")

[브론즈 2] 백준 1452 - 피시방 알바 (파이썬)

pental — Wed, 10 Sep 2025 09:58:38 +0900

https://www.acmicpc.net/problem/1453

dp처럼 생겼지만 걍 단순한 구현문제이다.

check 배열에 False로 하여 100개를 미리 만들어 두고, 각 손님을 돌면서 해당 자리에 넣고 True로 변경한다.

만약 동일한 자리가 들어오게 되면 result 변수에 +1 을 하여 거절당하는 자리를 계산할 수 있다.

# 백준 1453 - 피시방 알바

check = [False] * 100
N = int(input())
A = list(map(int, input().split()))

result = 0
for i in A :
    if check[i - 1] == False :
        check[i - 1] = True
    else :
        result += 1

print(result)

[브론즈 2] 백준 1440 - 타임머신 (파이썬)

pental — Wed, 10 Sep 2025 09:54:48 +0900

본 문제와 무관합니다.

https://www.acmicpc.net/problem/1440

쉬운 구현문제중 하나이다. HH:MM:SS의 시간을 DD:DD:DD로 입력받았을때 유효한 시간의 갯수만 계싼하면 된다.

단 여기서 확인해야하는 점은 시간은 1 ~ 12시까지, 분은 00 ~ 59분까지 초는 00 ~ 59초 까지만 가능하다.

따라서 유효성 검증을 하는 함수를 하나 만들어줬다.

def check_hour(HH) :
    if HH > 12 or HH < 1:
        return False
    return True

def check_minute(MM) :
    if MM >= 60 :
        return False
    return True

def check_second(SS) :
    if SS >= 60 :
        return False
    return True

위 함수와 같이 시간과 분, 초를 각각 검증하는 함수를 작성하였고, 각 순열을 만들어야 하기에, permutations 함수를 이용하였다.

# 백준 1440 - 타임머신
from itertools import permutations

HH, MM, SS = map(int, input().split(":"))

def check_hour(HH) :
    if HH > 12 or HH < 1:
        return False
    return True

def check_minute(MM) :
    if MM >= 60 :
        return False
    return True

def check_second(SS) :
    if SS >= 60 :
        return False
    return True

result = 0
for permutation in permutations([HH, MM, SS], 3) :
    HH, MM, SS = permutation
    if check_hour(HH) and check_minute(MM) and check_second(SS) :
        result += 1

print(result)

[브론즈 2] 백준 1263 - 펫 (파이썬)

pental — Tue, 9 Sep 2025 13:01:08 +0900

https://www.acmicpc.net/problem/1362

여러 테케가 주어지며 각 케이스는 O W로 시작한다. 0 0 이면 전체 입력이 종료된다.

각 테케마다 # 0 이 주어지면 그 케이스는 끝이 난다.

E x 는 체중을 빼고, F x는 체중을 더한다. 하지만 처리 도중 W <= 0 이 되는 순간 죽는것이다. 그 뒤 명령은 반영하지 않고, # 0 까지 입력만 진행한다.

최종적으로 사망하면 RIP, 생존이고 적정 체중의 1.5배 및 2배 미만이면 :-), 그 외는 :-(을 출력하는 문제이다.

# 백준 1362 - 펫
import sys
input = sys.stdin.readline

def opt(O, W) :
    if W > O * 0.5 and W < 2 * O :
        return ":-)"
    elif W <= 0 :
        return "RIP"
    else :
        return ":-("
index = 1
while True :
    O, W = map(int, input().split())
    if O == 0 and W == 0 :
        break
    alive = (W > 0)
    while True :
        DATA = input().split()
        op = DATA[0]
        weight = int(DATA[1])
        if op == "#" and weight == 0 :
            if not alive:
                print(index, "RIP")
            else:
                print(index, opt(O, W))
            index += 1
            break
        if alive :
            if op == "E" :
                W -= weight
            elif op == "F" :
                W += weight
            
            if W <= 0 :
                alive = False

[브론즈 1] 백준 1356 - 유진수 (파이썬)

pental — Tue, 9 Sep 2025 10:00:01 +0900

https://www.acmicpc.net/problem/1356

정수 N이 주어졌을 때, 이 수가 유진수인지 판별해야한다.

유진수는 어떤 수 N을 앞부분과 뒷부분으로 나누었을 때, 앞부분 각 자리수의 곱과 뒷부분 각 자리수의 곱이 같은 경우를 의미한다.

예를 들어서 다음과 같다.

1221 -> (12 | 21) => 1 * 2 = 2, 2 * 1 = 2 -> 즉, 유진수

1236 -> (123 | 6) => 1 * 2 * 3 = 6, 6 = 6 -> 즉, 유진수

1234 -> 어떤 방법으로도 곱이 같아지지 않음 -> 즉, 유진수 아님

코드는 다음과 같이 작성하였다.

# 백준 1356 - 유진수

N = list(input())

start = len(N)
result = False
for i in range(1, start) :
    A = N[:i]
    B = N[i:]

    temp_A, temp_B = 1, 1

    for x in A :
        temp_A *= int(x)
    for y in B :
        temp_B *= int(y)

    if temp_A == temp_B :
        result = True
        break

if result : 
    print("YES")
else :
    print("NO")

start는 전체 길이를 나타내며, result의 경우 유진수 여부를 판별하는 변수이다.

자르는 위치를 1부터 시작해서 start 까지 돌면서 A와 B를 나눈다. 즉 앞부분과 뒷부분을 나누고, 각각 앞부분과 뒷부분의 각 요소를 곱해서 두 곱이 같으면 유진수, 다르면 유진수가 아니도록 코드를 작성하였다.

예를 들어서 1221를 입력한 경우는 다음과 같다.

길이: 4
i=1 → A="1", B="221" → 곱: 1 vs 4 → 불일치
i=2 → A="12", B="21" → 곱: 2 vs 2 → 일치 → YES 출력

시작복잡도는 O(N^2)이라 조금 비효율 적이지만 그래도 자리수가 최대 10이라 충분히 빠르다.

[브론즈 2] 백준 1297 - TV 크기 (파이썬)

pental — Tue, 9 Sep 2025 09:39:24 +0900

https://www.acmicpc.net/problem/1297

이 문제는 TV 대각선 길이 D와 높이, 너비의 비율 H:W 가 주어진다.

실제 TV의 높이와 너비 (h, w)는 피타고라스 정리로 표현할 수 있다.

여기서는 비율 관계가 성립한다. 아래 수식을 참고하자.

즉, 실제 높이와 너비는 H와 W를 일정 비율로 확대한 값이다.

사칙연산으로 접근하면 높이와 너비를 K배 만큼 확대한 값이라고 한다면, 다음과 같이 수식을 새울수 있다.

흔히 아는 대각선 공식에 대입하면 필요한 수식은 다음과 같다.

작성한 코드는 다음과 같다.

# 백준 1297 - TV 크기

import math

D, H, W = map(int, input().split())

R = D / (H ** 2 + W ** 2) ** 0.5
print(int(H * R), int(W * R))

[브론즈 2] 백준 1350 - 진짜 공간 (파이썬)

pental — Tue, 9 Sep 2025 09:32:45 +0900

https://www.acmicpc.net/problem/1350

파일 시스템을 공부하는 나에겐 재밌는 문제이다. 먼저 이 문제는 파일 시스템에서는 디스크 공간이 파일 사이즈와 항상 같지 않고, 디스크가 일정한 크기의 클러스터로 나뉘어져있고, 한 클러스터는 오직 한 파일만 이용할 수 있다고 한다.

여기서 중요한것은 한 클러스터는 오직 한 파일만 이용할수 있다는 것이다.

예제에서 클러스트가 512bytes이고, 600bytes의 파일을 저장하려고 한다면 두개의 클러스터에 저장하게 된다.

이렇게 600 bytes의 파일을 저장하게되면 2개의 클러스터를 사용하게 된다.

또 하나 중요한것은 한 클러스터에는 하나의 파일만 이용할 수 있다는 점이다.

이렇게 500, 12, 100이 들어왔다면 512Bytes에 2개의 파일을 저장할수 있는것이 아닌 아래 그림과 같이 하나의 클러스터에는 한개의 파일만 저장 할 수 있는 것이다.

이걸 코딩으로 나타내면 다음과 같이 작성 할 수 있다.

# 백준 1350 - 진짜 공간

N = int(input())
SIZE = list(map(int, input().split()))
CLUSTER = int(input())

result = 0
for i in SIZE :
    if i == 0 :
        continue

    if i > CLUSTER :
        if i % CLUSTER > 0 :
            result += i // CLUSTER + 1
        else :
            result += i // CLUSTER
    else :
        result += 1
print(result * CLUSTER)

N과 파일 크기들, 클러스터 크기를 입력받고, 파일 크기가 0인 파일은 클러스터에 저장되지 않아도 되므로, 다음 파일로 넘어간다.

만약에 파일 크리가 클러스터보다 크다면 클러스터를 연속해서 사용해야하는데, 여기서 클러스터가 1024 크기이고, 들어오는 파일이 2049 라면 1024 + 1024 + 1 을 사용해야하기에, 총 3개가 들어온다.

따라서 파일 크기는 클러스터 크기로 나머지 연산을 했을때 0보다 크다면 + 1을 적용하고, 파일 크기를 클러스터 사이즈로 나누었을때 몫을 더해준다.

나머지가 없는 경우에는 파일 크기를 클러스터 사이즈로 나누었을때의 몫을 더해준다.

그외에는 그냥 + 1을 통해서 클러스터 갯수를 증가시키고, 마지막에는 클러스터 갯수 * 클러스터 사이즈로 결과를 도출한다.

나스 서버 교체 후기 (8베이 나스, 녹투아 쿨러)

pental — Sat, 30 Aug 2025 16:08:25 +0900

기존에 사용하던 서버는 미니 피씨 형태로 작기도 하고, NVME도 1개, 하드도 최대 2개밖에 장착할 수 없었다.

예전에 8베이 케이스를 사둔게 아깝기도 하고 용량 확장을 위해서 다시 8베이 케이스 + D-1581 보드로 이전하는 작업을 진행했다.

3년전 사놨던 8베이 나스 케이스,, 사실 한 1년 돌리고 소음이랑 발열 때문에 묵혀놨다. 근데 기존에 사용하던 서버는 SATA가 2개 뿐이라서 ㅜㅜ 어쩔수 없이 다시 서버 이전을 진행했다.

기본적으로 장착되어 있는 쿨러는 80mm 쿨러 4개가 달려 있고, 4핀으로 PWM 제어가 되지 않는 모델이다. 심지어 2800RPM 으로 쉬지 않고 돌아서 잠자는 방에서 돌리기엔 문제가 있다.

쿨러 4개를 모두 녹투아로 교체하자니 쿨러만 10만원이 훌쩍 넘어가는 비용,, 그래서 그냥 8베이중에 4베이를 과감하게 버리고 쿨러 2개로 진행하기로 했다.

개당 2.8 주고 2개를 구입했고, 서버 쿨러를 변경하기 위해서 케이스를 뜯었는데,,,

케이스를 완전 분해해야지만 HDD 백플레인에 있는 쿨러를 뗄수 있다.. 이거땜에 케이스 완전 분해를 진행했다..

사실은 이 과정에서 조금 고민이 많이 됐다. 현재는 해당 모델의 케이스를 사용하고 있으며, 케이스 내 쿨러는 다음과 같이 배치되어 있습니다.

해당 상품에서는 HDD 백플레인쪽에 쿨러가 없는데, HDD 백플레인쪽 2개, 위 사진에서 보이는 케이스에 딱 붙어있는 쿨러 2개

총 4개가 달려 있다... 팬 소음이 심해서 녹투아 NF-A8로 전체 교체를 진행하고 있는데,,

흡기 배기는, 아래 보드 쪽에는 CPU 쪽으로 흡기가 되고 CPU를 식혀주는게 당연하고, 위쪽에서는 위 그림처럼 HDD 쪽으로 바람을 2방향 보내고, 반대로 뒤편에 있는 쿨러는 케이스 밖으로 바람을 보내는게 맞을까?

아니면 2번 사진처럼 HDD 쪽에서 바람이 들어와서 뒤쪽 케이스 밖으로 빼는게 맞을까?

근데 답을 모르겠어서 그냥 국룰인 2번으로 진행했다.

녹투아 쿨러로 장착한 모습.. 이 두개 쿨러가 무슨 5만원이 넘냐고,,

10기가 멜라녹스도 야무지게 연결해주고 선정리는 대충 해주면 끝. 이러고 벤치마킹 돌리니까 39~42도가 평균적으로 케이스 안에서 진행되고 있었다.

사실 이렇게 까지 총알을 쓰면서 쿨러를 바꾼 이유는, 기존 서버는 온도 떄문에 시스템이 계속 죽었기 때문,

심지어 1개 팬으로 버티다 보니까 당연히 온도가 높아져서 뒤질수밖에,,, 그래서 변경하게 되었다.

하드 평균 IDLE에서는 HGST 4TB 모델이 51도, WD 4TB모델이 45도를 유지하고 있다.

딱히 나쁘지 않은듯~ 예쩐엔 파일 조금만 옮겨도 60도 이랬는데 역시 쿨링은 잘해줘야한다.

[실버 5] 백준 11723 - 집합 (파이썬)

pental — Wed, 13 Aug 2025 17:03:15 +0900

# 백준 11723 - 집합

import sys
input = lambda: sys.stdin.readline().rstrip()

S = []
M = int(input())
for _ in range(M) :
    line = input().split()
    if len(line) > 1 :
        op = line[0]
        num = int(line[1])

        if op == "add" :
            if num not in S :
                S.append(num)
        elif op == "remove" :
            if num in S :
                S.remove(num)
        elif op == "check" :
            if num in S :
                print("1")
            else :
                print("0")
        elif op == "toggle" :
            if num in S :
                S.remove(num)
            else :
                S.append(num)
    else :
        op = line[0]
        if op == "all" :
            S = [n for n in range(1, 21)]
        elif op == "empty" :
            S = []

백준 5522, 10178, 9295, 10569, 2921 (파이썬)

pental — Fri, 1 Aug 2025 16:10:39 +0900

# 백준 5522 - 카드 게임

A = [int(input()) for _ in range(5)]
print(sum(A))

# 백준 10178 - 할로윈의 사탕

T = int(input())
for _ in range(T) :
    c, v = map(int, input().split())
    print(f"You get {c // v} piece(s) and your dad gets {c % v} piece(s).")

# 백준 9295 - 주사위

T = int(input())
for i in range(T) :
    a, b = map(int, input().split())
    print(f"Case {i + 1}: {a + b}")

# 백준 10569 - 다면체

T = int(input())
for _ in range(T) :
    V, E = map(int, input().split())
    print(2 - V + E)

# 백준 2921 - 도미노

N = int(input())
total = 0

for i in range(N + 1):
    for j in range(i, N + 1):
        total += i + j

print(total)

[실버 3] 백준 6666 - Help Me with the Game (파이썬)

pental — Thu, 31 Jul 2025 11:19:13 +0900

분류 : 구현

링크 : https://www.acmicpc.net/problem/6666

풀이

문제집에서 이거 안풀면 꿈에서 나온다는 말이 있어서 찾아보게된 문제이며, 문제 번호부터가 6666으로 예사롭지가 않다.

근데 진짜 문제도 예사롭지 않다.

입력을 한번 봐보자

+---+---+---+---+---+---+---+---+
|.r.|:::|.b.|:q:|.k.|:::|.n.|:r:|
+---+---+---+---+---+---+---+---+
|:p:|.p.|:p:|.p.|:p:|.p.|:::|.p.|
+---+---+---+---+---+---+---+---+
|...|:::|.n.|:::|...|:::|...|:p:|
+---+---+---+---+---+---+---+---+
|:::|...|:::|...|:::|...|:::|...|
+---+---+---+---+---+---+---+---+
|...|:::|...|:::|.P.|:::|...|:::|
+---+---+---+---+---+---+---+---+
|:P:|...|:::|...|:::|...|:::|...|
+---+---+---+---+---+---+---+---+
|.P.|:::|.P.|:P:|...|:P:|.P.|:P:|
+---+---+---+---+---+---+---+---+
|:R:|.N.|:B:|.Q.|:K:|.B.|:::|.R.|
+---+---+---+---+---+---+---+---+

입력자체가 조금 빡치게 생겨서 나같은 경우는 "+---+---+---+---+---+---+---+---+" 이친구를 모두 없애고, 1번 위치 부터 -1위치까지 “|”를 기준으로 나누고, Board에 넣는다. 체스판은 총 17줄이기 때문에 17만큼만 반복문을 구했다.

예시 입력 결과

|:r:|...|...| → [':r:', '...', ..., '...']

정렬 기준을 설정했다. 정렬 기준은 다음과 같이 설정하였다.

columns = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
priority = {'K' : 0, 'Q' : 1, 'R' : 2, 'B' : 3, 'N' : 4, "P" : 5}

columns는 열에 대응되는 알파벳 a ~ h를 나타내고, priority는 말의 중요도 순서를 나타내었다.

우선순위의 경우 출력 시 정렬 기준으로 사용 할 수 있다.

for row in range(8) :
    for col in range(8) :
        cell = board[row][col]
        piece = cell[1]
        if piece == '.' or piece == ':':
            continue

백색과 흑색 말의 위치 정보를 따로 저장한다. cell[1]은 :r: 또는 .P. 처럼 가운데 문자를 의미하고, 비어있는 칸은 스킵한다.

        col_letter = columns[col]
        row_number = 8 - row

행과 열을 체스 기보 표기법 좌표로 변환한다.

예 : e4, Nc6등

if piece.isupper() :
    kind = piece
    if kind == 'P' :
        name = f"{col_letter}{row_number}"
    else :
        name = f"{kind}{col_letter}{row_number}"
    white.append((priority[kind], row_number, col_letter, name))

백색 말은 대문자로 이루어져있어서 isupper함수를 통해서 대문자인지 확인하였고, P는 열 + 행, 나머지는 말이름 + 열 + 행으로 저장한다.

정렬을 하기 위해서 (우선순위, 행번호, 열문자, 기보)를 형식으로 한 튜플로 저장한다.

else :
    kind = piece.upper()
    if kind == 'P' :
        name = f"{col_letter}{row_number}"
    else :
        name = f"{kind}{col_letter}{row_number}"
    balack.append((priority[kind], -row_number, col_letter, name))

흑색말은 소문자로 이루저여있지에, 소문자에서 대문자로 바꾸어 동일한 포맷을 유지하도록 했다.

행번호는 위에서부터 내려오기 때문에 -row_number로 정렬 방향을 반대로 만들어주었다.

문제에서는 정렬을 해서 출력하라 하였기에 다음과 같이 정렬한다.

white.sort()
balack.sort()

코드

# 백준 6666 - Help me With the Game

board = []
for i in range(17) :
    s = input()
    if s != "+---+---+---+---+---+---+---+---+" :
        s = s[1:-1].split("|")
        board.append(s)

columns = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']
priority = {'K' : 0, 'Q' : 1, 'R' : 2, 'B' : 3, 'N' : 4, "P" : 5}

white = []
balack = []
for row in range(8) :
    for col in range(8) :
        cell = board[row][col]
        piece = cell[1]
        if piece == '.' or piece == ':':
            continue
        col_letter = columns[col]
        row_number = 8 - row

        if piece.isupper() :
            kind = piece
            if kind == 'P' :
                name = f"{col_letter}{row_number}"
            else :
                name = f"{kind}{col_letter}{row_number}"
            white.append((priority[kind], row_number, col_letter, name))
        else :
            kind = piece.upper()
            if kind == 'P' :
                name = f"{col_letter}{row_number}"
            else :
                name = f"{kind}{col_letter}{row_number}"
            balack.append((priority[kind], -row_number, col_letter, name))

white.sort()
balack.sort()

print("White: " + ",".join(piece[3] for piece in white))
print("Black: " + ",".join(piece[3] for piece in balack))

[골드 4] 백준 2661 - 좋은수열 (파이썬)

pental — Wed, 30 Jul 2025 23:12:25 +0900

분류 : 백트래킹

링크 : https://www.acmicpc.net/problem/2661

풀이

이 문제는 숫자 1, 2, 3 으로만 이루어지는 수열이 있으며, 임의의 길이의 인접한 두 개의 부분 수열이 동일한 것이 있으면, 그 수열은 나쁜 수열이라고 한다.

좋은 수열은 인접한 두 개의 부분 수열이 동일하면 안된다. 즉 1212는 마지막 두자리 12가 반복되므로 나쁜 수열이다.

길이 N의 좋은 수열 중 사전순으로 가장 앞서는 수열을 찾아야한다.

def is_good(seq) :
    length = len(seq)
    for i in range(1, length // 2 + 1) :
        if seq[-i:] == seq[-2 * i : -i] :
            return False
    return True

이 함수는 현재 수열이 좋은 수열인지 판단한다.

i는 검사할 패턴의 길이, 최대 length // 2 까지만 확인하면 충분하다.

예를 들어서 123123에서는 뒤에서부터 길이 3까지의 패턴 123을 비교한다.

seq[-i:]는 마지막 i개의 문자, seq[-2*i:-i]는 그 앞 i개의 문자를 나타내며, 두부분이 같다면 반복되는 패턴이므로 나쁜수열이다.

반복이 없다면 좋은 수열을 나타낸다.

def dfs(seq) :
    global found
    if found : return
    if len(seq) == N :
        print(seq)
        found = True
        return 
    for digit in '123' :
        new_seq = seq + digit
        if is_good(new_seq) :
            dfs(new_seq)

현재 수열 seq를 기반으로 깊이우선탐색을 진행한다.

수열의 길이가 N이 되면 출력하고 종료하고, 숫자 1, 2, 3을 하나씩 붙여가면서 수열을 확장한다.

붙였을때 좋은 수열인지 검사 후 통과하면 재귀를 호출한다.

좀 어려운 문제인데 이게 어떻게 정답률이 50%..

코드

# 백준 2661 - 좋은수열
# 분류 : 백트래킹

N = int(input())

found = False

def is_good(seq) :
    length = len(seq)
    for i in range(1, length // 2 + 1) :
        if seq[-i:] == seq[-2 * i : -i] :
            return False
    return True

def dfs(seq) :
    global found
    if found : return
    if len(seq) == N :
        print(seq)
        found = True
        return 
    for digit in '123' :
        new_seq = seq + digit
        if is_good(new_seq) :
            dfs(new_seq)

dfs("")

[yolo11] YOLO를 활용한 차량 분류 시스템 개발기 (2) - Yolo를 통해 객체 인식하기

pental — Tue, 29 Jul 2025 16:23:42 +0900

https://blog.system32.kr/567

[yolo11] YOLO를 활용한 차량 분류 시스템 개발기 (1) - YOLO란 무엇인가? + labelme 사용법

블랙박스 영상에는 단순히 사고 장면을 담는 것 이상의 수많은 정보가 들어 있다. 차량의 움직임, 주변 상호, 도로 표시, 다른 차량 정보까지 — 이것들은 모두 범죄 수사, 보험 분쟁, 운전 패턴

blog.system32.kr

기존글에서는 YOLO를 활용한 차량 분류 시스템 개발 - YOLO가 무엇인지, 그리고 Labelme를 사용해서 Yolo에 적합한 타임의 Dataset으로 변환하는 과정에 관해서 작성했었다.

본 게시물에서는 [yolo11] YOLO를 활용한 차량 분류 시스템 개발기 (1) - YOLO란 무엇인가? + labelme 사용법 에서 다뤘던 데이터들로 학습을 진행한다.

만들어 두었던 YOLODataset 폴더를 그대로 사용할 것이며, 필자의 환경은 Apple M2, MPS를 사용해서 진행하며, Python 3.9.6 버전을 사용하고 있다.

일단 진행전 가상 환경을 구축하고 진행한다.

pental@pentalui-MacBookAir ultralytics % python3 -m venv yolovenv
pental@pentalui-MacBookAir ultralytics % source yolovenv/bin/activate

pip install ultralytics

먼저 python pip를 통해서 ultralytics를 설치한다. 설치에는 꽤나 많은 시간이 소요된다.

import ultralytics
ultralytics.checks()

제대로 설치되었는지 확인하기 위해서 위와 같은 코드를 사용하면 아래와 같이 어떤 버전을 사용하고 있으며 CPU 상태 등을 확인 할 수 있다.

학습은 간단하다. 미리 알아둔 Dataset 경로만 있으면 자동으로 필요한 파일은 다운받고, 학습까지 진행해준다.

yolo train model=yolo11n.pt data=/Users/pental/Desktop/YOLODataset/dataset.yaml epochs=100 imgsz=640

학습 중간중간에, runs 폴더 내 train 폴더에서 어떻게 학습이 되고 있는지 확인 할 수 있다.

학습이 완료되면, runs 폴더 아래 train의 마지막 폴더에 weights 폴더가 존재한다.

해당 폴더안에는 best.pt와 last.pt가 존재하며, 여기서 우리가 사용할 것은 best.pt이다.

이제 예측을 진행해야 한다. 예측은 다음과 같은 커맨드 라인으로 진행 할 수 있다.

yolo predict model=best.pt source=input.mp4

해당 작업이 완료되면, runs 폴더 아래 predict 폴더가 생성된다. 해당 파일은 아까 학습시킨 모델로 예측이 진행된 결과물이 들어있다.

예측 결과가 나오긴 했지만, 아직은 아쉬운 점이 많았다.

실제로 테스트해본 결과, 오탐(false positive)도 많고, 미탐(false negative)도 상당히 많아 개선이 필요해 보였다. 특히 비슷한 차량 외형 간 구분이 제대로 되지 않거나, 일부 프레임에서는 객체를 전혀 인식하지 못하는 경우도 발생했다..

이 문제를 해결하기 위해선 다음과 같은 부분에 대한 추가 고민이 필요할 것 같다.

끝날 때까지 끝난 게 아니다.
YOLO 프로젝트는 계속됩니다...

[실버 2] 백준 11279 - 최대 힙 (파이썬)

pental — Tue, 29 Jul 2025 15:52:07 +0900

분류 : 자료구조

링크 : https://www.acmicpc.net/problem/11279

풀이

백준 1927과 비슷한 문제이다. 1927 최소 힙 문제에서는 정석대로 heap에 값을 양수로 넣었지만, 이번 문제는 최대 힙을 구하는 문제이기에, -를 붙여서 음수로 넣어주면 힙에서는 최대 힙으로 정렬되게 된다.

이때 문제점은 pop 할때도 음수로 나오기에, 다시한번 -를 붙여주면, 최대 힙으로 출력 할 수 있다.

코드

# 백준 11729 - 최대 힙

import heapq
import sys

input = sys.stdin.readline
N = int(input())
heap = []

for i in range(N) :
    x = int(input())
    if x == 0 :
        if len(heap) > 0 :
            print(-heapq.heappop(heap))
        else :
            print(0)
    else :
        heapq.heappush(heap, -x)

[실버 2] 백준 1927 - 최소 힙 (파이썬)

pental — Tue, 29 Jul 2025 15:47:26 +0900

분류 : 자료구조

링크 : https://www.acmicpc.net/problem/1927

풀이

힙의 기초적인 문제이다. 사실 시간초과가 나긴했는데, sys.stdin.readline을 고려하지 못했다.

문제에서는 N이 최대 10만개이기 때문에 단순히 input()으로만으로는 당연히 시간 초과가 날 수 밖에 없다.

문제에서 N을 입력받고, 다음 N개의 줄에는 연산에 대한 정보를 나타내는 정수 X가 주어진다고 한다.

X가 0이 아닌 경우에는 배열에 자연수 X를 넣고, 0이라면 배열에서 가장 작은 값을 출력하고, 그 값을 배열에서 제거하면 된다.

이에 적합한 자료구조는 heap이기에 아래와 같은 코드로 작성하였다.

코드

# 백준 1927 - 최소 힙

import heapq
import sys

input = sys.stdin.readline
N = int(input())
heap = []

for i in range(N) :
    x = int(input())
    if x == 0 :
        if len(heap) > 0 :
            print(heapq.heappop(heap))
        else :
            print(0)
    else :
        heapq.heappush(heap, x)

[yolo11] YOLO를 활용한 차량 분류 시스템 개발기 (1) - YOLO란 무엇인가? + labelme 사용법

pental — Sat, 26 Jul 2025 20:21:46 +0900

블랙박스 영상에는 단순히 사고 장면을 담는 것 이상의 수많은 정보가 들어 있다. 차량의 움직임, 주변 상호, 도로 표시, 다른 차량 정보까지 — 이것들은 모두 범죄 수사, 보험 분쟁, 운전 패턴 분석 등 다양한 분야에서 활용될 수 있다.

이번 프로젝트에서는 이러한 영상 정보들을 좀 더 정형화된 데이터로 추출하여 분석하기 위해 여러 기능들을 구현하려고 한다.

그중 첫 번째는 가장 기본적이면서도 강력한 기능, 바로 차량 분류 시스템이다.

차량 분류 시스템이란?

예를 들어, 내가 주차 중 누군가의 차량에 의해 긁히는 뺑소니를 당했는데, 블랙박스 영상에는 차량의 외형만 찍혔다고 가정해본다.

이럴 경우, 차량 종류(승용차, SUV, 트럭 등) 만 알아도 용의 차량을 좁히는 데 큰 도움이 될거로 추정된다.

이 기능을 구현하기 위해 선택한 기술이 바로 YOLO (You Only Look Once)이다.

YOLO란 무엇인가?

YOLO(You Only Look Once)는 객체 탐지(Object Detection) 분야에서 가장 널리 쓰이는 딥러닝 모델 중 하나이다.

기존의 이미지 분류 모델과 달리, YOLO는 이미지 안에 있는 객체들의 위치와 종류를 한 번에 예측한다.

YOLO를 사용해보기 전에 블랙박스 영상의 샘플을 구해, 5분짜리 영상에서 1초 간격으로 총 300개의 이미지를 만들었다.

영상을 이미지로 만드는 것은 ffmpeg를 사용해 영상 -> 이미지로 변환하였다.

ffmpeg -i input.mp4 -vf fps=1 output_%04d.jpg

이제 만들어진 이미지에 객체를 학습하기 위해서 labelme 도구를 사용한다. 설치 방법과 실행은 다음과 같다.

Labelme는 이미지에 객체의 경계 박스를 그리거나 폴리곤 형태로 라벨링할 수 있는 Python 기반의 시각적 어노테이션 툴이다.

설치 방법과 실행은 다음과 같다.

pip install labelme

또는 가상환경을 사용하는 경우

conda create --name labelme_env python=3.8
conda activate labelme_env
pip install labelme

설치가 완료되면 단순히 터미널에서 다음과 같이 실행하면, labelme가 실행된다.

labelme

labelme가 실행되면 좌측 상단에서 이미지 샘플들을 불러올 수 있다. 단일 파일의 경우 Open File, 디렉터리에 있는 모든 이미지를 가져오려면 Open Dir을 클릭하면 된다.

필자 같은 경우는 sample 폴더를 선택해, 300장의 이미지를 모두 탑재했다.

위 사진은 이미 Polygon을 생성한 상태이고, Create Polygon 기능을 통해서 원하는 위치에 객체를 인식시킨다.

위와 같이 원하는 영역에 Polygon을 생성하고, 최초 점 위치를 클릭하면 다음과 같이 라벨링을 지정할 수 있는 창이 확인된다.

지금은 도로 내 점선을 인식시켰기 때문에, road_dotted_line으로 이름을 붙여주었다.

다음 사진으로 넘어가기 위해서는 키보드에서 A 나 D를 통해서 이전, 다음 이미지로 넘어 갈 수 있다. 또는 아래 버튼을 클릭 하면 이전, 다음 이미지로 넘어갈 수 있다.

300장의 이미지에서 일부 필요한 정보를 추출하여 ~~노가다~~를 진행한다.

노가다가 완료 되면, 샘플 이미지 파일 및 아까 마스킹 한 json 파일이 잘 저장되었는지 확인한다.

labelme 같은 경우는 json으로 반환해주는데, yolo에서 필요한 정보는 txt파일 형태로 되어 있어야 하기에, labelme2yolo를 통해서 yolo가 인식 할 수 있도록 변환해 주어야 한다.

pip install labelme2yolo

pental@pentalui-MacBookAir BLACKBOX % labelme2yolo --json_dir sample --val_size 0.15 --test_size 0.15

내가 사용한 명령줄은 위와 같으며, 실행 시키면 다음과 같이 진행되는것을 확인 할 수 있다.

지정한 경로에서 YOLODataset 폴더가 생성된 것을 확인 할 수 있고, 해당 폴더는 아래 사진과 같은 구조를 가지고 있다.

위와 같이 json에서 txt로 변환 된 것을 확인 할 수 있다.

다음편에서는 생성한 마스킹 정보를 바탕으로 yolo 학습 및 예측을 포스팅 할 예정이다.

[골드 3] 백준 16957 - 체스판 위의 공 (파이썬)

pental — Mon, 21 Jul 2025 09:46:05 +0900

분류 : DFS

링크 : https://www.acmicpc.net/problem/16957

풀이

각 공이 어디로 떨어지는가가 아니라 각 골짜기로 얼마나 많은 공이 모이는가를 역방향으로 계산한다.

각 칸에서 인접한 8방향 중 가장 낮은 칸으로 공이 흘러간다.

그 흐름을 역방향 그래프로 만들어 두고, 실제로 공이 도달할 수 있는 최종 지점부터 시작해서, 역으로 DFS를 돌며 얼마나 많은 공이 이 칸으로 오는지 세는 방식이다.

입력 처리

R, C = map(int, input().split())
B = [list(map(int, input().split())) for _ in range(R)]

dr = [0, 0, 1, 1, 1, -1, -1, -1]
dc = [1, -1, -1, 0, 1, -1, 0, 1]

B[r][c]는 r행 c열의 높이값을 나타내며, dr, dc는 8방향 이동을 위한 델타값이다.

흐름을 반대로 저장할 adj를 선언한다.

adj = {(r, c) : [] for r in range(R) for c in range(C)}
valley = []

adj[(r, c)]는 이 칸으로 공이 도달하는 출발 위치 리스트를 나타내며, valley의 경우 더 낮은 인접같이 없어 공이 머무르게 되는 칸을 나타낸다.

흐름 경로 설정

for r in range(R):
    for c in range(C):
        min_val = B[r][c]
        who = (-1, -1)
        for i in range(8):
            nr, nc = r + dr[i], c + dc[i]
            if 0 <= nr < R and 0 <= nc < C and B[nr][nc] < min_val:
                min_val = B[nr][nc]
                who = (nr, nc)
        
        if who != (-1, -1):
            adj[who].append((r, c))
        else:
            valley.append((r, c))

각 칸 (r, c)에서 가장 낮은 인접 칸 (nr, nc)를 찾고, 더 낮은 칸이 있으면 (nr, nc)로 공이 흐르므로 adj[(nr, nc)]에 (r, c)를 추가한다.

만약 없는 경우 골짜기로 간주한다.

def dfs(r, c):
    global count
    count += 1
    for (nr, nc) in adj[(r, c)]:
        dfs(nr, nc)

역방향 DFS로써, 현재 valley에서 이 칸으로 유입되는 모든 칸들을 방문하며, count에 누적한다.

for vr, vc in valley:
    count = 0
    dfs(vr, vc)
    answer[vr][vc] = count

각 골짜기마다 DFS를 실행해 얼마나 많은 공이 이 골짜기로 모이는지 카운트 하고, 그 수를 answer[vr][vc]에 기록한다.

그런데 이 풀이의 문제점은 중복 방문이 있다는 점이다.

예를 들어 (2, 2)가 여러 valley에 도달하는 경로 중 중복으로 포함되면, DFS에서 여러번 방문하게 되고, 결과적으로 전체 공 개수가 맞지 않게 된다.

코드

# 백준 16957 - 체스판 위의 공
# 분류 : DFS

from collections import deque

R, C = map(int, input().split())
B = [list(map(int, input().split())) for _ in range(R)]

adj = {(r, c) : [] for r in range(R) for c in range(C)}

dr = [0, 0, 1, 1, 1, -1, -1, -1]
dc = [1, -1, -1, 0, 1, -1, 0, 1]

valley = []

for r in range(R) :
    for c in range(C) :
        min_val = B[r][c]
        who = (-1, -1)
        for i in range(8) :
            nr, nc = r + dr[i], c + dc[i]
            if nr < 0 or R <= nr or nc < 0 or C <= nc :
                continue

            if min_val > B[nr][nc] :
                min_val = B[nr][nc]
                who = (nr, nc)
        
        if who != (-1, -1) :
            adj[who].append((r, c))
        else :
            valley.append((r, c))

count = 0

def dfs(r, c) :
    global count
    count += 1

    for (nr, nc) in adj[(r, c)] :
        dfs(nr, nc)
    
answer = [[0] * C for _ in range(R)]

for vr, vc in valley :
    count = 0
    dfs(vr, vc)
    answer[vr][vc] = count
    
for i in range(R) :
    print(*answer[i])

[실버 4] 백준 25214 - 크림 파스타 (파이썬)

pental — Sun, 20 Jul 2025 13:19:15 +0900

분류 : 다이나믹 프로그래밍

링크 : https://www.acmicpc.net/problem/25214

풀이

각 인덱스 i에 대해, D[i]는 A[0]부터 A[i]까지의 최솟값, E[i]는 E[i-1]과 (A[i] - D[i]) 중 더 큰 값이다.

즉, E[i]는 앞에서부터 지금까지의 최댓값을 유지하면서, A[i]에서 이전까지의 최솟값을 뺀 값 중 최대를 갱신한다.

D = [0] * N
E = [0] * N

D[i]는 A[0] ~ A[i] 중 최솟값을 나타내고, E[i]는 지금까지의 A[i] - D[i] 중 최대를 나타낸다.

D[0] = A[0]
for i in range(1, N) :
    D[i] = min(D[i - 1], A[i])

최솟값 갱신은 위와 같이 작성하며, D[i]는 A[0] ~ A[i]에서의 최솟값을 저장한다.

E[0] = 0
for i in range(1, N) :
    E[i] = max(E[i - 1], A[i] - D[i])

E[i]는 이전 최댓값과 현재 A[i] - D[i] 값 중 큰 것을 유지한다.

코드

# 백준 25214 - 크림 파스타
# 분류 : 다이나믹 프로그래밍

N = int(input())
A = list(map(int, input().split()))

D = [0] * N
E = [0] * N

D[0] = A[0]
for i in range(1, N) :
    D[i] = min(D[i - 1], A[i])

E[0] = 0
for i in range(1, N) :
    E[i] = max(E[i - 1], A[i] - D[i])

print(*E)

[골드 1] 백준 1311 - 할 일 정하기 1 (파이썬)

pental — Sat, 19 Jul 2025 13:41:13 +0900

분류 : 다이나믹 프로그래밍

링크 : https://www.acmicpc.net/problem/1311

풀이

이 문제는 N * N 크기의 비용 행렬 D가 주어지고, 사람 N명에게 각각 하나의 일을 배정하는데, 각 사람마다 각 일에 대한 비용이 다르다.

각 사람에게 정확히 하나의 일만, 각 일도 정확히 한 사람에게만 배정되도록 하면서 총 비용의 합을 최소화 해야한다.

초기 설정

cache = [[-1] * (2 ** N) for _ in range(N)]

cache[x][mask]는 x번째 사람까지 할당했을 때, mask 상태에서의 최소 비용을 저장한다.

기저 조건

if x == 0:
    for i in range(N):
        if mask == (2 ** i):
            cache[x][mask] = D[x][i]
            return D[x][i]

첫번째 사람에게 일을 한 개만 할당한 경우 해당 비용을 바로 반환한다.

재귀적으로 최소 비용을 계산

for i in range(N):
    if mask & (2 ** i) != 0:
        ret = min(ret, D[x][i] + dp(x - 1, mask - (2 ** i)))

현재 x번째 사람에게 i번째 일을 배정할 수 있는 경우에 대해, 그 비용과 이전 상태의 최소 비용을 더해서 ret를 갱신한다.

결과 반환

return dp(N - 1, (2 ** N) - 1)

사람 N명을 모두 배정한 경우, 모든 일이 사용되었을 때의 최소 비용을 출력한다.

코드

# 백준 1311 - 할 일 정하기 1
# 분류 : 다이나믹 프로그래밍
import sys
sys.setrecursionlimit(10**6)
input = sys.stdin.readline
N = int(input())
D = [list(map(int, input().split())) for _ in range(N)]

cache = [[-1] * (2 ** N) for _ in range(N)]
# N * (2 ^ N)
def dp(x, mask) :
    if cache[x][mask] != -1 :
        return cache[x][mask]

    if x == 0 :
        for i in range(N) :
            if mask == (2 ** i) :
                cache[x][mask] = D[x][i]
                return D[x][i]
    
    ret = 1e9
    for i in range(N) :
        if mask & (2 ** i) != 0 :
            ret = min(ret, D[x][i] + dp(x - 1, mask - (2 ** i)))
        
    cache[x][mask] = ret
    return ret
    
print(dp(N - 1, (2 ** N) - 1))

[골드 3] 백준 7579 - 앱 (파이썬)

pental — Fri, 18 Jul 2025 18:28:36 +0900

분류 : 다이나믹 프로그래밍

링크 : https://www.acmicpc.net/problem/7579

풀이

메모리 확보를 위해서 필요한 최소 비용을 구하는 문제다.

앱 N개가 있고, 각각 메모리 m[i], 비용 c[i]를 가진다.

총 확보해야 할 메모리는 M보다 크거나 같으며, 비용의 합이 최소가 되도록 하는 앱을 선택한다.

DP 테이블은 다음과 같이 정의한다.

D = [[0] * 10001 for _ in range(N)]

D[i][j]는 i번 앱까지 고려했을 때, 비용 j 이하로 확보 가능한 최대 메모리를 나타내며, 비용 최대치가 10000이므로 열 크기를 10001로 설정한다.

# D[0][i] : 첫 번째 앱만 사용할 때의 최대 메모리
for i in range(c[0], 10001) :
    D[0][i] = m[0]

초기화는 첫 앱의 비용보다 크거나 같은 비용 i에 대해서 m[0]만큼 확보가 가능하다.

점화식은 다음과 같이 구성한다.

for i in range(1, N) :
    for j in range(10001) :
        D[i][j] = D[i - 1][j]  # i번째 앱을 쓰지 않았을 때

        if j >= c[i] :
            # i번째 앱을 사용하는 경우와 비교하여 더 큰 메모리 확보
            D[i][j] = max(D[i][j], m[i] + D[i - 1][j - c[i]])

i번째 앱을 사용하지 않는 경우는 이전 상태를 그대로 유지하고, i번째 앱을 사용하는 경우 이전상태에서 비용 c[i]를 줄이고, 메모리 m[i]를 추가한다.

마지막으로 최소 비용을 탐색한다.

for i in range(10001) :
    if D[N - 1][i] >= M :
        print(i)
        break

마지막 행에서 메모리 ≥ M을 만족하는 가장 작은 비용 i를 출력한다.

코드

# 백준 7579 - 앱
# 분류 : 다이나믹 프로그래밍

N, M = map(int, input().split())
m = list(map(int, input().split()))
c = list(map(int, input().split()))

D = [[0] * 10001 for _ in range(N)]

# D[0][i], i < c[0] -> 0, i >= c[0] -> m[0]
for i in range(c[0], 10001) :
    D[0][i] = m[0]

for i in range(1, N) :
    for j in range(10001) :
        D[i][j] = D[i - 1][j]

        if j >= c[i] :
            D[i][j] = max(D[i][j], m[i] + D[i - 1][j - c[i]])

for i in range(10001) :
    if D[N - 1][i] >= M :
        print(i)
        break

[골드 5] 백준 11578 - 팀원 모집 (파이썬)

pental — Thu, 17 Jul 2025 15:28:43 +0900

분류 : 브루트포스 + 자료구조

링크 : https://www.acmicpc.net/problem/11578

풀이

1번부터 N번까지의 문제를 모두 풀 수 있는 최소한의 팀원수를 구하는 문제이다.

각 팀원은 자신이 풀 수 있는 문제 번호 리스트를 가지고 있다. 팀원은 M명이며, 문제를 모두 풀 수 있는 팀원의 최소 수를 구해야한다.

A = [list(map(int, input().split()))[1:] for _ in range(M)]
A = [set(a) for a in A]

각 팀원이 자신이 풀 수 있는 문제 번호들을 입력받는다.

list(map(int, input().split()))[1:] 에서 [1:] 부터 시작하는 이유는 첫 번째 숫자는 개수이므로 무시한다.

set(a)로 변환해서 나중에 합집한 연산을 쉽게 수행하도록 만든다.

예시는 다음과 같다.

A = [{1, 2}, {3, 4}, {2}]

answer = -1
for n in range(1, M + 1) :
    found = False

1명부터 M명까지 조합을 시도하며, n명이 모이면 모든 문제 (1 ~ N)를 커버할 수 있는지 확인한다.

    for combination in combinations(A, n) :
        U = set()
        for a in combination :
            U |= a

combination은 팀원 조합(set들의 리스트)를 나타내며 U |= a는 U = U.union(a)와 같다.

즉, 팀원들이 커버 가능한 문제들을 모두 합친다.

        if len(list(U)) == N :
            found = True
            break

U의 길이가 N이면 모든 문제를 커버했다는 뜻이므로, 더이상 탐색할 필요가 없어 break를 걸어준다.

코드

# 백준 11578 - 팀원 모집
# 분류 : 브루트포스 + set 자료구조

from itertools import combinations

N, M = map(int, input().split())
A = [list(map(int, input().split()))[1:] for _ in range(M)]
A = [set(a) for a in A]

answer = -1
for n in range(1, M + 1) :
    found = False
    for combination in combinations(A, n) :
        U = set()
        for a in combination :
            U |= a
        if len(list(U)) == N :
            found = True
            break

    if found : 
        answer = n
        break

print(answer)

[골드 2] 백준 2450 - 모양 정돈 (파이썬)

pental — Wed, 16 Jul 2025 17:17:12 +0900

분류 : 브루트포스

링크 : https://www.acmicpc.net/problem/2450

풀이

배열 A에는 1, 2, 3이 섞여있으면서, 각각 모양을 나타낸다.

이 배열을 구간 3개로 나누어서, 각 구간에는 한 가지 모양이 있도록 정렬해야 한다.

예를 들어서 [2, 2, 1, 1, 3, 3] 과 같은 형태이다.

단, 숫자들을 바꾸는 횟수를 최소화 해아한다.

입력 처리는 다음과 같다.

N = int(input())
A = list(map(int, input().split()))
A = [x - 1 for x in A]  # 0, 1, 2 로 바꿈

입력 배열을 x - 1을 통해서 0, 1, 2로 정규화한다.

그후 각 숫자의 개수를 센다.

count = [0] * 3
for x in A :
    count[x] += 1

예를 들어서 A = [0, 0, 1, 2, 1] → count = [2, 2, 1] 이다.

이후 순열을 통해 모든 배치를 시도한다.

for permutation in permutations(range(3), 3):

예를 들면 (0, 1, 2), (0, 2, 1) … 총 6가지 순서로 세 구간을 만들 수 있다.

구간을 미리 만들어 뒀으면 정렬된 상태의 목표 배열을 생성한다.

B = []
for x in permutation:
    B += [x] * count[x]

예를 들어서 count = [2, 2, 1] 이고, permutation = (1, 0, 2) 라면 B = [1, 1, 0, 0, 2]가 된다.

잘못 위치한 원소를 파악 하기 위해서 다음과 같디 정의 한다.

wrong = [[0]*3 for _ in range(3)]
for i in range(N):
    if A[i] != B[i]:
        wrong[A[i]][B[i]] += 1

wrong[i][j]는 i를 j로 바꿔야 함을 의미한다.

교화 가능한 부분 계산을 위해서 다음과 같이 정의한다.

for i in range(3):
    for j in range(i + 1, 3):
        tmp = min(wrong[i][j], wrong[j][i])
        num_changes += tmp
        wrong[i][j] -= tmp
        wrong[j][i] -= tmp
        remain = max(wrong[i][j], wrong[j][i])

i ↔ j 끼리 바꿔서 해결 가능한 개수는 min(wrong[i][j], wrong[j][i])이다.

이걸로 교환하고 남은 애들은 사이클로 해결해야 하기 때문이다.

위에서 말한 사이클은 다음과 같다.

num_changes += 2 * remain

예를 들어서 1→ 2, 2→ 3, 3 → 1과 같이 순환하는 경우는 2번 바꿔야 한다.

다 끝났다면 최소 교환 횟수를 저장한다.

answer = min(answer, num_changes)

코드

# 백준 2450 - 모양 정돈
# 분류 : 브루트포스

from itertools import permutations

N = int(input())
A = list(map(int, input().split()))
A = [x - 1 for x in A]

answer = 1e9
count = [0] * 3
for x in A :
    count[x] += 1

for permutation in permutations(range(3), 3) :
    B = []
    for x in permutation :
        B += [x] * count[x]
    
    wrong = [[0] * 3 for _ in range(3)]
    for i in range(N) :
        if A[i] != B[i] :
            wrong[A[i]][B[i]] += 1

    num_changes = 0
    remain = 0

    for i in range(3) :
        for j in range(i + 1, 3) :
            # i -> j, j -> i, a, b min(a, b)
            tmp = min(wrong[i][j], wrong[j][i])
            num_changes += tmp

            wrong[i][j] -= tmp
            wrong[j][i] -= tmp
            remain = max(wrong[i][j], wrong[j][i])

    # i -> j, j -> k, k -> i : 2번, 같은 수,
    num_changes += 2 * remain
    answer = min(answer, num_changes)

print(answer)

[플래티넘 5] 백준 1981 - 배열에서 이동 (파이썬)

pental — Tue, 15 Jul 2025 15:49:40 +0900

분류 : 이분 탐색 + BFS

링크 : https://www.acmicpc.net/problem/1981

풀이

N x N 크기의 정수 배열 A가 주어짐
(0, 0) → (N-1, N-1)까지 상하좌우로 이동 가능
단, 이동하는 칸의 숫자는 어떤 [min, max] 구간에 속해야 함
이때 max - min 의 최소값을 구하는 것이 목적

문제 풀이 아이디어는 다음과 같다.

배열의 값은 최대 200이므로 min ~ max 범위가 0~200 사이임
max - min <= mid라고 가정하고 이동이 가능한지 BFS로 검사함
mid 값을 이분 탐색으로 줄여나가며 최소값을 찾는 방식

초기 설정은 다음과 같이 진행한다.

low, high = 0, 200
answer = -1

mid = max_val - min_val 을 이분 탐색으로 줄여 나갈 범위이다.

이분 탐색을 시작한다.

while low <= high:
    mid = (low + high) // 2
    found = False

현재 mid를 고정하고, 어떤 min_val ~ max_val = min_val + mid 범위 내에서 시작점과 끝점을 동시에 포함하면서 도달 가능한지 확인한다.

모든 가능한 min_val을 탐색한다.

for min_val in range(200 - mid + 1):
    max_val = min_val + mid

max_val이 200을 넘지 않도록 탐색 범위를 제한한다.

시작점과 끝점이 범위에 포함되는지 확인한다.

if A[0][0] < min_val or max_val < A[0][0]:
    continue
if A[N-1][N-1] < min_val or max_val < A[N-1][N-1]:
    continue

시작점과 도착점이 범위 안에 들어있지 않으면 해당 구간은 유효하지 않다.

BFS 탐색을 시작한다.

visit = [[False]*N for _ in range(N)]
queue = deque()
queue.append((0, 0))
visit[0][0] = True

BFS로 이동 가능한지 확인하는 부분이다.

while queue:
    r, c = queue.popleft()
    for i in range(4):
        nr, nc = r + dr[i], c + dc[i]
        if nr < 0 or nr >= N or nc < 0 or nc >= N:
            continue
        if A[nr][nc] < min_val or A[nr][nc] > max_val:
            continue
        if not visit[nr][nc]:
            visit[nr][nc] = True
            queue.append((nr, nc))

min_val ~ max_val 범위 내 값만 탐색하면서 방문을 체크한다.

BFS 결과에 따른 이분 탐색을 갱신한다.

if visit[N - 1][N - 1]:
    found = True
    break

도착지까지 도달했으면 더 작은 mid도 가능할 수 있으므로 high 줄인다.

if found:
    answer = mid
    high = mid - 1
else:
    low = mid + 1

코드

# 백준 1981 - 배열에서 이동
# 분류 : 이분 탐색 + BFS

from collections import deque

N = int(input())
A = [list(map(int, input().split())) for _ in range(N)]

low, high = 0, 200
answer = -1
dr = [1, -1 ,0, 0]
dc = [0, 0, 1, -1]

while low <= high :
    mid = (low + high) // 2

    found = False

    for min_val in range(200 - mid + 1) :
        max_val = min_val + mid

        if A[0][0] < min_val or max_val < A[0][0] :
            continue
        if A[N - 1][N - 1] < min_val or max_val < A[N - 1][N - 1] :
            continue

        visit = [[False] * N for _ in range(N)]
        queue = deque()

        queue.append((0, 0))
        visit[0][0] = True

        while len(queue) != 0 :
            r, c= queue.popleft()

            for i in range(4) :
                nr, nc = r + dr[i], c + dc[i]

                if nr < 0 or N <= nr or nc < 0 or N <= nc :
                    continue
                if A[nr][nc] < min_val or max_val < A[nr][nc] :
                    continue
                if not visit[nr][nc] :
                    queue.append((nr, nc))
                    visit[nr][nc] = True
        
        if visit[N - 1][N - 1] :
            found = True
            break
    
    if found :
        answer = mid
        high = mid - 1
    else :
        low = mid + 1

print(answer)

[골드 5] 백준 14567 - 선수과목 (Prerequisite) (파이썬)

pental — Mon, 14 Jul 2025 17:02:21 +0900

분류 : 다이나믹 프로그래밍

링크 : https://www.acmicpc.net/problem/14567

풀이

총 N개의 과목이 주어지며, M개의 선수 조건이 주어진다.

모든 과목에 대해 가장 빠른 이수 학기를 출력해야한다.

N, M = map(int, input().split())
adj = [[] for _ in range(N)]

for _ in range(M) :
    a, b = map(int, input().split())
    a, b = a - 1, b - 1
    adj[b].append(a)

adj[b].append(a)는 b를 듣기 위해 a를 먼저 들어야 한다는 조건이므로, b에서 a로 역방향 간선을 저장한다.

즉, b의 선수 과목들을 adj[b]에 저장한다.

cache = [-1] * N

cache[i]는 i번 과목을 이수할 수 있는 가장 빠른 학기를 저장한다.

def dp(u) :
    if cache[u] != -1 :
        return cache[u]

    if len(adj[u]) == 0 :
        ret = 1
    else :
        ret = max([dp(v) + 1 for v in adj[u]])
    cache[u] = ret
    return ret

dp(u)는 과목 u를 듣기 위한 최소 학기 수를 반환한다.

선수 과목이 없으면 바로 1학기에 들을 수 있으며, 선수 과목이 있다면 그 중 가장 늦게 들을 수 있는 과목 + 1학기가 돼야 한다.

메모이제이션으로 중복 계산을 방지한다.

코드

# 백준 14567 - 선수과목 (Prerequisite)
# 분류 : 다이나믹 프로그래밍

import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 6)

N, M = map(int, input().split())
adj = [[] for _ in range(N)]

for _ in range(M) :
    a, b = map(int, input().split())
    a, b = a - 1, b - 1

    adj[b].append(a)

cache = [-1] * N
def dp(u) :
    if cache[u] != -1 :
        return cache[u]

    if len(adj[u]) == 0 :
        ret = 1
    else :
        ret = max([dp(v) + 1 for v in adj[u]])
    cache[u] = ret
    return ret

for i in range(N) :
    print(dp(i), end = " ")

[골드 3] 백준 1719 - 택배 (파이썬)

pental — Sun, 13 Jul 2025 11:29:27 +0900

https://www.acmicpc.net/problem/1719

분류 : 다익스트라

링크 : https://www.acmicpc.net/problem/1719

풀이

이 문제는 어느 경로로 가는 것이 최단 경로인지를 알아내는 문제이다.

각 도시(정점) 간의 최단 경로를 찾아야하며, 단순히 최단 거리만 출력하는 것이 아니라, 어디로 먼저 가야 하는지를 출력해야한다.

즉, i → j 로 갈 때 첫번째로 가야하는 도시를 출력해야하는 것ㅇ디ㅏ.

from queue import PriorityQueue

N, M = map(int, input().split())  # 도시 수 N, 도로 수 M
adj = [[] for _ in range(N)]      # 인접 리스트

# 간선 정보 입력
for _ in range(M):
    a, b, c = map(int, input().split())
    a, b = a - 1, b - 1            # 0-indexed
    adj[a].append((b, c))
    adj[b].append((a, c))

# 모든 정점쌍 최단 거리 저장할 2차원 리스트
dist = [[1e9] * N for _ in range(N)]

# 모든 정점에 대해 다익스트라 수행
for s in range(N):
    pq = PriorityQueue()
    pq.put((0, s))
    dist[s][s] = 0

    while pq.qsize() != 0:
        d, u = pq.get()
        if d != dist[s][u]:
            continue

        for v, w in adj[u]:
            if dist[s][v] > dist[s][u] + w:
                dist[s][v] = dist[s][u] + w
                pq.put((dist[s][v], v))

for i in range(N):
    for j in range(N):
        if i == j:
            print("-", end=" ")
        else:
            for k, w in adj[i]:
                if dist[i][j] == w + dist[k][j]:
                    print(k + 1, end=" ")
                    break
    print()

의도는 i → j 로 가는 최단 경로에서 처음으로 가야 할 노드 k를 찾고 싶은 것이다. i → k 간선이 있고, k → j까지 최단 거리라면 그게 최단 경로 일까?

이 방식은 단순한 거리 비교에 기반하고 있다.

dist[i][j] == w + dist[k][j] 조건을 만족하는 아무 노드나 찍는다.

하지만 최단 경로는 여러 개일 수도 있고, 경유 순서를 추적하지 않기 때문에 반례가 존재한다.

예시 반례를 다음과 같다.

1 -> 2-> 4, 1 -> 3 -> 4 둘다 거리가 2

근데 adj[1]에 2, 3 모두 연결되ㅓ 있고, dist[1][4] == w + dist[k][4] 조건을 만족한다.

어떤 걸 먼저 print 할지는 adj[1] 순서에 따라 달라진다.

항목 설명

장점	다익스트라를 N번 돌려서 모든 쌍의 최단 거리를 구함
문제점	최단 거리만 있고, 경로(특히 첫 번째 경유지) 추적을 하지 않음
오답 가능성	단순한 거리 비교로는 정확한 경로 추정이 안 됨 (정점 방문 흐름이 보장되지 않음)

일단은 코드가 맞았지만, 개선 방법을 요약하면 다음과 같다.

다익스트라 수행 중에 이 정점은 어디를 통해 처음 왔는가를 기록해야 한다.
즉, first[s][v] = u 또는 first[s][v] = first[s][u] 방식으로 추적이 필요하다.

코드

# 백준 1719 - 택배
# 분류 : 다익스트라

from queue import PriorityQueue

N, M = map(int, input().split())
adj = [[] for _ in range(N)]

for _ in range(M) :
    a, b, c = map(int, input().split())
    a, b = a - 1, b - 1
    adj[a].append((b, c))
    adj[b].append((a, c))

dist = [[1e9] * N for _ in range(N)]

for s in range(N) :
    pq = PriorityQueue()

    pq.put((0, s))
    dist[s][s] = 0

    while pq.qsize() != 0 :
        d, u = pq.get()
        if d != dist[s][u] :
            continue

        for v, w in adj[u] :
            if dist[s][v] > dist[s][u] + w :
                dist[s][v] = dist[s][u] + w
                pq.put((dist[s][v], v))

for i in range(N) :
    for j in range(N) :
        if i == j :
            print("-", end = " ")
        else :
            for k, w in adj[i] :
                if dist[i][j] == w + dist[k][j] :
                    print(k + 1, end = " ")
                    break
        
    print()

[Reversing.kr] Easy Crack

pental — Sat, 12 Jul 2025 20:22:04 +0900

흠,, 포렌식만 공부하다가 이제 리버싱도 슬슬 해볼까 해서 reversing.kr 을 풀어보기 시작했다.

역시 리버싱은 공부해도 어려운것 같다.. 포렌식 보다 훨씬 더,, 해당 포스팅은 포렌식 7년차의 리버싱 입문기라고 생각하고, 틀린점이 있어도 그냥 귀엽게 넘어가 주면 좋겠다.

Easy_CrackMe.exe의 파일은 다음과 같다.

FileName	Easy_CrackMe.exe
FileSize	40,960 Byte
CRC32	FE454D60
MD5	A74DB218A9175E0AE2CCFFB3476DD4CF
SHA-1	F153F26F16B5AE03E3A7BE7FFE5395E966051F3B

Easy_CrackMe.exe 를 실행하면 다음과 같은 창이 나타난다.

아무거나 입력 후 확인을 클릭하면 다음과 같이 Incorrect Password 와 같은 알림창이 나타난다.

IDA 9.1 Free를 통해서 파일을 연다.

IDA Free를 통해서 바이너리 파일을 열어보면 자동으로 시작점을 잡아 준다.

사실 IDA를 쓸줄은 모르지만 그래도 깔짝깔짝 써보려고 한다… 리버싱 입문자,,

먼저 초기에 정의되는 부분에서는 다음과 같은 힌트를 확인 할 수 있다.

이 상태에서 Tab 키를 누르면 디컴파일된 코드로 확인 할 수 있다.

사실 이게 중요한건 아니고, 위에서 순서대로 살펴보면 다음과 같다.

mov     eax, [esp+hInstance]
push    0               ; dwInitParam
push    offset DialogFunc ; lpDialogFunc
push    0               ; hWndParent
push    65h             ; lpTemplateName
push    eax             ; hInstance
call    ds:DialogBoxParamA
xor     eax, eax
retn    10h
_WinMain@16 endp

이 부분에서는 mov eax, [esp+hInstance] 에서는 스택에서 첫번쨰 인자 hInstace를 가져오는 것이다.

이 값은 WinMain(HINSTACE hInstace, …) 에서의 hInstace이다.

다음 push 인자들에서는 DialogBoxParamA함수의 인자들을 푸쉬하는 부분이다.

즉 다음과 같은 시그니처를 가진다고 할 수 있다.

INT_PTR DialogBoxParamA(
  HINSTANCE hInstance,
  LPCSTR lpTemplateName,
  HWND hWndParent,
  DLGPROC lpDialogFunc,
  LPARAM dwInitParam
);

중요한건 아닌것 같으니 넘어간다..

shift+F12를 통해서 사용되는 문자열을 확인 할 수 있으며, 위에서 Incorrect PAssword와 같은 문자열을 확인 했기에, IDA Strings 기능을 통해서 확인한다.

Strings에서는 74개의 문자열들이 발견 되었으며, Incorrect Password 및 Congratulaion !! 등의 문자열 패턴을 확인 할 수 있다.

아까 Incorrect Password 부분에서 잘못된 암호가 입력되었기 때문에, 해당 값을 더블클릭하여 어떤 구조로 되어 있는지 확인한다.

sub_401080에서 조건 문 들을 확인 할 수 있다.

cmp [esp+68h+Stirngs], 45h; ‘E’ 부분에서 cmp는 compare를 나타내며, 이 문자가 동일한지 확인하고, Congrautulation !! 이 출력되도록 하는 구조이다.

위에서 부터 차근차근 확인해 본다.

sub_401080 proc near

String= byte ptr -64h
var_63= byte ptr -63h
Str1= byte ptr -62h
var_60= byte ptr -60h
hDlg= dword ptr  4

sub     esp, 64h
push    edi
mov     ecx, 18h
xor     eax, eax
lea     edi, [esp+68h+var_63]
mov     [esp+68h+String], 0
push    64h ; 'd'       ; cchMax
rep stosd
stosw
stosb
mov     edi, [esp+6Ch+hDlg]
lea     eax, [esp+6Ch+String]
push    eax             ; lpString
push    3E8h            ; nIDDlgItem
push    edi             ; hDlg
call    ds:GetDlgItemTextA
cmp     [esp+68h+var_63], 61h ; 'a'
jnz     short loc_401135

첫 함수의 시작에서는 다이얼로그 박스에서 에디트박스의 텍스트를 읽어온 후, 그 텍스트의 첫번쨰 문자가 ‘a’ 인지 확인하는 함수이다.

push    2               ; MaxCount
lea     ecx, [esp+6Ch+Str1]
push    offset Str2     ; "5y"
push    ecx             ; Str1
call    _strncmp
add     esp, 0Ch
test    eax, eax
jnz     short loc_401135

그 다음 함수는 strcpm를 호출하여, Str1이라는 버퍼의 값이 문자열 “5y”와 같은지를 확인하고, 앞에서 부터 두 글자만 비교하고, 같지 않으면 loc_401135로 분기하는 함수이다.

push    ebx
push    esi
mov     esi, offset aR3versing ; "R3versing"
lea     eax, [esp+70h+var_60]

위에서 조건이 맞다면, 문자열 “R3versing”의 주소를 esi에 저장한다.

이 문자열은 PE 리소스의 .rdata 섹션 등에 존재하는 고정 문자열일 가능성이 높다.

그리고, 지역 변수 var_60의 주소를 계산해서 eax에 저장한다. 즉, eax = 문자열을 복사할 목적지 버퍼의 주소를 나타낸다.

cmp     [esp+68h+String], 45h ; 'E'
jnz     short loc_401135

이건 간단히 말하면 스택에 있는 String이라는 버퍼의 첫 번째 바이트가 ‘E’ 인지 검사하고, 그렇지 않으면 loc_401135로 점프하는 조건문이다.

결국 지금까지 나온 값들을 종합하면 ‘Ea5yR3versing’ 이 정답이 되게 된다.

[골드 5] 백준 14284 - 간선 이어가기 2 (파이썬)

pental — Sat, 12 Jul 2025 12:33:39 +0900

https://www.acmicpc.net/problem/14284

풀이

이 문제는 조금 방향 없는 그래프, 즉 무방향 그래프가 주어지며, 정점수 N, 간선수 M이 주어진다.

각 간선은 가중치를 가지며, 출발점 S에서 도착점 T까지의 최단 거리를 구하는 문제이다.

이 문제에세의 핵심 알고리즘은, 단연코 다익스트라 알고리즘이라고 할 수 있다.

먼저 가중치가 있는 그래프에서 하나의 시작점에서 다른 모든 정점까지의 최단 경로를 구하는 알고리즘이며, 이 문제에서는 특정 시작점에서 특정 도착점 까지의 거리만 구하면 된다.

from queue import PriorityQueue

우선순위 큐는 최소 거리 기준으로 정점을 꺼내기 위해서 위와 같이 사용한다.

N, M = map(int, input().split())
adj = [[] for _ in range(N)]

정점수와 간선수 및 인접 리스트 방식으로 그래프를 저장하기 위해서 위와 같이 선언한다.

for _ in range(M):
    a, b, c = map(int, input().split())
    a, b = a - 1, b - 1
    adj[a].append((b, c))
    adj[b].append((a, c))

위와 같이 간선 정보를 입력받으며, 양방향 간선이므로, adj[a], adj[b]에 각각 추가한다.

S, T = map(int, input().split())
S, T = S - 1, T - 1

시작점 S, 도착점 T 입력 및 1-Base-Index를 0-Based-Index로 수정한다.

dist = [1e9] * N
pq = PriorityQueue()

pq.put((0, S))
dist[S] = 0

dist의 경우 시작점에서 각 정점까지의 최단 거리를 저장하며, 시작점 S는 거리 0으로 초기화, 나머지는 무한대로 미리 초기화 해둔다.

또한 우선순위 큐에 (거리, 정점) 형태로 삽입한다.

while pq.qsize() != 0:
    d, u = pq.get()

    if d != dist[u]:
        continue

큐에서 현재 가장 거리가 짧은 정점 u를 꺼내며, 꺼낸 값 d가 dist[u]와 다르면 이미 더 짧은 거리로 처리되었으므로 스킵한다.

    for v, w in adj[u]: 
        if dist[v] > dist[u] + w:
            dist[v] = dist[u] + w
            pq.put((dist[v], v))

인접한 정점 v에 대해서 현재까지 알려진 거리보다 더 짧은 경로가 있으면 업데이트한다.

print(dist[T])

마지막으로 dist[T]를 출력하면 S에서 T까지의 최단 거리를 출력 하는 것이다.

시간 복잡도

O(M Log N) → 우선순위 큐 기반 다익스트라 사용

코드

# 백준 14284 - 간선 이어가기 2
# 분류 : 다익스트라

import sys
from queue import PriorityQueue

input = sys.stdin.readline

N, M = map(int, input().split())
adj = [[] for _ in range(N)]

for _ in range(M) :
    a, b, c = map(int, input().split())
    a, b = a - 1, b - 1

    adj[a].append((b, c))
    adj[b].append((a, c))

S, T = map(int, input().split())
S, T = S - 1, T - 1

dist = [1e9] * N
pq = PriorityQueue()

pq.put((0, S))
dist[S] = 0

while pq.qsize() != 0 :
    d, u = pq.get()

    if d != dist[u] :
        continue
    
    for v, w in adj[u]: 
        if dist[v] > dist[u] + w :
            dist[v] = dist[u] + w
            pq.put((dist[v], v))

print(dist[T])

[골드 5] 백준 17072 - 나무 위의 빗물 (파이썬)

pental — Fri, 11 Jul 2025 17:35:31 +0900

https://www.acmicpc.net/problem/17073

풀이

이 문제는 비의 양 W가 루트 노드에 고이며, 나무는 N개의 정점으로 이루어진 트리이고, 루트 노드는 1번이다.

비는 모든 리프 노드까지 동일하게 분배되며, 각 리프 노드까지 고인 빗물의 양을 구하는 문제이다.

결국 이 문제를 해결하는 방법은 다음과 같다.

트리는 사이클이 없는 연결 그래프이므로, DFS로 리프 노드를 쉽게 찾을 수 있다.
루트에서 DFS를 돌려 리프 노드의 개수를 센다.
전체 물이의 양 W를 리프 노드 개수로 나눈다.
1. 리프노드마다 동일한 양의 물이 고이기 때문이다.

먼저 정점 수, 물의 양을 입력받는 인접 리스트를 생성한다.

N, W = map(int, input().split())
adj = [[] for _ in range(N)]

N은 트리의 정점 개수, W는 전체 빗물의 양, adj는 트리의 구조를 표현하는 인접 리스트를 의미한다.

for _ in range(N - 1):
    u, v = map(int, input().split())
    u -= 1
    v -= 1
    adj[u].append(v)
    adj[v].append(u)

트리는 N - 1개의 간선을 가지며, 입력된 정점 번호는 1부터 시작하므로 0부터 시작하도록 0-Index based 형식으로 처리한다

무방향 그래프이므로 adj[u], adj[v] 양쪽에 추가한다.

방문 처리 배열 및 리프 노드 수를 초기화 한다.

visit = [False] * N
count = 0

visit의 경우 DFS 중복 방문 방지용 배열이며, count는 리프 노드의 개수를 셀 변수를 나타낸다.

다음은 DFS 함수를 정의한다.

def dfs(u):
    visit[u] = True
    is_leaf = True

    for v in adj[u]:
        if not visit[v]:
            dfs(v)
            is_leaf = False
    
    if is_leaf:
        global count
        count += 1

u는 현재 방문 중인 노드를 의미하며 is_leaf는 자식 노드가 있는지 확인한다.

자식이 있으면 리프가 아니므로 is_leaf = False로 리프 노드인 경우 count를 증가시킨다.

결국 전체적인 흐름은 다음과 같다.

트리 구조를 입력받고 인접 리스트를 구성한다.
DFS로 루트부터 탐색하면서 리프 노드 개수를 파악한다.
물의 양 W를 리프 노드 수 count로 나눠서 정답을 출력한다.

코드

# 백준 17073 - 나무 위의 빗물
# 분류 : DFS + 수학

import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 6)

N, W = map(int, input().split())
adj = [[] for _ in range(N)]

for _ in range(N - 1) :
    u, v = map(int, input().split())
    u -= 1
    v -= 1

    adj[u].append(v)
    adj[v].append(u)

visit = [False] * N
count = 0

def dfs(u) :
    visit[u] = True
    is_leaf = True

    for v in adj[u] :
        if not visit[v] :
            dfs(v)
            is_leaf = False
    
    if is_leaf :
        global count
        count += 1

dfs(0)
print(W / count)

[골드 4] 백준 20159 - 동작 그만. 밑장 빼기냐?

pental — Wed, 9 Jul 2025 16:56:29 +0900

https://www.acmicpc.net/problem/20159

풀이

플레이어가 번갈아 가면서 카드를 가져간다.

짝수 번째(0, 2, 4 … )는 내차례, 홀수 번째는 상대 차례이다.

마지막 카드 1장을 상다 차례에서 내가 가져도록 1번의 밑장 빼기를 허용한다.

최대 점수를 얻기 위해 밑장 빼기를 어느 위치에서 할지를 결정해야한다.

psum0 = [0] * N  # 내 차례에서의 누적합
psum1 = [0] * N  # 상대 차례에서의 누적합

psum0[0] = A[0]
psum1[0] = 0

for i in range(1, N):
    if i % 2 == 0:  # 내 차례
        psum0[i] = psum0[i - 1] + A[i]
        psum1[i] = psum1[i - 1]
    else:           # 상대 차례
        psum0[i] = psum0[i - 1]
        psum1[i] = psum1[i - 1] + A[i]

i번째 카드가 내 차례인지 상대 차례인지를 나누어 각각의 누적합 배열을 구성한다.

def range_sum0(l, r): ...
def range_sum1(l, r): ...

누적합을 이용한 구간 합 함수를 각각 구현한다.

sum0의 경우 내 차례인 카드들 중 l ~ r의 합을 나타내고, sum1의 경우 상대 차례인 카드들 중 l ~ r의 합을 나타낸다.

밑장 빼기 시뮬레이션은 다음과 같이 진행한다.

answer = psum0[N - 1]  # 밑장 안 뺐을 경우의 기본 점수

for i in range(N):
    score = range_sum0(0, i - 1) + range_sum1(i, N - 2)
    if i % 2 == 0:
        score += A[N - 1]  # 밑장 빼기 성공하면 마지막 카드 얻음
    
    answer = max(answer, score)

i는 밑장을 빼는 위치이고, range_sum0, range_sum1을 통해서 밑짱 빼기 시뮬레이션을 진행한다.

코드

# 백준 20159 - 동작 그만. 밑장 빼기냐?
# 분류 : 누적합

N = int(input())
A = list(map(int, input().split()))

psum0 = [0] * N
psum1 = [0] * N
psum0[0] = A[0]
psum1[0] = 0

for i in range(1, N) :
    if i % 2 == 0 :
        psum0[i] = psum0[i - 1] + A[i]
        psum1[i] = psum1[i - 1]
    else :
        psum0[i] = psum0[i - 1]
        psum1[i] = psum1[i - 1] + A[i]

def range_sum0(l, r) :
    if l > r :
        return 0
    ret = psum0[r]
    if l > 0 :
        ret -= psum0[l - 1]
    return ret

def range_sum1(l, r) :
    if l > r :
        return 0
    ret = psum1[r]
    if l > 0 :
        ret -= psum1[l - 1]
    return ret

answer = psum0[N - 1]
for i in range(N) :
    score = range_sum0(0, i - 1) + range_sum1(i, N - 2)
    if i % 2 == 0 :
        score += A[N - 1]
    
    answer = max(answer, score)

print(answer)

[실버 4] 백준 29767 - 점수를 최대로 (파이썬)

pental — Wed, 9 Jul 2025 16:55:01 +0900

https://www.acmicpc.net/problem/29767

풀이

길이가 N인 정수 수열 A가 주어지며, 누적합(A[0]부터 A[i]까지의 합)을 구해 전체 N개의 누적합 중 K개를 선택해서 합을 최대로 만들어야한다.

N, K = map(int, input().split())
A = list(map(int, input().split()))

N은 원소 개수, K는 선택할 누적합 개수를 입력 받는다.

psum = [0] * N
psum[0] = A[0]

for i in range(1, N):
    psum[i] = psum[i - 1] + A[i]

psum[i]는 A[0] + A[1] + … + A[i]를 의미하며, 즉, 누적합 배열을 만든다.

psum.sort(reverse=True)
print(sum(psum[:K]))

누적합 배열을 내림차순 정렬한 뒤, 상위 K개의 값을 선택하여 더한 결과를 출력한다.

결국 이 문제 풀이의 아이디어는 누적합은 앞에서부터의 합이므로 psum[i]는 i + 1개 원소의 부분합니다.

점수를 최대로 하려면 가장 큰 누적합들만 선택하면 되고, 따라서 누적합 배열을 정렬해 상위 K개만 골라서 더하면 해결 할 수 있는 문제이다.

코드

# 백준 29767 - 점수를 최대로
# 분류 : 누적합 + 그리디

N, K = map(int, input().split())
A = list(map(int, input().split()))

psum = [0] * N
psum[0] = A[0]

for i in range(1, N) :
    psum[i] = psum[i - 1] + A[i]

psum.sort(reverse=True)
print(sum(psum[:K]))

[플래티넘 5] 백준 1050 - 물약 (파이썬)

pental — Tue, 8 Jul 2025 16:29:13 +0900

https://www.acmicpc.net/problem/1050

풀이

여러개의 기초 물약은 가격이 주어지고, 일부 물약은 다른 물약들로 조합하여 만들 있다.

조합은 "LOVE=A+2B" 같은 형태로 주어진다.
목표: 물약 “LOVE”를 만드는데 필요한 최소 비용 계산하는 것이다.

N, M = map(int, input().split())
stuff = {}

N은 가격이 주어진 물약 수를 나타내며, M은 조합식 수를 나타낸다.

for _ in range(N) :
    name, cost = input().split()
    cost = int(cost)
    stuff[name] = cost

가격이 주어진 물약은 딕셔너리 stuff에 저장한다.

formulas = [input() for _ in range(M)]

LOVE = 2A + 3B 형식으로 전체 조합식을 저장한다.

for i in range(M) :
    result, formula = formulas[i].split("=")
    
    if result not in stuff :
        stuff[result] = -1  # 아직 계산 안 됨
    
    elements = formula.split("+")
    for e in elements :
        k = int(e[0])
        name = e[1:]
        if name not in stuff :
            stuff[name] = -1  # 조합에 필요한 것도 초기화

-1은 아직 비용 계산이 안된 물약을 나타낸다.

while True :
    update = False

    for i in range(M) :
        result, formula = formulas[i].split("=")
        elements = formula.split("+")

        computable = True
        sum = 0
        for e in elements :
            k = int(e[0])
            name = e[1:]

            if stuff[name] == -1 :
                computable = False
                break
            else :
                sum += k * stuff[name]
                sum = min(sum, MAX_VAL)  # 오버플로 방지

        if computable :
            if stuff[result] == -1 or stuff[result] > sum :
                stuff[result] = sum
                update = True

    if not update :
        break

모든 조합식을 순회하면서, 조합 가능한 경우에만 최소 비용을 갱신한다.

갱신이 일어났으면 한 번 더 반복하며, 더이상 갱신이 없으면 종료한다.

코드

# 백준 1050 - 물약
# 분류 : 자료구조

import re

N, M = map(int, input().split())
MAX_VAL = 10000000001

stuff = {}
for _ in range(N) :
    name, cost = input().split()
    cost = int(cost)
    stuff[name] = cost

formulas = [input() for _ in range(M)]

for i in range(M) :
    result, formula = formulas[i].split("=")
    
    if result not in stuff :
        stuff[result] = -1
    
    elements = formula.split("+")
    for e in elements :
        k = int(e[0])
        name = e[1 : ]

        if name not in stuff :
            stuff[name] = -1

while True :
    update = False

    for i in range(M) :
        result, formula = formulas[i].split("=")
        elements = formula.split("+")

        computable = True
        sum = 0
        for e in elements:
			    match = re.match(r"(\\d+)([A-Z]+)", e)
			    k = int(match[1])
			    name = match[2]
			
			    if name not in stuff or stuff[name] == -1:
			        computable = False
			        break
			    else:
			        cost = k * stuff[name]
			        if cost > MAX_VAL:
			            cost = MAX_VAL
			        sum += cost
			        if sum > MAX_VAL:
			            sum = MAX_VAL

        if computable :
            if stuff[result] == -1 or stuff[result] > sum :
                stuff[result] = sum
                update = True

    if not update :
        break

if "LOVE" in stuff and stuff["LOVE"] != -1 :
    print(stuff["LOVE"])
else :
    print(-1)

[골드 2] 백준 2461 - 대표 선수 (파이썬)

pental — Mon, 7 Jul 2025 16:39:10 +0900

https://www.acmicpc.net/problem/2461

분류 : 정렬 + 우선순위 큐

링크 : https://www.acmicpc.net/problem/2461

풀이

N개의 반이 있고, 각 반에는 M명의 학생이 있음.
각 학생마다 실력이 있고, 각 반에서 한 명씩 대표로 뽑아서 실력 차이를 최소로 하고 싶음.
즉, N명의 대표를 뽑을 때 최소 실력차가 가장 작은 집합을 만들고, 그 차이를 출력해야 함.

from queue import PriorityQueue

• Python 표준 라이브러리의 우선순위 큐 (최소 힙 역할) 사용

N, M = map(int, input().split())
A = [list(map(int, input().split())) for _ in range(N)]

N개의 반마다 M명의 학생 실력을 입력 받음
A[i][j]는 i번째 반의 j번째 학생 실력

for i in range(N):
    A[i].sort()

각 반의 학생 실력을 정렬해서 가장 작은 수부터 선택할 수 있도록 함

pq = PriorityQueue()  # 최소 힙
pos = [0] * N          # 각 반의 현재 선택된 인덱스
max_val = 0

pq: (값, 반 번호) 형태로 우선순위 큐에 저장
max_val: 현재 선택된 값 중 가장 큰 값

for i in range(N):
    pq.put((A[i][0], i))         # 각 반에서 가장 작은 학생을 우선 삽입
    max_val = max(max_val, A[i][0])  # 초기 최대값 갱신

각 반에서 실력이 가장 낮은 학생부터 시작

while True:
    min_val, id = pq.get()     # 현재까지의 최솟값과 그 반의 번호
    answer = min(answer, max_val - min_val)  # 차이 최소 갱신

현재 pq에는 각 반에서 하나씩 뽑힌 학생들이 들어 있음
이 중 제일 실력이 낮은 학생을 꺼냄 → min_val
이 집합에서 최대 실력(max_val)과의 차이를 계산해서 answer 갱신

    pos[id] += 1
    if pos[id] >= M:
        break

해당 반의 다음 학생으로 이동
만약 그 반에서 더 이상 뽑을 수 없으면 반복 종료

    pq.put((A[id][pos[id]], id))
    max_val = max(max_val, A[id][pos[id]])

새로운 학생을 우선순위 큐에 추가
최대 실력 갱신

코드

# 백준 2461 - 대표 선수
# 분류 : 정렬 + 우선순위 큐

from queue import PriorityQueue

N, M = map(int, input().split())
A = [list(map(int, input().split())) for _ in range(N)]

for i in range(N) :
    A[i].sort()

pq = PriorityQueue()
pos = [0] * N
max_val = 0
for i in range(N) :
    pq.put((A[i][0], i))
    max_val = max(max_val, A[i][0])

answer = 1e9
while True :
    min_val, id = pq.get()
    answer = min(answer, max_val - min_val)

    pos[id] += 1

    if pos[id] >= M :
        break

    pq.put((A[id][pos[id]], id))
    max_val = max(max_val, A[id][pos[id]])

print(answer)

포렌식 & 개발 이야기 - Forensics & Development

인터넷이 안되는 시골집에 CCTV 설치하기

[2025 DFC] 2025 디지털포렌식 챌린지 - 301 - 404 VMK Not Found

[2025 DFC] 2025 디지털포렌식 챌린지 - 207 – iBackup Trace

[2025 DFC] 2025 디지털포렌식 챌린지 - 206 – Let’s Vibe

[2025 DFC] 2025 디지털포렌식 챌린지 - 203 - Ooops, your files have ben encrypted!

[2025 DFC] 2025 디지털포렌식 챌린지 - 201 - Look at the Quote

palera1n을 통한 아이폰 탈옥 및 SSH 접근

[25년 2회차] 제11회 빅데이터분석기사 합격 후기 (필기 & 실기)

[브론즈 2] 백준 2703 - Cryptoquote (파이썬)

[빅데이터분석기사] 실기 대비 4일차 - 기출문제 4회

작업형 1유형 문제 1

작업형 1유형 문제 2

작업형 1유형 문제 3

작업형 2유형

[빅데이터분석기사] 실기 대비 3일차 - 기출문제 3회

작업형 1유형 문제 1

작업형 1유형 문제 2

작업형 1유형 문제 3

작업형 2유형

[빅데이터분석기사] 실기 대비 2일차 - 기출문제 2회

작업형 1유형 문제 1번

작업형 1유형 문제 2번

작업형 1유형 문제 3번

작업형 2유형

[빅데이터분석기사] 실기 대비 1일차 - 모의고사

작업형 1유형 1번 문제

작업형 1유형 2번 문제

작업형 1유형 3번 문제

작업형 2유형

작업형 3유형 1번 문제

작업형 3유형 2번 문제

[포렌식] 카카오톡 수정된 메시지 및 삭제된 메시지 분석 및 복구 (25.10.07)

[58회] SQLD 합격 후기

공부 과정

공부 일지

공부 방법

추천 자료

합격 소감

SQLD 준비하는 분들께 ✏️

[브론즈 2] 백준 1673 - 치킨 쿠폰 (파이썬)

[브론즈 2] 백준 1718 - 암호 (파이썬)

[브론즈 2] 백준 1592 - 영식이와 친구들 (파이썬)

[브론즈 1] 백준 1524 - 세준세비 (파이썬)

[브론즈 2] 백준 1452 - 피시방 알바 (파이썬)

[브론즈 2] 백준 1440 - 타임머신 (파이썬)

[브론즈 2] 백준 1263 - 펫 (파이썬)

[브론즈 1] 백준 1356 - 유진수 (파이썬)

[브론즈 2] 백준 1297 - TV 크기 (파이썬)

[브론즈 2] 백준 1350 - 진짜 공간 (파이썬)

나스 서버 교체 후기 (8베이 나스, 녹투아 쿨러)

[실버 5] 백준 11723 - 집합 (파이썬)

백준 5522, 10178, 9295, 10569, 2921 (파이썬)

[실버 3] 백준 6666 - Help Me with the Game (파이썬)

풀이

코드

[골드 4] 백준 2661 - 좋은수열 (파이썬)

풀이

코드

[yolo11] YOLO를 활용한 차량 분류 시스템 개발기 (2) - Yolo를 통해 객체 인식하기

[실버 2] 백준 11279 - 최대 힙 (파이썬)

풀이

코드

[실버 2] 백준 1927 - 최소 힙 (파이썬)

풀이

코드

[yolo11] YOLO를 활용한 차량 분류 시스템 개발기 (1) - YOLO란 무엇인가? + labelme 사용법

차량 분류 시스템이란?

YOLO란 무엇인가?

[골드 3] 백준 16957 - 체스판 위의 공 (파이썬)

풀이

코드

[실버 4] 백준 25214 - 크림 파스타 (파이썬)

풀이

코드

[골드 1] 백준 1311 - 할 일 정하기 1 (파이썬)

풀이

코드

[골드 3] 백준 7579 - 앱 (파이썬)

풀이