BlowFish.pbi

Hier könnt Ihr gute, von Euch geschriebene Codes posten. Sie müssen auf jeden Fall funktionieren und sollten möglichst effizient, elegant und beispielhaft oder einfach nur cool sein.
Antworten
Benutzeravatar
roherter
Beiträge: 1407
Registriert: 10.04.2005 18:58
Kontaktdaten:
Kontaktdaten von roherter

Beitrag von roherter »

Habe noch einen anderen Code gefunden werde eine dll daraus erstellen und die dll in mein Programm mit einbinden.
Danke für die Mühe. :allright:
Purebasic 5.0 32bit und 64 bit

I'm back from hell
Nach oben
Benutzeravatar
Konne
Beiträge: 764
Registriert: 30.03.2005 02:20
Kontaktdaten:
Kontaktdaten von Konne

Beitrag von Konne »

Wo haste die denn gefunden?
Nach oben
Christian
Beiträge: 73
Registriert: 31.08.2004 16:02

Beitrag von Christian »

Hallo!

Ich habe mal eine Frage zu den Werten in der DataSection: Diese sollen ja die Hexadezimalwerte von Pi sein.
Wie kann ich denn die angegebenen Hexadezimalwerte in die Dezimalwerte von Pi umrechnen?

Nehme ich beispielsweise

Code: Alles auswählen

Debug $243f6a88
Um den ersten Datenblock zu ermitteln, komme ich auf eine Ziffernfolge (608135816), die nicht wirklich was mit der Kreiszahl zu tun hat. Könnt ihr mir vieleicht helfen, wo ich einen Denkfehler habe?

Gruße
Christian
Nach oben
Benutzeravatar
Helle
Beiträge: 566
Registriert: 11.11.2004 16:13
Wohnort: Magdeburg

Beitrag von Helle »

@Christian: Die Zahl Pi steht nicht als solche (3.1415...) da, sondern die Nachkomma-Stellen sind als binäre Potenz-Werte angegeben, deren Wertigkeiten aufaddiert werden müssen.
Also: $243f6a88 ist binär 00100100001111110110101010001000, wichtig sind auch führende Nullen! Die linke erste Stelle hat den Wert 2 hoch minus 1, also 0.5; die zweite Stelle hat den Wert 0.25 usw. Nullen zählen natürlich nicht, also ist der erste Wert (3.Stelle) 0.125. Der nächste dazu zuaddierende Wert ist 2^-6, also 0,015625, ergibt 0,140625 usw. Die Summe ergibt dann irgendwann 0.1415926535897932384626433832795...
Viel Spass :D !

Gruss
Helle
Nach oben
Christian
Beiträge: 73
Registriert: 31.08.2004 16:02

Beitrag von Christian »

Hallo Helle!

Danke für deine Antwort. Für einen Block habe ich das jetzt soweit verstanden. Aber wie füge ich dann zum Beispiel den ersten und den zweiten Block zusammen? Einfach aneinanderhängen?

Gruß
Christian
Nach oben
Benutzeravatar
Helle
Beiträge: 566
Registriert: 11.11.2004 16:13
Wohnort: Magdeburg

Beitrag von Helle »

Hi Christian,
wenn du mit "Block" das nächste DWord meinst wird einfach der (negative) Exponent weitergezählt, also das MSB (höchstes Bit) von 85A308D3 hat den Wert 2^-33. Aus Jux hier ein schnell zusammengestoppeltes Prog, erhellende Debug-Ausgaben habe ich drin gelassen. In jedem Schritt wird der Vorgängerwert durch 2 geteilt und wenn vom BlowFish-Wert das entsprechende Bit gesetzt ist wird dieser Wert zum Gesamtwert zuaddiert. Die Division durch 2 habe ich als 5-fach Addition mit nachfolgender Stellenverschiebung realisiert.

Code: Alles auswählen

;- Aus Jux Pi´s Nachkommastellen aus BlowFish-DATA "rückberechnen"
;- "Helle" Klaus Helbing, 24.05.2007, PB v4.02
;- Völlig unoptimierter Code! Nicht meckern! :-)
;- Nicht als exakten Pi-Wert benutzen! Hier sind ca.die ersten 170 Stellen genau.

