Binären Wert schreiben

[Predator]

hi Jungs.

Also ich hab folgenden Binärwert als .reg vorliegen:

5f,0e,ad,ff,d4,44,89,6c,96,6e,06,26,b2,f6,52,04,21 ,bc,f6,d6,5c,0a,\
25,37,be,70,98,e7,d9,45,8a

Den möchte ich gerne aus der Delphi Anwendung in die Registry schreiben.

Doch wie kann ich den Als Binärwert in die Reg schreiben ? Also in der Registry muss der dann genauso aussehen.

Villeicht kann mir jemand ein Beispielcode geben ?

Danke !

mfg
Predator

[Duffy]

Hallo Predator;
Schau dir mal die Funktionen "WriteBinaryData (Methode von TRegistry)" und "ReadBinaryData (Methode von TRegistry)" aus der Unit Registry an.
bye
Claus

[Predator]

uch hat ich vergessen, die habe ich mir schon angeschaut aber wenn ich z.B.:
einen string habe s := 'hier die binäre werte';

und dann WriteBinaryData('ID', s, length(s));

schreibt er sie nicht so sonder macht andere Zahlen draus.

Also deswegen frage ich . Komme da einfach net weiter und beim Beispielcode könnte ich mich da reindenken deswegen.

Danke.

[Duffy]

Hallo Predator,
das verstehe ich nicht ganz. Wenn Du zum Beispiel in einem String einfach ein "A" stehen hättest, dann wird ein Hexa x'41' oder dezimal eine 65 in das Array geschrieben. Was steht dann bei Dir?
bye
Claus

[Predator]

also nehmen wir von meinem Binären Code die ersten 2 Stellen: 5f !!!

Daraus wird dann in die Registry geschrieben: 64 und bei dem 0e wird 11 geschrieben.

Da stimmt doch was net.

Kannst du nichtmal ein Beispiel posten ? Also der String den ich oben gepostet hab ist der original Binär String aus der Registry. Nur ich will den jetzt aus Delphi in die reg schreiben.

Danke.

[scp]

Dann probiers mal hiermit:

Delphi-Quellcode:

function HexToBinStr(HexStr : string) : String;
const
  ValidHexChars : set Of Char = ['0'..'9', 'A'..'F', 'a'..'f'];
  Convert: array['0'..'f'] of SmallInt =
    ( 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-1,-1,-1,-1,-1,-1,
     -1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1,
     -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
     -1,10,11,12,13,14,15);
var
  HexTmpStr : String;
  HexSize : Integer;
  HexPos : Integer;
begin
  result := '';
  HexTmpStr := HexStr + ' ';
  HexSize := length(HexTmpStr);
  HexPos := 0;
  while ((HexSize - HexPos)  > 1) do
    begin
      while not (HexTmpStr[HexPos+1] in ValidHexChars) do
        begin
          Inc(HexPos);
          If ((HexSize - HexPos) < 1) then
            Break;
        end;
      If ((HexSize - HexPos) < 2) then
        Break;

      result := result + Char((Convert[HexTmpStr[HexPos+1]] shl 4) + Convert[HexTmpStr[HexPos+2]]);
      Inc(HexPos, 2);
    end;
end;

Delphi-Quellcode:

s := '0a,1d,4f,7c';
s := HexToBinStr(s);
WriteBinaryData('ID', s[1], length(s));

[Predator]

hmm geht irgendwie auch net, sind wieder andere Werte und die Kommas fehlen.

Delphi-Quellcode:

var
  ccd: TRegistry;
  s: String;
  Buffer: Byte;
begin
   ccd := TRegistry.Create;
   ccd.RootKey := HKEY_LOCAL_MACHINE;
   ccd.OpenKey('\SOFTWARE\Elaborate Bytes\CloneCD\CDKey', true);
   s := '5f,0e,ad,ff,d4,44,89,6c,96,6e,06,26,b2,f6,52,04,21,bc,f6,d6,5c,0a,25,37,be,70,98,e7,d9,45,8a';
   s := HextoBinStr(s);
   ccd.WriteBinaryData('Serial', s, length(s));
   ccd.Free;

oder mach ich was falsch ?

[scp]

Habs raus, alles richtig, bis auf eine Zeile:

Delphi-Quellcode:

WriteBinaryData('Serial', s[1], length(s));

Man muss den ersten Char eines Strings angeben, anstatt nur den Stringnamen

[Predator]

juhuu Danke vielen Dank.

Jetzt kanns weitergehen mit der Entwicklung juhuuu.

cu
Predator

[Predator]

eine frage hätte ich noch.

Kann man aus sonem hex Code bzw. Binär Code herausfinden wie der Original Code heißt ?

also mein Kumpel codet an dieser Routine und das ist eine BenutzerID die in hex umgewandelt wird und binär in die reg geschrieben wird.

Wie kann ich das machen, das aus diesem Hex wieder Klartext wird ? Danke.

cu
Predator

[scp]

Wenn der Code nicht verschlüsselt ist, dann speicher den String (der mit HexToBinStr umgewandelt wurde) doch einfach mal in eine Datei und öffne diese mit UltraEdit oder ähnlichem.

Ach ja, hier noch der umgekehrte Weg:

