AGB  ·  Datenschutz  ·  Impressum  







Anmelden
Nützliche Links
Registrieren
Zurück Delphi-PRAXiS Projekte Unnamed-Projekt > BigInt, MD5, RipeMD320, SHA, Streams usw.

Unnamed-Projekt > BigInt, MD5, RipeMD320, SHA, Streams usw.

Ein Thema von himitsu · begonnen am 23. Mai 2008 · letzter Beitrag vom 19. Feb 2016
Antwort Antwort
Seite 1 von 4  1 23     Letzte » 
Benutzerbild von himitsu
himitsu
Registriert seit: 11. Okt 2003
Also, wie Versprochen hier mal die ersten Teile meines kleinen Projekes.

es wird mal 'ne Art nonVCL-Framework und benötigt keine Fremdkomponenten/-Units und es werden auch nur die nötigsten Delphi-Units benötigt (per Standard nur System, SysInit und SysConst)

* das ganze Projekt ist auf Minimalismus ausgelegt,
also es wird niemals so groß wie z.B. die JEDIs, aber es soll das "Nötigste" enthalten
außerdem wird auf minimalsten Speicherverbrauch/Overhead geachtet
* es ist aktuell in einen Debugmodus versetzt und auch die Inlinefunktionen sind deaktivert
* alte/neue Demo-/Testprojekte liegen im Unterverzeichnis "Demo"
und in der Project.dpr befinden sich aktuelle Test-/Democodes zur TBigInt
* speziell in der FMath.pas sind noch unfertige Funktionen drin ... einfach mal nach "///" ausschau halten, außerdem wird bei Verwendung der entsprechende Funktionen eine Exception ausgelößt.

!!! Achtung: Vorraussetzung ist mindestens:
- BDS 2006, Delphi 2006, Turbo Delphi (incl. Updates)
- Windows 2000 Professional oder Neuer



