Im Buffer größere Hex-ketten schreiben!

[whitelion]

keine ahnung, evtl. hab ich mich auch nur blöd aus gedrückt. ich versuche nochmal meinen wunsch bzw das ziel zu äußern.

ich würde gerne:

1. mehere hex-ketten am anfang eines programmes (einfach der übersicht halber) definieren. damit ich selbige nach belieben anpassen könnte!
ich möchte NICHT jedes mal den kompletten source durchwühlen, nur weil ich an diesen hexketten was ändern muss!

fernes ziel:
2. am besten liegen beliebig viele (naja 20 reichen auch erstmal) hexketten in einer txt/ini-datei, die dann jeweils ausgelesen wird und in verschiedene namige buffer gepackt werden!

traum:
3. noch besser diese datei wird hinten ans programm gehängt und aus den resourcen geladen!


anmerkungen:
entweder hab ich das einfach nur extrem blöde beschrieben, oder es ist tatsächlich so umständlich. jedenfalls finde ich es schon erstaunlich wie umständlich es mit PB ist, einen buffer mit mehr als 4 bzw 8 bytes zu definieren!!! - schließlich ist es ja BASIC und nicht CPP !

[ts-soft]

Ist doch nicht schwer, alles wissenswerte wurde dir eigentlich mitgeteilt.
Hex ist nur zur Darstellung (fürs Auge)! Ins memory kommt der Wert!

[whitelion]

schwer hab ich auch nciht geschrieben, ich finde es umständlich. weniger umständlich würde ich finden, wenn es so gehen würden:

buffer1 = AllocateMemory(50)
hexwert1 = hex"010101010010101010...."
buffer1(hexwert1,0)

wobei die 0 die zu beschriebende bufferposition anzeigt. DAS wäre einfach!

wie auch immer, muss man wohl eine funktion bauen oder so... ich hab auch noch nciht so viel ahnung!

allerdings versteh ich immernoch nicht wie ich jetzt mehr als 4 bytes mit dem code in gewünschter definition in den buffer schreiben kann (sowie in hexwert1).

hier gehts doch auch nur mit 4 bytes oder wie soll ich mit "num" mehr als 4 definieren!

num = $01010101001 ; <--- geht nicht, da zu lang!!!!

Code: Alles auswählen

For i = 1 To 10
   byte = num - (num >> 8) << 8
   num >> 8
   
   Debug Hex(byte)
Next

[Kaeru Gaman]

das würde ja bedeuten, dass du einen zig-stelligen hexwert verarbeiten könntest.
das entbehrt aber jeglichen bedarfs.
2^64-1, also die obere grenze einer 64bit zahl oder $FFFFFFFFFFFFFFFF sind ja schon über 18 trilliarden.
mit jeder hinzukommenden hexadezimalstelle multipliziert sich das mit 16.
128 bit sind schon 3,4*10^38, das ist das zig-fache eines Mol.
es gibt einfach keinerlei verwendung für noch größere zahlen.

wenn du Hex-Ketten schreiben willst, dann hast du einen speicherbereich, den du so oder so zellenweise ansprechen willst/musst/kannst.

vielleicht würde dir auch sowas helfen:

Code: Alles auswählen

DataSection
Data.b $20, $FE, $C3, $7F
EndDataSection

PS:
außerdem läßt du gerade ein reihenfolge-problem außer acht:
wenn du eine Hex-Zahl hättest:
"72F83C8B34A93E682D967C8294B868934A9087D982364FE3",
dann würde die E3 als erstes und die 72 als letztes im Speicher stehen...

[ts-soft]

Hab so das Gefühl, hier ist nicht Hex sondern Bin gemeint

Code: Alles auswählen

Debug %01010101001

[whitelion]

neeeeeeeee hex soll es sein, der buffer wird hinterher per writeprocessmemory (API) in den speicher bzw. einen prozess geschrieben.
das ganze funktioniert .... und das ist auch gut so.... auch mit einem (beliebig?)großen buffer.

ist doch auch logisch, wenn ich meinetwegen einen prozess patche (wer sich mit reversing auskennt weiss das), kommt man schnell mal in die lage mehrere bytes verändern zu müssen! - je nach dem was man halt macht!
auf jeden fall wisst ihr jetzt wieso, wobei ich jetzt auch nciht verstehe was das problem an der sache mit größeren hexwerten ist ? - ich will selbigen nicht verarbeiten im sinne von mathematischen berechnungen, sondern diese hexwerte sind modifizierte assemblerbefehle die einen teil der codesection überschreiben! - das ganze soll ein loader werden, der evtl auch als eine art gametrainer funktioniert.... und bitte sagt mir jetzt nicht, dass ein trainer ja eigentlich variablen patcht..... es geht halt oft auch anders oder besser in der codesection zu patchen, was außerdem mehr möglichkeiten bietet....

[HeX0R]

Nimm dir eine Datasection, wie Kaeru bereits vorgeschlagen hat:

Code: Alles auswählen

DataSection
	
	Hex_Kette_1:
	Data.b 10 ;<-Die folgende Kette ist 10 Bytes Lang
	;Kette sieht so aus: $104ab45f65bbc4556beecde
	Data.b $10, $4a, $b4, $5f, $65, $bb, $c4, $55, $6b, $ee
	
	Hex_Kette_2:
	Data.b 5 ;<-Die folgende Kette ist 5 Bytes Lang
	;Kette sieht so aus: $5734f654ed
	Data.b $57, $34, $f6, $54, $ed
	;...
	
EndDataSection

