c64scene.pl

To oczywiście tak żart gdyby coś takiego istniało i pisalibyśmy w asm na PC a potem w translator i mamy na C64.
Nie o tym będę pisał, napiszę to w ten sposób:
W ostatnim czasie troszkę się aktywowałem na rynku C64 i zamierzam coś tam sklecić, popróbować sił lub zwał jak kto chce. Mam jednak mały problemik, ktoś na moich starych dyskach pozakładał mi hasła na takie tam programiki w tym turbo dopalacze na irq do czytania dyskietek, program do łączenia pojedynczych plików w całości, program do relokowania muzyki itp. -znam tego gościa co mi to zrobił, przydusiłem go do ściany i...
Niestety on już nie pamięta tych haseł.
Mógłbym poszukać na internecie czegoś w zastępstwie, ale jakoś tak mam, że lubię mieć w pamięci to co znam osobiście.
Tego zapominalskiego przydusiłem do ściany i w końcu wpadłem na pomysł jak rozwiązać problem odzyskania tych haseł. Hasła są 5 literowe -czyli nie wielkie, program dekodujący będzie działał ze 3 dni -ale w końcu dopasuje owe hasło.
Sęk w tym, że mam sklerozę co do niektórych komend i tutaj właśnie proszę o pomoc bo nie sztuką uruchomić program na 3 dni i nie doczekać się efektu z powodu błędu w tłumaczeniu z asm C64 na asm PC.
Kod rozkodowujący w C64 wygląd tak:

Kod: Zaznacz cały

lda $0800,x
eor $02c0
clc
adc $02c1
eor $02c2
sec
sbc $02c3
eor $02c4
sta $0800,x

jak łatwo zauważyć hasło znajduje się od adresu $02c0, ale nie chodzi mi o to gdzie co jest w pamięci
w PC zakodowałem to:

Kod: Zaznacz cały

mov al,[mem_1]
xor al,[znak1]
clc
adc al,[znak2]
xor al,[znak3]
stc
sbb al,[znak4]
xor al,[znak5]
mov [mem_2],al

ogólnie tak to chyba powinno być przetłumaczone, ale może ktoś to potwierdzi lub poprawi zanim uruchomię program na 3 dni?

A nie lepiej pozostac na c64 i uruchomic to w vice na warpie?

5 znaków -nie wiadomo jakich, ale ich kody ascii będą z zakresu 0-127 -czyli 128 kombinacji. Dopasowanie 5 znaków przy tych kombinacjach to 128x128x128x128x128=34359738368 kombinacji. Do tego po każdej z kombinacji 32 bajty do porównania. C64 liczyłby to chyba miesiąc. Dlatego napisałem to w zwykłym asm do PC pod DOS -uruchomię w ten sposób kompa i dawaj, a VICA pod Windą -20 razy więcej kodu do przetworzenia.

Taki pytanie dla coder'ów z C64,
rozkaz EOR co dokładnie robi na bajcie, tzn. mnie się wydaje, że to wygląda w ten sposób
lda #%11110000
eor #%11110000
wynik w akumulatorze to #%00000000
czy się mylę?

Nie podałeś sposobu jak chcesz sprawdzać prawidłowość hasła, masz zdeszyfrowany jakiś program i będziesz porównywał rezultat? Czy jakaś heurystyka?
Aby zoptymalizować program proponuje na początek ograniczyć zgadywane hasło do dużych liter i znaków. Finalnie pamiętaj, że C64 nie używa ASCII tylko PETSCII
https://en.wikipedia.org/wiki/PETSCII

EOR to oczywiście operacja Exclusive OR:
Obrazek

Z tego co napisałeś EOR na C64 to nic innego jak XOR z assemblera x86 czy x64 na PC.
Szczegółowo opisując mój program polega na tym, że jest fragment zakodowanego kodu -mam też ten sam fragment kodu nie zakodowany, mam też wiedzę o tym jak następuje dekodowanie.
Pomysł był krótki, napisać program który przepuszcza 32 bajty przez procedurę dekodującą a następnie porównuje te wartości z fragmentem rozkodowanym.
Ale dzięki za podpowiedź z tym PETSCII -teraz wiem (bo skleroza u mnie zapanowała, gdyż kiedyś świetnie poruszałem się na C64), że każde z 5 znaków mogą znajdować się w zakresie 0-127. -innym słowem procedurę można skrócić o połowę na każdym znaku.
Wykorzystując mój stary program do asemblera działający na komputerach x86 uruchamiany pod DOS zwany Turbo Maszynowy -dostępny do pobrania na mojej stronie stworzyłem kod:

Kod: Zaznacz cały

                 push     CS
                 pop      DS
                 push     word ptr $b800
                 pop      ES
