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

[himitsu]

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]

[himitsu]

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.

[gammatester]

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

[himitsu]

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.

[gammatester]

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

[himitsu]

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

[himitsu]

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

[gammatester]

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

[gammatester]

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

[sx2008]

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).