Global X1.b

  !lea edi,[String1]
  !mov byte[edi+1023],1 ;Startwert für Berechnung minus-2-er-Potenzen

W1:
;erstmal aktuellen Wert berechnen
;------- Ausgangswert umkopieren für 5=4+1
  !lea edi,[String1]
  !add edi,1023
  !lea esi,[String2]
  !add esi,1023
  !mov ebx,[Len] 
!@@:
  !mov al,[edi]
  !mov [esi],al
  !dec edi
  !dec esi
  !dec ebx
  !jns @b

;-------
  !mov edx,2            ;Zähler für x4 
W1_1:                   ;für Schleife x4 
  !lea edi,[String1]
  !add edi,1023         ;Ende des Strings
  !mov ebx,[Len]
  !xor ah,ah
W0_1:                   ;für Schleife x2
  !mov al,[edi]
  !add al,al
  !add al,ah

  !xor ah,ah
  !cmp al,10
  !jb l_nicht_10
  !sub al,10
  !inc ah

Nicht_10:
  !mov [edi],al
  !dec edi
  !dec ebx
  !jns l_w0_1

  !dec edx
  !jnz l_w1_1           ;zweiter Durchlauf für 2+2

;- hier 4+1 als "Multiplikation" mit 5
  !xor ah,ah
  !mov ebx,[Len]
  !lea edi,[String1]
  !add edi,1023
  !lea esi,[String2]
  !add esi,1023
W3_1:                
  !mov al,[edi]
  !mov dl,[esi]
  !add al,dl
  !add al,ah

  !xor ah,ah
  !cmp al,10
  !jb l_nicht_10_1
  !sub al,10
  !inc ah

Nicht_10_1:
  !mov [edi],al
  !dec edi
  !dec esi
  !dec ebx
  !jns l_w3_1

  !inc [Len]

!pushad
!lea esi,[String1]
!mov ecx,[Len]
!mov ebx,1024
!sub ebx,ecx
!@@:
!mov al,[esi+ebx]
!mov [v_X1],al
!pushad
X$+Str(X1)
!popad
!inc ebx
!dec ecx
!jnz @b
Debug X$
X$=""
!popad

  !xor ah,ah
  !mov ebx,[Len]
  !lea edi,[String3]
  !add edi,1023
  !lea esi,[String1]
  !add esi,1023

  !sub edi,ebx
W22:
  !mov al,[edi]
  !mov [edi-1],al
  !inc edi
  !dec ebx
  !jns l_w22

  !mov ebx,[Len]
  !dec edi              ;wieder Ausgangswert
  !mov byte[edi],0h

;- hier Gesamtsumme bilden
  !cmp [DWZ],0          ;DWord-Zähler
  !jne @f
  !push esi
  !push edi 
  !mov [DWZ],32
  !mov edi,[BFZ]
  
  !lea esi,[BlowFish_K+edi]
  !add [BFZ],4
  !mov eax,[esi]
  !pop edi
  !pop esi

  !or eax,eax
  !jz l_ende
  !mov [Bits],eax

!@@:
  !dec [DWZ]
  !shl [Bits],1
  !jnc l_w1
  !xor ah,ah

W3_11:                
  !mov al,[edi]
  !mov dl,[esi]
  !add al,dl
  !add al,ah

  !xor ah,ah
  !cmp al,10
  !jb l_nicht_10_11
  !sub al,10
  !inc ah

Nicht_10_11:
  !mov [edi],al
  !dec edi
  !dec esi
  !dec ebx
  !jns l_w3_11

!lea esi,[String3]
!mov ecx,[Len]
!mov ebx,1024
!sub ebx,ecx
!@@:
!mov al,[esi+ebx]
!mov [v_X1],al
!pushad
X$+Str(X1)
!popad
!inc ebx
!dec ecx
!jnz @b
Debug ""
Debug "Zwischensumme: "
Debug X$
Debug ""
X$=""

   !jmp l_w1

Ende:

  !lea esi,[String3]
  !mov ecx,[Len]
  !mov ebx,1024
  !sub ebx,ecx
  !@@:
  !mov al,[esi+ebx]
  !mov [v_X1],al
  !pushad
  X$+Str(X1)
  !popad
  !inc ebx
  !dec ecx
  !jnz @b