Delphi-Quellcode:

function BinToHexStr(SourceStr : String; Separator : String = ',') : String;
var
  ChrCnt : Word;
begin
  result := '';
  If (length(SourceStr) > 0) then
    for ChrCnt := 1 to length(SourceStr) do
      begin
        result := result + LowerCase(Format('%0:2.2x', [Ord(SourceStr[ChrCnt])]));
        If not (ChrCnt = length(SourceStr)) then
          result := result + Separator;
      end;
end;

Delphi-Quellcode:

      s := StringOfChar(#0, $7FFF);
      slen := ReadBinaryData('Serial', s[1], length(s));
      s := Copy(s, 1, slen);
      s := BinToHexStr(s);

[scp]

Obwohl.... habe noch was in meinen Quelltexten gefunden, um aus Hex/Bin Klartext zu machen:

Delphi-Quellcode:

function BinToValidStr(SourceStr : String) : String;
var
  ChrCnt : Word;
begin
  result := SourceStr;
  If (length(result) > 0) then
    for ChrCnt := 1 to length(result) do
      If (Ord(result[ChrCnt]) < $20) {or (Ord(result[ChrCnt]) > $AF)} then
        If not ((Ord(result[ChrCnt]) = $0D) or (Ord(result[ChrCnt]) = $0A)) then
          result[ChrCnt] := '.';
end;

Delphi-Quellcode:

  s := '00,48,61,6c,6c,6f,00';
  s := HexToBinStr(s);
  s := BinToValidStr(s);  // Ergebnis: '.Hallo.'

BinToValidStr macht dabei nix anderes als einfach Sonderzeichen, die nix auf dem Bildschirm zu tun haben, rauszufiltern und durch Punkte zu ersetzen.

[HomerGER]

Ich hoffe es kann helfen

hier bi daten zu lesen und in ein string zu tun

Delphi-Quellcode:

//******************************************************************************
//HilfsFunction
//BI lesen
Function Reg_BI_Lesen_RYU(input_r : G_Reg): String;
const
bufsize = 500;
var
reg : TRegistry;
byte_size_i : Integer;
byte_len_i : Integer;
i : Integer;
hexstr_s : String;
byte_buffer_dab : Array of Byte;
output_s : String;
begin
    reg := TRegistry.Create;
    try
        reg.RootKey := input_r.h1;
        reg.OpenKey(input_r.k1, True);

        SetLength(byte_buffer_dab, byte_size_i);

        byte_len_i := Reg.ReadBinaryData(input_r.v1, PChar(byte_buffer_dab)^, byte_size_i);

        hexstr_s := '';
        output_s := '';

        for i := 0 to byte_len_i - 1 do
        begin
            hexstr_s := IntToHex(byte_buffer_dab[i], 2);
            output_s := output_s + '$' + hexstr_s;
        end;
        Result := output_s;
    finally
        reg.Free;
    end;
end;

und hier aus den string in die reg zu tun

Delphi-Quellcode:

//******************************************************************************
//HilfsFunction
//BI schreiben
Procedure Reg_BI_Schreiben_RYU(input_r : G_Reg; daten_s : String);
type
PByteArray = ^TByteArray;
TByteArray = array[0..500] of Byte;
var
buffer_sl : TStringList;
reg : TRegistry;
datasize_i : Integer;
i : Integer;
j : Integer;
hexstr_s : String;
buffer_ba : PByteArray;
buffer_temp_s : String;
begin
    try
        buffer_sl := TStringList.Create;
        buffer_sl.Clear;

        hexstr_s := '';
        hexstr_s := daten_s;

        hexstr_s := '';
        hexstr_s := daten_s;
        //Alles in String Liste
        for i := 0 to Length(hexstr_s) do
        begin
            if (hexstr_s <> '') then
            begin
                buffer_temp_s := '';
                buffer_temp_s := Copy(hexstr_s, 1, 3);
                Delete(hexstr_s, 1, 3);
                buffer_sl.Append(buffer_temp_s);
            end;
        end;


        datasize_i := buffer_sl.Count;
        //Buffer grösse
        if datasize_i > 0 then
        begin
            System.GetMem(buffer_ba, datasize_i);
        end;

        j := 0;

        for i := 0 to buffer_sl.Count - 1 do
        begin
            hexstr_s := '';
            hexstr_s := buffer_sl.Strings[i];
            if j >= 0 then
            begin
                if hexstr_s <> '' then
                begin
                    buffer_ba^[j] := StrToInt(hexstr_s);
                end;
            end;
            Inc(j, 1);
        end;

        reg := TRegistry.Create;
        try
            reg.RootKey := input_r.h1;
            reg.OpenKey(input_r.k1, True);
            reg.WriteBinaryData(input_r.v1, buffer_ba^, datasize_i);
        finally
            reg.Free;
        end;
        System.FreeMem(buffer_ba);
    finally
        buffer_sl.Free;
    end;
end;

wobei Reg_daten bei mir ein record ist wo ich den key, daten und value zu tun habe

ps die daten sehen dann so im String aus $a2$23 usw.

[edit=Daniel B]Delphi-Tags korrigiert. Mfg, Daniel B[/edit]