"wichtige" aktuell enthaltene Elemente:
  • FVersionsCheck.inc
    Delphi-Versiontests
    Optionen (alternativ über Delphiprojektoptionen)
    > Userdefinitionen im Abschnitt "Private" (ab Zeile 705) und Beschreibungen siehe nachfolgenden Abschnitt
  • FType.pas
    (Basis)Typendefinitionen
  • FBinary.pas
    ByteSwap, BitSwap, RoL, RoR, OpenBit(MSB), CloseBit(LSB), CountBits, OneBit(MSB+LSB)
    Swap(Speicher tauschen), FindData(binärdaten suchen)
  • FMath.pas
    TBigInt > 512 bit integer = -2^511 .. 2^511 - 1 = ±6.703e153
    'nen paar Zufallsfunktionen
  • FStream.pas
    IStream > Windows IStream-Interface
    TnFileStream
    TnMemoryStream
    TnMemoryMappedStream
    TnIStream > IStream-Kapselung
    TnStream > TnFileStream + TnMemoryStream + TnMemoryMappedStream
  • FHash.pas
    Windows MD5- und SHA-API
    ThMD5 > Kapselung der WinAPI
    ThSHA > Kapselung der WinAPI
    ThxCRC32Table > CRC32-Rechentabelle
    ThxCRC32 > CRC32-"Klasse"
    ThxMD5 > MD5-"Klasse" (16 Byte)
    ThxRMD320 > Ripe MD320-"Klasse" ('ne Art 40 Byte-MD5)
  • FResXPMan.pas
    XP-Manifest
  • FResXPManAdmin.pas
    XP-Manifest mit Anforderung von Adminrechten

viele "Klassen" bauen auf Records auf ... können also wie jede "billige" Variable verwende werden
(also ohne Initialisation/Finalisation) und kommen vorallem ohne jeglichen Ovehead seitens der Objektverwaltung aus.
z.B.
Delphi-Quellcode:
Var Hash: ThMD5;
  S: String;

Begin
  Hash.Init;
  Hash.Update('123');
  Hash.Final;
  S := Hash.asHexString;

  Hash.Calc('123');
  S := Hash.asHexString;

  Hash.CalcFile('C:\Text.dat');
  S := Hash.asHexString;

  // oder gleich direkt
  S := Hash.CalcFile('C:\Text.dat').asHexString;
End;
RAM-Verbrauch von z.B. ThxCRC32 und TnFileStream liegen bei genau 4 Byte ... halt genau die Recordgröße (exclusive des Verbrauchs enthaltener Windowskomponenten)

Speziell auf sowas wie TBigInt und das zukünftige TBigFloat hat der Aufbau als Record große positive Auswirkungen, denn
  • Speichermanagement optimal gelöst (meißt liegt die Variable direkt im Stack, oder auf'm Heap)
    also vom Typ selbst gehen keine Anfagen an den Memorymanager und Dergleichen
  • die Variableninhalte liegen direkt in anderen Stuckturen (z.B. Records und Arrays) eingebettet
    > es gibt keine externen Daten über Pointer und so.
    = perfekt für Speicherung und Datenübertragung
    (z.B. von normalen Strings kennt man es ja, daß dessen Daten woanders liegen, als die Stringvariable)

[neu]
aktueller Funktionsumfang von TBigInt:

automatische/implizite Konvertierung
von: Integer, Int64, String
nach: Integer, Int64, Float(Extended), String

explizite Konvertierung
von und nach: Int64, Integer, UInt64, LongWord/Cardinal, Currency, Extended, String

Vergleiche ( = <> < <= >= > )
mit: TBigInt, Int64, Integer, Currency, Extended, String

Operatoren ( + - * div mod and or xor )
mit: TBigInt, Int64, Integer, String

Operatoren2 ( inc dec + - not shl shr )

Record(Klassen)-Proceduren:
Load/Save: TBigInt, Int64, Integer, UInt64, LongWord/Cardinal, String, TnStream(TnFileStream,TnMemoryStream,TnMemoryMappe dSream)
MinBigInt/MaxBigInt (Konstanten)
Compare, Add, Subtract, Multiply, Divide, Modulus, DivMod
Power, LdExp(2), LtExp(10), LxExp, ExpMod, Log2 Log10, LogN, Radic, Sqr, Sqrt,
Fibonacci, RoundTo
bAnd, bOr, bXor, bNot
Inc, Dec, Abs, NegAbs, Negative
bShl, bShr, Rol, Ror, aShl, aShr
Sign, isZero, isPositive, isNegative, isOdd, isEven,
OpenBit(MSB), CloseBit[LSB], CountBits, OneBit[MSB+LSB]

[u]Record(Klassen)-Properties:[u]
asString, asStringT(with thousands separator), asHexString

> meißt sollte Byte und Word auch mit durch Integer abgearbeitet werden können
[/neu]

[new]
die TBigInt gibt es inzwischen auch einzeln (unabhängig von diesem Projekt)
siehe Beitrag #13
[/new]




und dann noch ein Problem:
erstmal ist mir noch kein Name dafür eingefallen ... falls also wer eine Idee hat ...

Geschichte:
dieses Projekt ist 'ne Neuauflage meines nie veröffentlichten UCCs,
ist allerdings nicht mehr vorrangig auf Unicode ausgelegt
und soll dafür eine nette Win-API-Kapslung inlc. einiger nonVCL-Objekte, welche hoffentlich den Zugriff erleichtern, werden.
Und dazu kommt noch 'ne kleine Funktions/Objektsamung hinzu (z.B. TBigInt und Co.)


Lizenz: da fast alles von mir selber ist, liegt das Copyright wohl auch bei mir
außer wo es explizit im QuellCode, bei den entsprechenden Funktionen, dabei steht

die Grundlagen zur FBinary.BitSwap (speziell von BitSwap(i: LongWord): LongWord; ) hatte ich mal hier aus dem Forum, weiß aber nicht mehr von wem ... wäre schön, wenn sich dazu die Person wieder anfinden würde, damit ich diese erwähnen kann)


[add 22.01.2009]
die Hashfunktionen wurden etwas überarbeitet
siehe Beitrag #18
- Delphi 2009 Kompatibilität
- als Einzeldatei verwendbar
(Achtung: in diesem Post wurde die Delphi 2009-Änderungen noch nicht geupdatet)
[/add]
Angehängte Dateien
Dateityp: 7z nonvcl_267.7z (359,8 KB, 267x aufgerufen)
Garbage Collector ... Delphianer erzeugen keinen Müll, also brauchen sie auch keinen Müllsucher.
Delphi-Tage 2005-2014
 
Benutzerbild von himitsu
himitsu

 
Delphi 10.2 Tokyo Professional
 
#2
  Alt 25. Mai 2008, 14:44
So, 's wurde noch was zur TBigInt hinzugefügt:
Log2
Log10
LogN
Sqrt
Radic (Wurzelziehen/Radizieren mit belibiger Potenz)
Fibonacci
(Test- und Democodes aktuell in Project1.dpr)

Außerdem hab ich die Typenumwandlung (Implicit/Explicit) etwas überarbeitet

und es gibt jetzt eine explizite Typenumwandlung von Extended nach TBigInt.
(mit dem normaltem "Trunc" brauchte man ja bei Zahlen größer Int64 garnicht erst anfangen )
I := TBigInt(E); wobei nur die ersten 18/19 Stellen des Ganzzahlaneiles übernommen und der Rest mit 0 gefüllt wird.

folgendes Testschleifchen befindet sich noch in der Project1.dpr
Delphi-Quellcode:
E := 0.123;
For i5 := -3 to 100 do Begin
  I := TBigInt(E);
  S := I.asString;
  If (E > 0) or (S <> '') Then ;

  E := E * 10;
End;
Zitat:
Ergebnis: (Extended = TBigInt)
0.123 = 0
1.23 = 1
12.3 = 12
123 = 123
1230 = 1230
12300 = 12300
...
1.23e11 = 123000000000
...
1.23e50 = 12300000000000000000000000000000000000000000000000 0
...


-----------------

123456789012345678901234567890000000 = 1.2345678901e35 = 123456789012345679000000000000000000

Dann hab ich (da sich wer über das LongInt-geeiere "beschwert" hat) da auch mal was umgestellt und dieses Problem in eine kleiner Ecke verschoben.
Nur nett, daß ich gestern dieses in 'ner halben Stunde fertig hatte und heute nochmal 2 Stunden den dadurch enstandenn Rechenfehler suchen durfte ... was so ein Vorzeichen alles bewirkt

Und man kann jetzt auch endlich Vergleiche mit Extended durchführen ( < > <= >= = ......) ... ging vorher mangels passender Typenumwandlung nicht.


Neue Version + kleine Ergänzung (siehe [neu]) im ersten Post.
  Mit Zitat antworten Zitat
gammatester
 
#3
  Alt 25. Mai 2008, 15:27
Ich denke, Dein CRC32 ist nicht Standard wg 'State := not ByteSwap(State)' bzw. dem ASM code in ThxCRC32.Final. Ich kann es aber nicht testen, da ich nicht verstehe, wie ich ThxCRC32 fehlerfrei benutzen soll:

Die ThxCRC32.CalcFile öffnet das File, kommt aber nicht in die While ReadFile Schleife. OK, ich habe nur D10 Kommandozeilen-Compiler unter Win98 (kann also nicht debuggen, und unter D6 läuft's nicht). Aber selbst das folgende Testprogramm liefert immer 0.


Delphi-Quellcode:
{$apptype console}
program cc;
uses
  sysutils,fhash;
const
  abc: array[0..2] of char = 'abc';
var
  hash: LongWord;
  crc: ThxCRC32;
begin
  CRC.InitT;
  Hash := CRC.Calc(pointer(@abc), 3);
  writeln(IntToHex(hash,8));
end.
Gruß Gammatester
  Mit Zitat antworten Zitat
Benutzerbild von himitsu
himitsu

 
Delphi 10.2 Tokyo Professional
 
#4
  Alt 25. Mai 2008, 16:11
da ist wohl beim letzten Umstellen was untergegangen

es wird einfach nur der erechnete Hash nicht gespeichert
Delphi-Quellcode:
// in (Unit FHash)
Procedure ThxCRC32.Update(Input: Pointer; inLen: LongWord);

// nach
LOOP @@Loop // DEC &inLen; JNZ @@Loop

// das einfügen
MOV EDX, [ESP + 4]
MOV [EDX], &Self
Die Ausgabe lautet nun c2412435.


Allerdings frag ich mich grad, warum .asHexString eine andere Reinfolge hat.


Also im alten Project (als Klasse) lief es noch und ich hatte den selben Hash raus wie Hagen's DEC
jetzt müßte ich nur noch wissen welche Werte korreckt sind ... hab hier grad keine Vergleichsmöglichkeit.
Delphi-Quellcode:
const
  abc: array[0..2] of char = 'abc';
var
  hash: LongWord;
  crc: ThxCRC32;

Begin
  CRC.InitT;

  hash := CRC.Calc(@abc, 3);
  WriteLn(IntToHex(hash, 8));
  WriteLn(CRC.asHexString);

  CRC.CalcFile(ParamStr(0), hash);
  WriteLn(IntToHex(hash, 8));

  ReadLn;
Zitat:
c2412435
5342142c
4b89e4f1
errechnet mit Standard-Polynom $EDB88320



Und was ThxCRC32.CalcFile bei dir hat, kann ich so nicht nachvollziehen ... hier läuft es jedenfalls und beim Debuggen bin ich auch in die Schleife reingekommen.


[add]
so, in den anderen Hashs ist auch der Wurm drin.

Delphi-Quellcode:
const
  abc: array[0..2] of char = 'abc';
var
  hash: FHash.MD5_DIGEST;
  md5_1: ThMD5;
  md5_2: ThxMD5;

Begin
  hash := md5_1.Calc(@abc, 3);
  WriteLn(md5_1.asHexString);

  hash := md5_2.Calc(@abc, 3);
  WriteLn(md5_2.asHexString);

  md5_1.CalcFile(ParamStr(0), hash);
  WriteLn(md5_1.asHexString);

  md5_2.CalcFile(ParamStr(0), hash);
  WriteLn(md5_2.asHexString);

  ReadLn;
Zitat:
900150983cd24fb0d6963f7d28e17f72
c5b151b6fe900681fedcba9876543210
ce3f7e686afa6a12b5e343c840d30afa
3fa5b06d57eeb9bf0000000000000000
Hier stimmt definitiv auch etwas nicht ... also ist aktuell von den Thx-Funktionen abzuraten.
Die ThMD5 und ThSHA sollten aber funktionieren.
  Mit Zitat antworten Zitat
gammatester
 
#5
  Alt 25. Mai 2008, 16:41
Also wie vermutet: Als 32-Bit-Integer kommt 352441c2 raus, da sind sich die meisten Programme einig. c2412435 kommt raus, wenn man die vier Bytes als Hexstring ausgibt. Was Dein asHex macht, weiß ich nicht.

Dein Programm liefert selbst unter Win2000 folgende Ausgabe

00000000
00000000
FFFFFFFF

Also wird das Problem wohl beim D10-Kdozeilencompiler liegen.

Dein Demoprogramme im Archiv kann ich nicht testen, da (bei mir) jede Menge Units fehlen, zB:
Project1.dpr(4) Fatal: F1026 File not found: 'FWinUI.dcu'

Im übrigen sind Testprgramme für alle/die meisten Funktionen für Regressiontest 'ne ganz brauchbare Sache :)

Gruß Gammatester
  Mit Zitat antworten Zitat
Benutzerbild von himitsu
himitsu

 
Delphi 10.2 Tokyo Professional
 
#6
  Alt 25. Mai 2008, 16:56
stimmt, die FWinUI.pas und FWinUIClass.pas hatte ich noch weggelassen ... wär wohl besser dann beim Hochladen diese auch aus den Uses zu entfernen

Zitat:
c2412435 kommt raus, wenn man die vier Bytes als Hexstring ausgibt. Was Dein asHex macht, weiß ich nicht.
stimmt auch, hab grad mal die alten UCC-Testdateien durchgekramt und da lief es ja noch ._.


Zitat:
Im übrigen sind Testprgramme für alle/die meisten Funktionen für Regressiontest 'ne ganz brauchbare Sache
ich schau mal, was sich machen läßt
Angehängte Dateien
Dateityp: exe hash_400.exe (180,5 KB, 6x aufgerufen)
Dateityp: 7z hash_438.7z (2,2 KB, 22x aufgerufen)
  Mit Zitat antworten Zitat
Benutzerbild von himitsu
himitsu

 
Delphi 10.2 Tokyo Professional
 
#7
  Alt 25. Mai 2008, 18:47
ich hab mal schnell in Google gesucht und mir von da http://www2.cs.ucy.ac.cy/courses/EPL...test_tests.txt die Teststrings gemopst


ThxCRC32 geht demnach wieder
und der Rest folgt bestimmt auch bald.

hab mir das Ganze erstmal als kleines externes Testprojekt angelegt:
Delphi-Quellcode:
Program UnitTest;

{$APPTYPE CONSOLE}

Uses F_unknown, FType, FSecurity, FMemory, FBinary, FMath, FSystem,
  FFile, FStream, FHash;

{$INCLUDE FVersionsCheck.inc}

Var TestError: Boolean = False;

Procedure FHash_ThxCRC32Table;
  Const Test: ThxCRC32Table = (Data: ($00000000, $77073096, $ee0e612c, $990951ba, $076dc419, $706aF48F, $e963a535,
     $9e6495a3, $0edb8832, $79dcb8a4, $e0d5e91e, $97d2d988, $09b64c2b, $7eb17cbd, $e7b82d07, $90bF1d91, $1db71064,
     $6ab020F2, $F3b97148, $84be41de, $1adad47d, $6ddde4eb, $F4d4b551, $83d385c7, $136c9856, $646ba8c0, $Fd62F97a,
     $8a65c9ec, $14015c4F, $63066cd9, $Fa0F3d63, $8d080dF5, $3b6e20c8, $4c69105e, $d56041e4, $a2677172, $3c03e4d1,
     $4b04d447, $d20d85Fd, $a50ab56b, $35b5a8Fa, $42b2986c, $dbbbc9d6, $acbcF940, $32d86ce3, $45dF5c75, $dcd60dcF,
     $abd13d59, $26d930ac, $51de003a, $c8d75180, $bFd06116, $21b4F4b5, $56b3c423, $cFba9599, $b8bda50F, $2802b89e,
     $5F058808, $c60cd9b2, $b10be924, $2F6F7c87, $58684c11, $c1611dab, $b6662d3d, $76dc4190, $01db7106, $98d220bc,
     $eFd5102a, $71b18589, $06b6b51F, $9FbFe4a5, $e8b8d433, $7807c9a2, $0F00F934, $9609a88e, $e10e9818, $7F6a0dbb,
     $086d3d2d, $91646c97, $e6635c01, $6b6b51F4, $1c6c6162, $856530d8, $F262004e, $6c0695ed, $1b01a57b, $8208F4c1,
     $F50Fc457, $65b0d9c6, $12b7e950, $8bbeb8ea, $Fcb9887c, $62dd1ddF, $15da2d49, $8cd37cF3, $Fbd44c65, $4db26158,
     $3ab551ce, $a3bc0074, $d4bb30e2, $4adFa541, $3dd895d7, $a4d1c46d, $d3d6F4Fb, $4369e96a, $346ed9Fc, $ad678846,
     $da60b8d0, $44042d73, $33031de5, $aa0a4c5F, $dd0d7cc9, $5005713c, $270241aa, $be0b1010, $c90c2086, $5768b525,
     $206F85b3, $b966d409, $ce61e49F, $5edeF90e, $29d9c998, $b0d09822, $c7d7a8b4, $59b33d17, $2eb40d81, $b7bd5c3b,
     $c0ba6cad, $edb88320, $9abFb3b6, $03b6e20c, $74b1d29a, $ead54739, $9dd277aF, $04db2615, $73dc1683, $e3630b12,
     $94643b84, $0d6d6a3e, $7a6a5aa8, $e40ecF0b, $9309FF9d, $0a00ae27, $7d079eb1, $F00F9344, $8708a3d2, $1e01F268,
     $6906c2Fe, $F762575d, $806567cb, $196c3671, $6e6b06e7, $Fed41b76, $89d32be0, $10da7a5a, $67dd4acc, $F9b9dF6F,
     $8ebeeFF9, $17b7be43, $60b08ed5, $d6d6a3e8, $a1d1937e, $38d8c2c4, $4FdFF252, $d1bb67F1, $a6bc5767, $3Fb506dd,
     $48b2364b, $d80d2bda, $aF0a1b4c, $36034aF6, $41047a60, $dF60eFc3, $a867dF55, $316e8eeF, $4669be79, $cb61b38c,
     $bc66831a, $256Fd2a0, $5268e236, $cc0c7795, $bb0b4703, $220216b9, $5505262F, $c5ba3bbe, $b2bd0b28, $2bb45a92,
     $5cb36a04, $c2d7FFa7, $b5d0cF31, $2cd99e8b, $5bdeae1d, $9b64c2b0, $ec63F226, $756aa39c, $026d930a, $9c0906a9,
     $eb0e363F, $72076785, $05005713, $95bF4a82, $e2b87a14, $7bb12bae, $0cb61b38, $92d28e9b, $e5d5be0d, $7cdceFb7,
     $0bdbdF21, $86d3d2d4, $F1d4e242, $68ddb3F8, $1Fda836e, $81be16cd, $F6b9265b, $6Fb077e1, $18b74777, $88085ae6,
     $FF0F6a70, $66063bca, $11010b5c, $8F659eFF, $F862ae69, $616bFFd3, $166ccF45, $a00ae278, $d70dd2ee, $4e048354,
     $3903b3c2, $a7672661, $d06016F7, $4969474d, $3e6e77db, $aed16a4a, $d9d65adc, $40dF0b66, $37d83bF0, $a9bcae53,
     $debb9ec5, $47b2cF7F, $30b5FFe9, $bdbdF21c, $cabac28a, $53b39330, $24b4a3a6, $bad03605, $cdd70693, $54de5729,
     $23d967bF, $b3667a2e, $c4614ab8, $5d681b02, $2a6F2b94, $b40bbe37, $c30c8ea1, $5a05dF1b, $2d02eF8d));

  Var CRC32Tab: ThxCRC32Table;
    i: Integer;

  Label Exit;

  Begin
    WriteLn;
    WriteLn('********** FHash.ThxCRC32Table **********');
    WriteLn;
    CRC32Tab.CreateTable($EDB88320);
    For i := 0 to High(CRC32Tab.Data) do
      If CRC32Tab.Data[i] <> Test.Data[i] Then Begin
        TestError := True;
        WriteLn(WordToHex(CRC32Tab.Data[High(CRC32Tab.Data)]), ' [failed] **********');
        Goto Exit;
      End;
    WriteLn(WordToHex(CRC32Tab.Data[High(CRC32Tab.Data)]), ' [passed]');
    Exit:
    WriteLn(WordToHex($2d02eF8d), ' CRC32Tab.Data[255]');
    WriteLn;
    WriteLn;
  End;

Procedure FHash_ThxCRC32;
  Const Test: Array[0..15] of String = (
    '00000000', '',
    '43beb7e8', 'a',
    'c2412435', 'abc',
    '7f9d1520', 'message digest',
    'bd50274c', 'abcdefghijklmnopqrstuvwxyz',
    'd2e6c21f', 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789',
    '724aa97c', '12345678901234567890123456789012345678901234567890123456789012345678901234567890',
    '2639f4cb', '123456789');

  Var CRC32: ThxCRC32;
    i: Integer;
    S, S2: String;

  Begin
    WriteLn;
    WriteLn('********** FHash.ThxCRC32 **********');
    WriteLn;
    CRC32.InitT;
    For i := 0 to High(Test) div 2 do Begin
      S := Test[i * 2 + 1];
      CRC32.Calc(PChar(S), Length(S));
      S2 := CRC32.asHexString;
      If S2 <> Test[i * 2] Then Begin
        WriteLn(S2, ' [failed] **********');
        TestError := True;
      End Else WriteLn(S2, ' [passed]');
      WriteLn(Test[i * 2], ' ', Copy('"' + Test[i * 2 + 1] + '"', 1, 69));
      WriteLn;
    End;
  End;

Begin
//ThMD5
//ThSHA
  FHash_ThxCRC32Table;
  FHash_ThxCRC32;
//ThxMD5
//ThxRMD320
  WriteLn;
  WriteLn;
  WriteLn('******************************');
  WriteLn;
  If TestError Then WriteLn('one or more tests [failed]') Else WriteLn('all tests [passed]');
  ReadLn;
End.
Code:
********** FHash.ThxCRC32Table **********

2d02ef8d [passed]
2d02ef8d CRC32Tab.Data[255]



********** FHash.ThxCRC32 **********

00000000  [passed]
00000000  ""

43beb7e8  [passed]
43beb7e8  "a"

c2412435  [passed]
c2412435  "abc"

7f9d1520  [passed]
7f9d1520  "message digest"

bd50274c [passed]
bd50274c "abcdefghijklmnopqrstuvwxyz"

d2e6c21f [passed]
d2e6c21f "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"

724aa97c [passed]
724aa97c "12345678901234567890123456789012345678901234567890123456789012345678

2639f4cb [passed]
2639f4cb "123456789"



******************************

all tests [passed]

neuer Anhang samt Textprojekt ist oben im ersten Post zu finden
  Mit Zitat antworten Zitat
gammatester
 
#8
  Alt 25. Mai 2008, 20:24
Den Link kannte ich noch gar nicht. Interessant ist, daß offensichtlich verschiedene Ausgabeformate darin vorkommen: CRC32 ist als LSB-First-Hexstring (wie Deine Ausgabe) und Adler-32 als Longint im IntToHex-Format.

Ansonsten geht's ja gut vorwärts bei Deinen Units :) Dies als positives Feedback, da ich offensichtlich bis jetzt der einzige bin, der die 7z-Archive runtergeladen hat.

Als weitere Anregung: Ich habe in meinen CRC/Hash-Units für jeden Algorithmus eine Selftest-Funktion eingebaut, damit können Benutzer (und ich nach Änderungen) schnell testen, ob die Implementation noch stimmt.

Viele Grüße
Gammatester
  Mit Zitat antworten Zitat
gammatester
 
#9
  Alt 25. Mai 2008, 21:52
Habe gerade selbst noch ein wenig gesucht und denke, daß Deine verlinkten Testwerte die Ausgabe von Wei Dai's Crypto++ Validierungs-Suite ist (jedenfalls kommen die Überschriften in den verschiedenen Testprogrammen vor).

Und siehe da, wenn man sich adler32.cpp/h und crc.cpp/h anschaut, findet man auch die Erklärung für die unterschiedliche Ausgabeformat für die 32-Bit-Werte.

Gruß Gammatester
  Mit Zitat antworten Zitat
Benutzerbild von sx2008
sx2008

 
Delphi 2007 Professional
 
#10
  Alt 26. Mai 2008, 01:13
Warum sind denn so viele Deklarationen aus Unit Windows enthalten?
Schließlich vergrössert die Unit Windows eine Anwendung nicht (und wenn doch, dann nur unwesentlich).
  Mit Zitat antworten Zitat
Themen-Optionen Thema durchsuchen
Thema durchsuchen:

Erweiterte Suche
Ansicht

Forumregeln

Es ist dir nicht erlaubt, neue Themen zu verfassen.
Es ist dir nicht erlaubt, auf Beiträge zu antworten.
Es ist dir nicht erlaubt, Anhänge hochzuladen.
Es ist dir nicht erlaubt, deine Beiträge zu bearbeiten.

BB-Code ist an.
Smileys sind an.
[IMG] Code ist an.
HTML-Code ist aus.
Trackbacks are an
Pingbacks are an
Refbacks are aus

Gehe zu:

Impressum · AGB · Datenschutz · Nach oben
Alle Zeitangaben in WEZ +1. Es ist jetzt 15:58 Uhr.
Powered by vBulletin® Copyright ©2000 - 2019, Jelsoft Enterprises Ltd.
LinkBacks Enabled by vBSEO © 2011, Crawlability, Inc.
Delphi-PRAXiS (c) 2002 - 2019 by Daniel R. Wolf