MessageRequester("Pi aus BlowFish-DATA, nur Nachkomma-Stellen", X$)

End

;--------
!section '.data' Data readable writeable

!String1    RB 1024          ;eigentlicher Berechnungs-String 
!String2    RB 1024          ;Hilfs-String für die Multiplikation mit 5 = 4 + 1
!String3    RB 1024          ;Aufsummierungs-String
!BlowFish_K DD 0243F6A88h    ;sind die Werte von DATA
!           DD 085A308D3h
!           DD 013198A2Eh
!           DD 003707344h 
!           DD 0A4093822h
!           DD 0299F31D0h
!           DD 0082EFA98h
!           DD 0EC4E6C89h 
!           DD 0452821E6h
!           DD 038D01377h
!           DD 0BE5466CFh
!           DD 034E90C6Ch 
!           DD 0C0AC29B7h
!           DD 0C97C50DDh
!           DD 03F84D5B5h
!           DD 0B5470917h 
!           DD 09216D5D9h
!           DD 08979FB1Bh
!           DD 0             ;hier als End-Marker
!Len        DD 0
!DWZ        DD 0
!BFZ        DD 0
!Bits       DD 0
Gruss
Helle

Edit: Fehler, der ab Stelle 480 auftrat, beseitigt. 27.05.2007
Zuletzt geändert von Helle am 27.05.2007 19:37, insgesamt 1-mal geändert.
Nach oben
Benutzeravatar
Helle
Beiträge: 566
Registriert: 11.11.2004 16:13
Wohnort: Magdeburg

Beitrag von Helle »

Die BlowFisch_Sx-Blöcke sind natürlich immer die Fortsetzung der Pi-Nachkommastellen.
Für die Klärung einiger Ungereimtheiten habe ich die Berechnung der Hex-Werte von Pi benötigt. Hier der Code:

Code: Alles auswählen

;- Beispiel für Pi´s Nachkommastellen in Hex-Werte umrechnen
;- 512 Nachkommastellen, 50 DWords hex
;- "Helle" Klaus Helbing, 27.05.2007, PB v4.02
;- Völlig unoptimierter Code! Nicht meckern! :-)

Global X1.b
Global X4.l

  !lea edi,[String1]
  !mov byte[edi+2047],1   ;Startwert für Berechnung minus-2-er-Potenzen

W1:
;Minus-2-er-Potenzen berechnen
;------- Ausgangswert umkopieren für 5=4+1
  !lea edi,[String1]
  !add edi,2047
  !lea esi,[String2]
  !add esi,2047
  !mov ebx,[Len] 
!@@:
  !mov al,[edi]
  !mov [esi],al
  !dec edi
  !dec esi
  !dec ebx
  !jns @b

;-------
  !mov edx,2                 ;Zähler für x4 
W1_1:                        ;für Schleife x4 
  !lea edi,[String1]
  !add edi,2047              ;Ende des Strings
  !mov ebx,[Len]
  !xor ah,ah
W0_1:                        ;für Schleife x2
  !mov al,[edi]
  !add al,al
  !add al,ah

  !xor ah,ah
  !cmp al,10
  !jb l_nicht_10
  !sub al,10
  !inc ah

Nicht_10:
  !mov [edi],al
  !dec edi
  !dec ebx
  !jns l_w0_1

  !dec edx
  !jnz l_w1_1                ;zweiter Durchlauf für 2+2

;- hier 4+1 als "Multiplikation" mit 5
  !xor ah,ah
  !mov ebx,[Len]
  !lea edi,[String1]
  !add edi,2047
  !lea esi,[String2]
  !add esi,2047
W3_1:                
  !mov al,[edi]
  !add al,[esi]
  !add al,ah

  !xor ah,ah
  !cmp al,10
  !jb l_nicht_10_1
  !sub al,10
  !inc ah

Nicht_10_1:
  !mov [edi],al
  !dec edi
  !dec esi
  !dec ebx
  !jns l_w3_1
;- Ende Berechnung der 2-er-Potenz

;- Ausgabe der 2-er-Potenz
 !jmp l_z