:skok_2
                 mov      AL,[:kod_1]
                 es:
                 mov      [#0],AL

                 mov      AL,[:kod_2]
                 es:
                 mov      [#2],AL

                 mov      AL,[:kod_3]
                 es:
                 mov      [#4],AL

                 mov      AL,[:kod_4]
                 es:
                 mov      [#6],AL

                 mov      AL,[:kod_5]
                 es:
                 mov      [#8],AL

                 xor      BX,BX
:skoks_1
                 mov      AL,[BX+:zakodowane]
                 call     :mechanizm
                 mov      [BX+:testowo],AL
                 inc      BX
                 cmp      BX,$20
                 jnz      :skoks_1
                 ;teraz porównanie
                 xor      SI,SI
:skoks_3
                 mov      AL,[SI+:testowo]
                 cmp      AL,[SI+:odkodowane]
                 jnz      :skoks_2
                 inc      SI
                 cmp      SI,$20
                 jnz      :skoks_3

                 call     :kody

                 mov      AX,$4cff
                 int      $21
:skoks_2
                 inc      byte ptr [:kod_1]
                 cmp      byte ptr [:kod_1],$80
                 jnz      :skok_1
                 mov      byte ptr [:kod_1],$00

                 inc      byte ptr [:kod_2]
                 cmp      byte ptr [:kod_2],$80
                 jnz      :skok_1
                 mov      byte ptr [:kod_2],$00

                 inc      byte ptr [:kod_3]
                 cmp      byte ptr [:kod_3],$80
                 jnz      :skok_1
                 mov      byte ptr [:kod_3],$00

                 inc      byte ptr [:kod_4]
                 cmp      byte ptr [:kod_4],$80
                 jnz      :skok_1
                 mov      byte ptr [:kod_4],$00

                 inc      byte ptr [:kod_5]
                 cmp      byte ptr [:kod_5],$80
                 jnz      :skok_1

                 mov      AX,$4cff
                 int      $21
:skok_1
                 jmp      /:skok_2

:odkodowane      db       $a2,$62,$bd,$00,$08,$9d,$00,$03
                 db       $e8,$d0,$f7,$4c,$62,$03,$a9,$01
                 db       $85,$fb,$85,$fd,$a2,$08,$86,$fe
                 db       $e8,$86,$fc,$78,$a9,$38,$85,$01

:zakodowane      db       $7a,$ba,$91,$dc,$c4,$71,$dc,$db
                 db       $24,$0c,$2f,$88,$ba,$bd,$5d,$d5
                 db       $59,$53,$59,$51,$7a,$c4,$5e,$56
                 db       $24,$5e,$58,$d4,$5d,$14,$59,$d5
:testowo         space    (#32)

:mechanizm
                 xor      AL,[:kod_1]
                 clc
                 adc      AL,[:kod_2]
                 xor      AL,[:kod_3]
                 stc
                 sbb      AL,[:kod_4]
                 xor      AL,[:kod_5]
                 ret
:kod_1           db       $0
:kod_2           db       $0
:kod_3           db       $0
:kod_4           db       $0
:kod_5           db       $0
:task            db       "0123456789abcdef"
:text            db       "00 00 00 00 00",$d,$a,"$"

:kody
                 mov      BL,[:kod_1]
                 mov      BH,BL
                 and      BL,$f
                 shr      BH,#4
                 movzx    DI,BL
                 movzx    SI,BH
                 mov      AL,[SI+:task]
                 mov      [:text],AL
                 mov      AL,[DI+:task]
                 mov      [:text+#1],AL


                 mov      BL,[:kod_1+#1]
                 mov      BH,BL
                 and      BL,$f
                 shr      BH,#4
                 movzx    DI,BL
                 movzx    SI,BH
                 mov      AL,[SI+:task]
                 mov      [:text+#3],AL
                 mov      AL,[DI+:task]
                 mov      [:text+#4],AL


                 mov      BL,[:kod_1+#2]
                 mov      BH,BL
                 and      BL,$f
                 shr      BH,#4
                 movzx    DI,BL
                 movzx    SI,BH
                 mov      AL,[SI+:task]
                 mov      [:text+#6],AL
                 mov      AL,[DI+:task]
                 mov      [:text+#7],AL

                 mov      BL,[:kod_1+#3]
                 mov      BH,BL
                 and      BL,$f
                 shr      BH,#4
                 movzx    DI,BL
                 movzx    SI,BH
                 mov      AL,[SI+:task]
                 mov      [:text+#9],AL
                 mov      AL,[DI+:task]
                 mov      [:text+#10],AL

                 mov      BL,[:kod_1+#4]
                 mov      BH,BL
                 and      BL,$f
                 shr      BH,#4
                 movzx    DI,BL
                 movzx    SI,BH
                 mov      AL,[SI+:task]
                 mov      [:text+#12],AL
                 mov      AL,[DI+:task]
                 mov      [:text+#13],AL

                 mov      DX,:text
                 mov      AH,#9
                 int      $21
                 ret

EOR = XOR, tak dokładnie, operacja Exclusive OR.
Czyli masz zdekodowany tekst do deszyfrowania, to olbrzymie ułatwienie. Fajnie, że podpowiedź o PETSCII pomogła, możesz jeszcze zawęzić zakres poszukiwań eliminując początek - znaki typu enter, esc itd...
Nie jestem mega obeznany w ASMie x86, program imho wygląda w porządku. Pisząc to samo w C/C++ uzyskasz max 2x wolniejszą szybkość[a może i 2x przyśpieszenie, dzisiejsze kompilatory potrafią zdziałać magię] za to wsio będzie łatwe do przeczytania i modyfikacji.
Tak czy owak życzę powodzenia

c64scene.pl

Translator assemblera (czyli problemy z pamięcia)

Translator assemblera (czyli problemy z pamięcia)

Re: Translator assemblera (czyli problemy z pamięcia)

Re: Translator assemblera (czyli problemy z pamięcia)

Re: Translator assemblera (czyli problemy z pamięcia)

Re: Translator assemblera (czyli problemy z pamięcia)

Re: Translator assemblera (czyli problemy z pamięcia)

Re: Translator assemblera (czyli problemy z pamięcia)