Procedure KopiereKetteInProzess(*SourceAddress.BYTE, *Destinationsaddress, ProcessID.l)
	Protected i.l, Length.l, Result.l
	
	Length = *SourceAddress\b & $FF
	*SourceAddress + 1
	Result = WriteProcessMemory_(ProcessID, *Destinationsaddress, *SourceAddress, Length, #Null)
	
	ProcedureReturn Result
EndProcedure

;Aufruf: KopiereKetteInProzess(?Hex_Kette_1, ....)

[hjbremer]

ich weiß zwar auch nicht was du so genau willst, aber ev. hilft dir folgender Code weiter

Code: Alles auswählen

DataSection
    HexData:    
      ;jeweils 20 Hexwerte
      Data.c $0b,$03,$30,$66,$01,$02,$0a,$ff,$30,$04,$01,$02,$0a,$ff,$31,$05,$01,$02,$01,$02
      Data.c $13,$01,$30,$40,$01,$02,$0a,$ff,$30,$50,$01,$02,$0a,$ff,$32,$60,$01,$02,$01,$02
      Data.c $14,$ff,$30,$00,$01,$02,$0a,$ff,$30,$00,$01,$02,$0a,$ff,$33,$00,$01,$02,$01,$02
EndDataSection

Structure Buffer
 StructureUnion
   s.s{20}
   c.c[0]
 EndStructureUnion
EndStructure

Procedure ReadHexWerte(*b.Buffer)
  
  For j = 0 To 19
     Read a.c
     *b\c[j] = a.c  
  Next
  
EndProcedure

Restore HexData
ReadHexWerte(buffer1.Buffer)
ReadHexWerte(buffer2.Buffer)
ReadHexWerte(buffer3.Buffer)


;Beispiele für Zugriff

a = buffer1\c[14]       ;ab null, die 14 ist also das 15.Zeichen

s$ = Chr(buffer1\c[14])

b$ = buffer2\s    ;Achtung ! nur bis zum $00, wenn vorhanden

c$ = Mid(buffer2\s,3,5)  ;ab 1 gezählt
d$ = Mid(buffer3\s,8,1)  ;geht nicht, da $00 davor liegt, für PB ist Char 0 das Stringendezeichen

dnr = 1
OpenFile(dnr,"\Test1.txt")
 WriteData(dnr,@buffer3,SizeOf(Buffer))
CloseFile(dnr)

;mehrere Zeichen im Buffer ändern; da es leider kein PeekData bzw.PokeData gibt, muß CopyMemory herhalten

x.s{10} = "abcdefghij"  ;genau 10 Zeichen, wenn weniger wird mit Char 0 aufgefüllt

CopyMemory(@x,@buffer2+5,SizeOf(x))

Debug buffer2\s

;oder

y$ = Chr($44)+Chr($55)+Chr($34)+Chr($35)+Chr($64)+Chr($75)

CopyMemory(@y$,@buffer2+5,Len(y$))

Debug buffer2\s

;oder mit Hilfe der Struktur

buffer2\c[5] = $c8
buffer2\c[6] = $b8
buffer2\c[7] = $a9

Debug buffer2\s

;Beispiel für WriteProcessMemory, nicht ausprobiert sollte so aber richtig sein

;lpBuffer = @buffer2
;nSize = SizeOf(Buffer)
;WriteProcessMemory_(hProcess,	lpBaseAddress,	lpBuffer,	nSize,	0)


;lpBuffer = @buffer2
;nSize = SizeOf(Buffer)
;ReadProcessMemory_(hProcess,	lpBaseAddress,	lpBuffer,	nSize,	0)

[whitelion]

jaaaaaaaaaa jaaaaa ... das sieht schon besser aus ... den krams mit der api hab ich in viel mühe und dank tipps schon erfolgreich zum laufen bekommen. sorry wenn ich nerve, aber einige dinge sind nicht so einfach aus den tutorials herauszulesen.... na ja, mein vorhaben ist wohl auch nciht gerade das einfachste für einen PB anfänger. da ich aber jetzt schon den api krams gebacken bekommen habe, sollte ich wohl daran nicht scheitern.

mit der datasection sieht das ganze doch schon recht gut aus. ich hoffe nur, das ich das auch verwenden kann, wenn ich diesen schritt gebacken bekommen habe und dann mein mit "an den hintern der exe kleben und auslesen" - vorhaben damit nicht scheitert!

meine frage:
wie kann ich, die definierten werte der datasection als kontrolle anzeigen bzw ausgeben lassen.

debug hexdata ; <--- 0

PrintN(hex(hexdata)) ; <- auch 0

[Kaeru Gaman]

mit einer schleife den buffer byteweise durchgehen,
mit Out$ + Hex(Byte) zu einem String zusammenstellen,
den kannst du dann mit Debug oder PrintN ausgeben.

Code: Alles auswählen

DataSection
    HexData:   
      ;jeweils 20 Hexwerte
      Data.c $0b,$03,$30,$66,$01,$02,$0a,$ff,$30,$04,$01,$02,$0a,$ff,$31,$05,$01,$02,$01,$02
      Data.c $13,$01,$30,$40,$01,$02,$0a,$ff,$30,$50,$01,$02,$0a,$ff,$32,$60,$01,$02,$01,$02
      Data.c $14,$ff,$30,$00,$01,$02,$0a,$ff,$30,$00,$01,$02,$0a,$ff,$33,$00,$01,$02,$01,$02
EndDataSection 

Restore HexData

For t=0 To 2
  Out$=""
  For n=0 To 19   ; je 20 Werte
    Read Char.c
    Out$ + RSet(Hex(Char),2,"0") + " "
  Next
  Debug Out$
Next