!pushad
!lea esi,[String1]
!mov ecx,[Len]
!mov ebx,2047
!sub ebx,ecx
!@@:
!mov al,[esi+ebx]
!mov [v_X1],al
!pushad
X$+Str(X1)
!popad
!inc ebx
!dec ecx
!jns @b
Debug X$
X$=""
!popad
 Z:
;- Ende Ausgabe

;- StringPi-String1, String1 wird verändert
;- Teil von String1 in StringSub kopieren
  !mov ecx,[Len]
  !lea esi,[String1]
  !mov ebx,2047
  !sub ebx,ecx
  !lea edi,[StringSub]
!@@:
  !mov al,[esi+ebx]
  !mov [edi],al
  !inc edi
  !inc ebx
  !dec ecx
  !jns @b

;- StringPi minus String1
  !mov ebx,[Len]
Q:
  !mov al,[StringPi+ebx]
  !sub al,[StringSub+ebx]
  !jnc l_q2
  !jz l_q2
  !add al,10
  !push ebx
!@@:
  !dec ebx
  !js l_bit0                 ;Bit0 schreiben und weiter; Len+1, nächste 2-er-Potenz, neuen 
                             ; Vergleichsstring (StringPi) einlesen mit Länge Len
  !inc [StringSub+ebx] 
  !cmp [StringSub+ebx],10
  !jb @f
  !mov [StringSub+ebx],0
  !jmp @b
!@@:
  !pop ebx
Q2:
  !mov [StringErg+ebx],al    ;Ziffer in Ergebnis schreiben
  !dec ebx
  !jns l_q
                      
  !mov ebx,[Len]
  !mov [Bits+ebx],1          ;Bit1 schreiben, Len(StringPi)-(String1) und in StringPi schreiben

;- StringErg in StringPi schreiben
  !lea esi,[StringPi]
  !lea edi,[StringErg]
!@@:
  !mov al,[edi]
  !mov [esi],al
  !inc edi
  !inc esi
  !dec ebx
  !jns @b
  !jmp l_ende_test

Bit0:                        ;Bit0 schreiben
  !pop ebx
  !mov ebx,[Len]
  !mov [Bits+ebx],0

Ende_Test:
;- Test auf Ende
  !inc [Len]                 ;Länge der 2-er-Potenz
  !cmp [Len],1600            ;50 DWords a 32 Bit
  !jb l_w1

Ende:                
!jmp l_r
  !lea esi,[Bits]
  !mov ecx,[Len]
  !xor ebx,ebx
  !@@:
  !mov al,[esi+ebx]
  !mov [v_X1],al
  !pushad
  X$+Str(X1)
  !popad
  !inc ebx
  !dec ecx
  !jnz @b
  Debug X$                   ;Binäre Darstellung für Test
R:

  !mov ecx,[Len]
  !xor esi,esi               ;Zeiger in StringHex

TT:
  !xor edx,edx
T:
  !mov ebx,[BitZ]            ;Zeiger in Bits
  !mov edi,4                 ;4 Nibbles
  !mov eax,dword[Bits+ebx]
  !bswap eax
!@@: 
  !shl edx,1
  !shl eax,8
  !adc edx,0
  !dec edi
  !jnz @b
 
  !add [BitZ],4
  !test [BitZ],4
  !jnz l_t
   
  !mov byte[StringHex+esi],dl 
  !inc esi 
  
  !cmp [BitZ],1600           ;50 DWords a 32 Bit 
  !jb l_tt

  !xor ebx,ebx
Ausgabe:
  !mov eax,[StringHex+ebx]
  !bswap eax
  !mov [v_X4],eax
  !pushad
  X$ + RSet(Hex(X4),8,"0") + "      "
  !popad
  !test ebx,4
  !jz @f
  !test ebx,8
  !jz @f
  !pushad
  X$ + #LFCR$
  !popad
!@@: 
  !add ebx,4
  !cmp ebx,200               ;zum Test 50 DWords
  !jb l_ausgabe

MessageRequester("Pi´s Nachkommastellen in Hex", X$)

End

;--------
!section '.data' Data readable writeable

