Umwandlung charkombination nach integer

[qwertz543221]

hallo ich suche eine möglichkeit folgendes schneller berechnen zu können oder sogar zu umgehen:

für rsa habe ich eine umwandlung von buichstabenkombinationen (immer zwei zusammen) zu einer zahl.
dies geht wie folgt:

ABCD

AB=256*65+66=16706 (zb ascii werte in einem stellenwertsystem)
CD=256*67+68=17220

umgekerht wäre:

16706 div 256=65=A
16706 mod 256=66=B
17220 div 256=67=C
17220 mod 256=68=D
gibt ABCD



Da dies ziemlich viele Rechenoperationen sind, bräuchte ich eine methode um diese umwandlungen in beide richtungen effizienter zu gestalten.

[DeddyH]

Aus dem Kopf, daher ohne Gewähr:

Delphi-Quellcode:

ErsteZahl := Ord('A') shl 8 or Ord('B');

//umgekehrt:

Char1 := ErsteZahl shr 8;
Char2 := ErsteZahl and $00FF;

[qwertz543221]

ok danke das hat gut geklappt.

[qwertz543221]

und wenn ich die blöcke jetzt vergößern möchte, mit mehr buchstaben - wie wäre das möglich?

[DeddyH]

Wenn es nicht mehr als 4 Buchstaben sein sollen, kommst Du mit DWORD aus.

Delphi-Quellcode:

Zahl := Ord(Buchstabe1) shl 24 or Ord(Buchstabe2) shl 16 or Ord(Buchstabe3) shl 8 or Ord(Buchstabe4);

//umgekehrt:
Buchstabe1 := Chr(Zahl shr 24);
Buchstabe2 := Chr(Zahl shr 16 and $000000FF);
Buchstabe3 := Chr(Zahl shr 8 and $000000FF);
Buchstabe4 := Chr(Zahl and $000000FF);

Wieder aus dem Kopf ;)

[qwertz543221]

Zitat:

wieder aus dem kopf;)

nicht schlecht;)


gibt es auch eine möglichkeit, die anzahlder verkettungen variieren zu lassen, um zb nur zahlen(blöcke) größer 30000 zu bekommen?

[DeddyH]

Kannst Du das mal genauer beschreiben? So ganz versteh ich es noch nicht.

[qwertz543221]

kein problem


ich bin dabei rsa zu programmieren.
bisher habe ich immer zweier blöcke benutzt - das hat auch funktioniert.
das problem dabei sind die enorm langen chiffretexte und die langen rechenzeiten. wenn ich also die anzahl der blöcke reduziere, in dem ich die blockgröße erhöhe, verkürze ich beides.

[DeddyH]

Ach, und wenn die Anzahl der verbleibenden Buchstaben kleiner als 4 ist, soll die Zahl trotzdem größer als 30.000 sein, richtig?

[qwertz543221]

normalerweise schon - aber dafür fragte ich ja an ob es eine möglichkeit gäbe die blockgröße variieren zu lassen - sodass ichb zb sagen könnte, wenn die textlänge mod 7 oder mod 12=0 ist (willkürlich gewählt), dass ich dann blöcke mit einer eben solchen länge (7 bzw 12) behandeln könnte

[DeddyH]

Nunja, wir haben ja pro Buchstaben ein Byte belegt. Du könntest also auch mit einem dynamischen Array of Byte hantieren, dessen Länge Du auf die Stringlänge setzt.

[edit] Andererseits wäre es ja auch egal, wenn man immer 4 Byte-Blöcke belegt, denn dann wäre das Byte hinter dem letzten komplett mit 0 belegt, so dass bei der Rückrechnung #0 herauskäme, das ist ja eh das Stringende-Zeichen. Ich könnte da zwar jetzt einen Denkfehler haben, aber IMO stimmt das schon so. [/edit]

[qwertz543221]

das problem dabei ist dass ich nur rechenoperationen für strings habe

also die zahlen der form '1234456789' - und immoment würde es ausreichen, für diese gruppe eine möglichkeit zu haben . das mit dem array of byte kommt vlt später.


oder wie meintest du das?


ps: mir fiel auf, dass bei der rückwandlung zeichen fehlen können

[DeddyH]

Betrachten wir das Ganze doch einmal binär. Angenommen, Du hast einen String 'AAAAA'. Das sieht dann so aus:

Code:

01000001 01000001 01000001 01000001 01000001
    A        A        A        A        A

Nach der Methode von oben in 4-Byte-Blöcken:

Code:

01000001 01000001 01000001 01000001 01000001 00000000 00000000 00000000
    A        A        A        A        A       #0       #0       #0

Ich denke mal, das stellt kein großes Problem dar, da #0 wie gesagt das Zeichen für Stringende ist.

[qwertz543221]

keine schlechte idee - ich muss mal sehen, wie ich da mit den operationen hinkomme - die sind nämlich nur für dezimal (stringzahlen)

was mach ich dagegen, dass die oben vorgestellte variante - eine von den ersten - die letzten zeichen entsorgt, wenn die länge nicht durch 4 teilbar ist

[DeddyH]

Füll den letzten Teilstring mal mit #0 auf, bis er durch 4 teilbar ist.

[edit] Oder zeig mal, wie Du das umgesetzt hast. [/edit]

[qwertz543221]

ok geht danke
hier das bisherige

Delphi-Quellcode:

function tform1.rsaenc(text:ansistring;n:ansistring):ansistring;
var
l:int64;
wa,zahl:ansistring;
begin
result:='';
mathe:=tmathe.Create;
l:=length(text);
while l mod 4 <>0
  do
  begin
  text:=text+chr(0);
  l:=length(text)
  end;
  i:=1;
  while i<=l do
begin
application.ProcessMessages;
if i mod 4 =0
    then
    begin
   // wa:=mathe.summe(mathe.produkt(inttostr(ord(text[i])),'256'),inttostr(ord(text[i+1])));
    wa:=inttostr(combtonum(text[i-3]+text[i-2]+text[i-1]+text[i]));
    wa:=mathe.PotenzModulo(wa,e,n);
    zahl:=wa;
   if length(zahl)<length(n)
      then
        while length(zahl)<>length(n) do
        zahl:='0'+zahl;
 result:=result+zahl;
  end;
 inc(i);
end;
end;

function tform1.rsadec(text:ansistring;d,n:ansistring):ansistring;
var
i:int64;
wa,z1,z2,z3,m_1,m_2,m,h:ansistring;
zahl:ansistring;

begin
result:='';
m_1:='0';
m_2:='0';
m:='0';
h:='0';
mathe:=tmathe.Create;
i:=1;
{
//chinesischer Restsatz:=>Fehlerhaft!!!
       dp:=modinvers(e,mathe.Differenz(p,'1'));
       dq:=modinvers(e,mathe.Differenz(q,'1'));
       qinv:=modinvers(p,q);     }
 while i<=length(text) do
  begin
  application.ProcessMessages;
  zahl:=copy(text,i,length(n));
  wa:=zahl;
  wa:=mathe.PotenzModulo(wa,d,n);


    //result:=result+chr(strtoint(mathe.Quotient(wa,'256')))+chr(strtoint(mathe.Modulo(wa,'256')));
  result:=result+numtocomb(strtoint(wa));
  i:=i+length(n)
  end;
   end;

function TForm1.numtocomb(num:longint):string;
var b1,b2,b3,b4:char;
begin
result:='';
b1 := Chr(num shr 24);
b2 := Chr(num shr 16 and $000000FF);
b3 := Chr(num shr 8 and $000000FF);
b4 := Chr(num and $000000FF);
result:=b1+b2+b3+b4;
end;


function TForm1.combtonum(comb:string):longint;
begin
result:=Ord(comb[1]) shl 24 or Ord(comb[2]) shl 16 or Ord(comb[3]) shl 8 or Ord(comb[4])
end;

[qwertz543221]

noch eine frage: was ist das größte ergebnis, was dabei herauskommen kann

also bei (256,256,256,256)?

[qwertz543221]

müsste 16843008 sein? - hm nein war falsch

[Neutral General]

Hi,

Hab nochwas:

Delphi-Quellcode:

// Speichert maximal 4 Buchstaben in einer Zahl (4 Byte)
function StrToCardinal(S: String): Cardinal;
begin
  Result :=  PCardinal(S)^;
end;

// Extrahiert den String aus dem Cardinal
function CardinalToStr(C: Cardinal): String;
begin
  SetLength(Result,4);
  Move(c,Result[1],4);
end;

// Anwendung:
var c: Cardinal;
    s: String;
begin
  S := 'Test';
  c := StrToCardinal(S);
  Caption := CardinalToStr(c);
end;

Gruß
Neutral General

[DP-Maintenance]

Dieses Thema wurde von "TBx" von "Neuen Beitrag zur Code-Library hinzufügen" nach "Object-Pascal / Delphi-Language" verschoben.
Im Moment ists noch ne Diskussion, wird vielleicht mal ein Beitrag für die CL ...