!String1    RB 2048          ;eigentlicher Berechnungs-String, Pi (;-)) mal Daumen reserviert
!String2    RB 2048          ;Hilfs-String für die Multiplikation mit 5 = 4 + 1
!StringSub  RB 2048          ;Hilfs-String für die Subtraktion
!StringErg  RB 2048          ;Ergebnis-String für die Subtraktion
!Bits       RB 2048          ;für die einzelnen Bits
!StringHex  RD 50            ;50 DWords Ausgabe 
!Len        DD 0
!BitZ       DD 0
!StringPi   DB 1,4,1,5,9,2,6,5,3,5,8,9,7,9,3,2,3,8,4,6,2,6,4,3,3,8,3,2,7,9 ;oder von Datei einlesen
!           DB 5,0,2,8,8,4,1,9,7,1,6,9,3,9,9,3,7,5,1,0,5,8,2,0,9,7,4,9,4,4
!           DB 5,9,2,3,0,7,8,1,6,4,0,6,2,8,6,2,0,8,9,9,8,6,2,8,0,3,4,8,2,5
!           DB 3,4,2,1,1,7,0,6,7,9,8,2,1,4,8,0,8,6,5,1,3,2,8,2,3,0,6,6,4,7
!           DB 0,9,3,8,4,4,6,0,9,5,5,0,5,8,2,2,3,1,7,2,5,3,5,9,4,0,8,1,2,8
!           DB 4,8,1,1,1,7,4,5,0,2,8,4,1,0,2,7,0,1,9,3,8,5,2,1,1,0,5,5,5,9
!           DB 6,4,4,6,2,2,9,4,8,9,5,4,9,3,0,3,8,1,9,6,4,4,2,8,8,1,0,9,7,5
!           DB 6,6,5,9,3,3,4,4,6,1,2,8,4,7,5,6,4,8,2,3,3,7,8,6,7,8,3,1,6,5
!           DB 2,7,1,2,0,1,9,0,9,1,4,5,6,4,8,5,6,6,9,2,3,4,6,0,3,4,8,6,1,0
!           DB 4,5,4,3,2,6,6,4,8,2,1,3,3,9,3,6,0,7,2,6,0,2,4,9,1,4,1,2,7,3
!           DB 7,2,4,5,8,7,0,0,6,6,0,6,3,1,5,5,8,8,1,7,4,8,8,1,5,2,0,9,2,0
!           DB 9,6,2,8,2,9,2,5,4,0,9,1,7,1,5,3,6,4,3,6,7,8,9,2,5,9,0,3,6,0
!           DB 0,1,1,3,3,0,5,3,0,5,4,8,8,2,0,4,6,6,5,2,1,3,8,4,1,4,6,9,5,1
!           DB 9,4,1,5,1,1,6,0,9,4,3,3,0,5,7,2,7,0,3,6,5,7,5,9,5,9,1,9,5,3
!           DB 0,9,2,1,8,6,1,1,7,3,8,1,9,3,2,6,1,1,7,9,3,1,0,5,1,1,8,5,4,8
!           DB 0,7,4,4,6,2,3,7,9,9,6,2,7,4,9,5,6,7,3,5,1,8,8,5,7,5,2,7,2,4 
!           DB 8,9,1,2,2,7,9,3,8,1,8,3,0,1,1,9,4,9,1,2,9,8,3,3,6,7,3,3,6,2
!           DB 4,4

!Dummy      RB 1088          ;1600-512, hier wird "Fortsetzng" von StringPi reingeschrieben!
Gruss
Helle
Nach oben
Christian
Beiträge: 73
Registriert: 31.08.2004 16:02

Beitrag von Christian »

Hi!

Entschuldige, dass ich mich solange nicht gemeldet habe, aber ich hatte in letzter Zeit kaum Gelegenheit mal ins Net zu schauen.

Danke für deine Erklärung. Ich kann zwar kein ASM und verstehe den Code daher nicht annähernd, aber ich habe zumindest die grundlegende Fundktionsweise verstanden.

Vielen Dank! :)

Gruß
Christian

[Edit:] Dein Tutorial zum Thema habe ich auch gerade entdeckt ... auch dafür herzlichen Dank!
Nach oben
Antworten

Zurück zu „Code, Tipps und Tricks“