initialer CommitHEADmaster

5 files changed, 1464 insertions, 0 deletions

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..6c22073
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,12 @@
+*.bmp
+*.png
+*.bak
+*.ppu
+*.o
+*.zip
+*.tar.gz
+*.out
+lib
+rsa
+*~
+Log*
diff --git a/rsa.lpi b/rsa.lpi
new file mode 100644
index 0000000..0255e95
--- /dev/null
+++ b/rsa.lpi
@@ -0,0 +1,93 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<CONFIG>
+  <ProjectOptions>
+    <Version Value="9"/>
+    <General>
+      <Flags>
+        <MainUnitHasCreateFormStatements Value="False"/>
+      </Flags>
+      <SessionStorage Value="InProjectDir"/>
+      <MainUnit Value="0"/>
+      <Title Value="RSA Application"/>
+      <UseAppBundle Value="False"/>
+      <ResourceType Value="res"/>
+    </General>
+    <i18n>
+      <EnableI18N LFM="False"/>
+    </i18n>
+    <VersionInfo>
+      <StringTable ProductVersion=""/>
+    </VersionInfo>
+    <BuildModes Count="1">
+      <Item1 Name="Default" Default="True"/>
+    </BuildModes>
+    <PublishOptions>
+      <Version Value="2"/>
+    </PublishOptions>
+    <RunParams>
+      <local>
+        <FormatVersion Value="1"/>
+      </local>
+    </RunParams>
+    <Units Count="4">
+      <Unit0>
+        <Filename Value="rsa.lpr"/>
+        <IsPartOfProject Value="True"/>
+      </Unit0>
+      <Unit1>
+        <Filename Value="rsaunit.pas"/>
+        <IsPartOfProject Value="True"/>
+        <UnitName Value="rsaunit"/>
+      </Unit1>
+      <Unit2>
+        <Filename Value="mlockunit.pas"/>
+        <IsPartOfProject Value="True"/>
+        <UnitName Value="mlockunit"/>
+      </Unit2>
+      <Unit3>
+        <Filename Value="mmanunit.pas"/>
+        <IsPartOfProject Value="True"/>
+      </Unit3>
+    </Units>
+  </ProjectOptions>
+  <CompilerOptions>
+    <Version Value="11"/>
+    <Target>
+      <Filename Value="rsa"/>
+    </Target>
+    <SearchPaths>
+      <IncludeFiles Value="$(ProjOutDir)"/>
+      <Libraries Value="/usr/lib/"/>
+      <OtherUnitFiles Value="/usr/src/dcpcrypt/;/usr/src/dcpcrypt/Ciphers/;/usr/src/dcpcrypt/Hashes/;../units"/>
+      <UnitOutputDirectory Value="lib/$(TargetCPU)-$(TargetOS)"/>
+    </SearchPaths>
+    <CodeGeneration>
+      <Checks>
+        <IOChecks Value="True"/>
+        <RangeChecks Value="True"/>
+        <OverflowChecks Value="True"/>
+        <StackChecks Value="True"/>
+      </Checks>
+    </CodeGeneration>
+    <Linking>
+      <Options>
+        <Win32>
+          <GraphicApplication Value="True"/>
+        </Win32>
+      </Options>
+    </Linking>
+  </CompilerOptions>
+  <Debugging>
+    <Exceptions Count="3">
+      <Item1>
+        <Name Value="EAbort"/>
+      </Item1>
+      <Item2>
+        <Name Value="ECodetoolError"/>
+      </Item2>
+      <Item3>
+        <Name Value="EFOpenError"/>
+      </Item3>
+    </Exceptions>
+  </Debugging>
+</CONFIG>
diff --git a/rsa.lpr b/rsa.lpr
new file mode 100644
index 0000000..015c2f4
--- /dev/null
+++ b/rsa.lpr
@@ -0,0 +1,430 @@
+program rsa;
+
+{$mode objfpc}{$H+}
+
+{$DEFINE UseCThreads}
+
+uses
+  {$IFDEF UNIX}{$IFDEF UseCThreads}
+  cthreads,
+  {$ENDIF}{$ENDIF}
+  Classes, SysUtils, CustApp,
+  { you can add units after this }
+  gmp, math, rsaunit, crt;
+
+type
+
+  { TRSAApplication }
+
+  TRSAApplication = class(TCustomApplication)
+  protected
+    procedure DoRun; override;
+  public
+    constructor Create(TheOwner: TComponent); override;
+    destructor Destroy; override;
+    procedure WriteHelp; virtual;
+  end;
+
+{ TRSAApplication }
+
+procedure TRSAApplication.DoRun;
+var
+  ErrorMsg,s,version:      String;
+  pass:                    tLockedString;
+  n1,n2,n3,modul,
+    e_exponent,d_exponent: mpz_t;
+  state:                   randstate_t;
+  i,j,bits,maxThreads:     longint;
+  gelesen,zulesen:         int64;
+  binf:                    file;
+  textf:                   textfile;
+  buff:                    array of byte;
+  privOut,pubOut:          textfile;
+  act:                     tRSAAction;
+begin
+  // parse parameters
+  maxThreads:=1;
+  pass:=nil;
+  if HasOption('g','generate') then begin
+    act:=raGen;
+    ErrorMsg:=CheckOptions('g:b:rt:','generate: bits: randomize threads:');
+    if HasOption('b','bits') then
+      bits:=strtoint(GetOptionValue('b','bits')) div 2 + 1
+    else
+      bits:=64;
+
+    if HasOption('t','threads') then
+      maxThreads:=strtoint(GetOptionValue('t','threads'));
+  end
+  else if HasOption('e','encrypt') then begin
+    act:=raEnc;
+    ErrorMsg:=CheckOptions('e:i:o:','encrypt: input: output:');
+    if (ErrorMsg='') and not (HasOption('i','input') and HasOption('o','output')) then
+      ErrorMsg:='Ich benötige zum Verschlüsseln Dateien!';
+  end
+  else if HasOption('d','decrypt') then begin
+    act:=raDec;
+    ErrorMsg:=CheckOptions('d:i:o:','decrypt: input: output:');
+    if (ErrorMsg='') and not (HasOption('i','input') and HasOption('o','output')) then
+      ErrorMsg:='Ich benötige zum Entschlüsseln Dateien!';
+  end
+  else if HasOption('c','check') then begin
+    act:=raChk;
+    ErrorMsg:=CheckOptions('c:','check:');
+  end
+  else if HasOption('u','update') then begin
+    act:=raUpd;
+    ErrorMsg:=CheckOptions('u:','update:');
+  end
+  else begin
+    act:=raUnk;
+    WriteHelp;
+    Terminate;
+    Exit;
+  end;
+
+  if ErrorMsg<>'' then begin
+    ShowException(Exception.Create(ErrorMsg));
+    Terminate;
+    Exit;
+  end;
+
+  { add your program here }
+
+  case act of
+    raGen: begin
+      readNewPassword(pass,ceil(sqrt(bits/8)));
+
+      mpz_init(n1);
+      mpz_init(n2);
+      mpz_init(n3);
+      mpz_init(modul);
+      mpz_init(e_exponent);
+      mpz_init(d_exponent);
+
+      assignfile(privOut,GetOptionValue('g','generate'));
+      rewrite(privOut);
+      assignfile(pubOut,GetOptionValue('g','generate')+'.pub');
+      rewrite(pubOut);
+      if HasOption('r','randomize') then begin
+        s:=acquireRandomness(bits div 4 + 1);
+        mpz_set_str(n1,@(s[1]),16);
+      end
+      else
+        mpz_set_str(n1,'1234567890',10);
+
+      mp_randinit_default(state);
+      mp_randseed(state,n1);
+
+      mpz_urandomb(n1,state,bits);
+      mpz_urandomb(n2,state,bits);
+      mpz_ui_pow_ui(n3,2,bits);
+      mpz_add(n1,n1,n3);
+      mpz_add(n2,n2,n3);
+
+      writeln;
+      write('Suche erste Primzahl ...');
+      nextPrime(n1,maxThreads);
+      writeln;
+      write('... suche zweite Primzahl ...');
+      repeat
+        nextPrime(n2,maxThreads);
+      until mpz_cmp(n1,n2)<>0;
+
+      mpz_mul(modul,n2,n1);
+
+      mpz_sub_ui(n1,n1,1);
+      mpz_sub_ui(n2,n2,1);
+      mpz_mul(n3,n1,n2);
+
+      writeln;
+      writeln('... suche Exponenten ...');
+      repeat
+        mpz_urandomb(e_exponent,state,min(16,bits div 2));
+        mpz_setbit(e_exponent,0);
+      until mpz_invert(d_exponent,e_exponent,n3)<>0;
+      mpz_set_ui(e_exponent,1025);
+      mpz_sub_ui(d_exponent,modul,1000);
+
+      writeln('... verschlüssele ...');
+      symmetricEncryption(d_exponent,pass,edEnc,'latest');
+      writeln('... speichere ...');
+
+      pass.free;
+
+      writeln(privOut,'Modul: '+mpz_get_str(nil,16,modul));
+      writeln(privOut,'e-Exponent: '+mpz_get_str(nil,16,e_exponent));
+      writeln(privOut,'d-Exponent: '+mpz_get_str(nil,16,d_exponent));
+      writeln(pubOut,'Modul: '+mpz_get_str(nil,16,modul));
+      writeln(pubOut,'e-Exponent: '+mpz_get_str(nil,16,e_exponent));
+      writeln('... fertig');
+
+      mpz_clear(n1);
+      mpz_clear(n2);
+      mpz_clear(n3);
+      mpz_clear(modul);
+      mpz_clear(e_exponent);
+      mpz_clear(d_exponent);
+
+      closefile(privOut);
+      closefile(pubOut);
+    end;
+
+    raEnc: begin
+      mpz_init(n1);
+      mpz_init(n2);
+      mpz_init(n3);
+      mpz_init(modul);
+      mpz_init(e_exponent);
+      mpz_init(d_exponent);
+      if (importKey(modul,e_exponent,d_exponent,version,GetOptionValue('e','encrypt')) and $01) = 0 then begin
+        writeln('Keinen öffentlichen Schlüssel in Datei '''+GetOptionValue('e','encrypt')+''' gefunden!');
+        Terminate;
+        Exit;
+      end;
+
+      assignfile(binf,GetOptionValue('i','input'));
+      reset(binf,1);
+      assignfile(textf,GetOptionValue('o','output'));
+      rewrite(textf);
+
+      setlength(buff,1);
+      setlength(buff,(mpz_sizeinbase(modul,256) div sizeof(buff[0]))-1);
+      gelesen:=0;
+      zulesen:=8+filesize(binf);
+      fillchar(buff[0],length(buff)*sizeof(buff[0]),0);
+      while gelesen<zulesen do begin
+        if gelesen=0 then begin
+          for i:=0 to 7 do
+            buff[i]:=(filesize(binf) shr (8*i)) and $ff;
+          gelesen:=8;
+          i:=8 div sizeof(buff[0]);
+        end
+        else i:=0;
+
+        j:=min((length(buff)-i)*sizeof(buff[0]),zulesen-gelesen);
+        blockread(binf,buff[i],j);
+        gelesen:=gelesen + j;
+
+        mpz_set_ui(n1,0);
+        for j:=0 to length(buff)-1 do begin
+          mpz_mul_2exp(n1,n1,sizeof(buff[j])*8);
+          mpz_add_ui(n1,n1,buff[j]);
+        end;
+
+        mpz_powm(n2,n1,e_Exponent,modul);
+        writeln(textf,mpz_get_str(nil,16,n2));
+      end;
+
+      closefile(binf);
+      closefile(textf);
+
+      mpz_clear(n1);
+      mpz_clear(n2);
+      mpz_clear(n3);
+      mpz_clear(modul);
+      mpz_clear(e_exponent);
+      mpz_clear(d_exponent);
+    end;
+
+    raDec: begin
+      write('Passwort des Schlüssels eingeben: ');
+      readlnblind(pass);
+
+      mpz_init(n1);
+      mpz_init(n2);
+      mpz_init(n3);
+      mpz_init(modul);
+      mpz_init(e_exponent);
+      mpz_init(d_exponent);
+
+      if (importKey(modul,e_exponent,d_exponent,version,GetOptionValue('d','decrypt')) and $02) = 0 then begin
+        writeln('Keinen privaten Schlüssel in Datei '''+GetOptionValue('d','decrypt')+''' gefunden!');
+        Terminate;
+        Exit;
+      end;
+      symmetricEncryption(d_exponent,pass,edDec,version);
+
+      setlength(buff,1);
+      setlength(buff,(mpz_sizeinbase(modul,256) div sizeof(buff[0]))-1);
+      fillchar(buff[0],length(buff)*sizeof(buff[0]),0);
+
+      gelesen:=0;
+      zulesen:=-1;
+
+      assignfile(textf,GetOptionValue('i','input'));
+      reset(textf);
+      assignfile(binf,GetOptionValue('o','output'));
+      rewrite(binf,1);
+      while not eof(textf) do begin
+        readln(textf,s);
+        mpz_set_str(n1,pchar(s),16);
+        mpz_powm(n2,n1,d_Exponent,modul);
+
+        for i:=length(buff)-1 downto 0 do begin
+          buff[i]:=mpz_get_ui(n2) and $ff;
+          mpz_fdiv_q_2exp(n2,n2,8);
+        end;
+
+        if gelesen=0 then begin
+          zulesen:=0;
+          for i:=0 to 7 do
+            zulesen:=zulesen*256+buff[7-i];
+          i:=8 div sizeof(buff[0]);
+        end
+        else
+          i:=0;
+
+        j:=min(zulesen-gelesen,(length(buff)-i)*sizeof(buff[0]));
+        if j>0 then blockwrite(binf,buff[i],j);
+
+        gelesen:=gelesen+j;
+      end;
+
+      if gelesen <> zulesen then
+        writeln(inttostr(gelesen)+' Bytes geschrieben, aber es waren '+inttostr(zulesen)+' angekündigt!');
+
+      closefile(binf);
+      closefile(textf);
+
+      mpz_clear(n1);
+      mpz_clear(n2);
+      mpz_clear(n3);
+      mpz_clear(modul);
+      mpz_clear(e_exponent);
+      mpz_clear(d_exponent);
+    end;
+
+    raChk: begin
+      write('Passwort des Schlüssels eingeben: ');
+      readlnblind(pass);
+
+      mpz_init(n1);
+      mpz_init(n2);
+      mpz_init(modul);
+      mpz_init(e_exponent);
+      mpz_init(d_exponent);
+
+      if importKey(modul,e_exponent,d_exponent,version,GetOptionValue('c','check')) <> $03 then begin
+        writeln('Der Datei '''+GetOptionValue('c','check')+''' fehlt mindestens ein Schlüsselteil!');
+        Terminate;
+        Exit;
+      end;
+      symmetricEncryption(d_exponent,pass,edDec,version);
+
+      for i:=0 to 100 do begin
+        s:=copy(inttostr(i)+paramstr(0),1,mpz_sizeinbase(modul,256)-1);
+        mpz_set_str(n1,pchar(s),256);
+        mpz_powm(n2,n1,e_exponent,modul);
+        mpz_powm(n2,n2,d_exponent,modul);
+        if mpz_cmp(n1,n2)<>0 then
+          writeln('Entschlüsselter Text ist ungleich Original! - Passwort falsch?');
+      end;
+
+      writeln('Tests abgeschlossen.');
+
+      mpz_clear(n1);
+      mpz_clear(n2);
+      mpz_clear(modul);
+      mpz_clear(e_exponent);
+      mpz_clear(d_exponent);
+    end;
+
+    raUpd: begin
+      write('Passwort des Schlüssels eingeben: ');
+      readlnblind(pass);
+
+      mpz_init(n1);
+      mpz_init(n2);
+      mpz_init(modul);
+      mpz_init(e_exponent);
+      mpz_init(d_exponent);
+
+      if importKey(modul,e_exponent,d_exponent,version,GetOptionValue('u','update')) <> $03 then begin
+        writeln('Der Datei '''+GetOptionValue('u','update')+''' fehlt mindestens ein Schlüsselteil!');
+        Terminate;
+        Exit;
+      end;
+      symmetricEncryption(d_exponent,pass,edDec,version);
+
+      write('Neues Passwort vergeben? (j/n) ');
+      readln(s);
+      if pos('j',s)=1 then
+        readNewPassword(pass,ceil(sqrt(mpz_sizeinbase(modul,2)/8)));
+
+      version:='latest';
+      symmetricEncryption(d_exponent,pass,edEnc,version);
+      pass.free;
+
+      repeat
+        write('Ziel zum Speichern eingeben: ');
+        readln(s);
+      until (not fileexists(s)) and (not fileexists(s+'.pub'));
+
+      assignfile(privOut,s);
+      rewrite(privOut);
+      assignfile(pubOut,s+'.pub');
+      rewrite(pubOut);
+
+      writeln(privOut,'Modul: '+mpz_get_str(nil,16,modul));
+      writeln(privOut,'Version: '+version);
+      writeln(privOut,'e-Exponent: '+mpz_get_str(nil,16,e_exponent));
+      writeln(privOut,'d-Exponent: '+mpz_get_str(nil,16,d_exponent));
+      writeln(pubOut,'Modul: '+mpz_get_str(nil,16,modul));
+      writeln(pubOut,'e-Exponent: '+mpz_get_str(nil,16,e_exponent));
+
+      closefile(pubOut);
+      closefile(privOut);
+
+      mpz_clear(n1);
+      mpz_clear(n2);
+      mpz_clear(modul);
+      mpz_clear(e_exponent);
+      mpz_clear(d_exponent);
+    end;
+
+    else
+      writeln('Fehler: Funktion noch nicht implementiert!');
+  end{of case};
+
+  // stop program loop
+  Terminate;
+end;
+
+constructor TRSAApplication.Create(TheOwner: TComponent);
+begin
+  inherited Create(TheOwner);
+  StopOnException:=True;
+end;
+
+destructor TRSAApplication.Destroy;
+begin
+  inherited Destroy;
+end;
+
+procedure TRSAApplication.WriteHelp;
+begin
+  { add your help code here }
+  writeln('Usage: ',ExeName,' -h');
+  writeln(' get help');
+  writeln('Usage: ',ExeName,' -g/--generate $key [-b/--bits $Bits] [-r/--randomize] [-t/--threads $maxThreads]');
+  writeln(' generate key');
+  writeln('Usage: ',ExeName,' -e/--encrypt $key -i/--input $input -o/--output $output');
+  writeln(' encrypt with key');
+  writeln('Usage: ',ExeName,' -d/--decrypt $key -i/--input $input -o/--output $output');
+  writeln(' decrypt with key');
+  writeln('Usage: ',ExeName,' -c/--check $key');
+  writeln(' check integrity of key');
+  writeln('Usage: ',ExeName,' -u/--update $key');
+  writeln(' update key, possibly change passphrase');
+end;
+
+var
+  Application: TRSAApplication;
+begin
+  Application:=TRSAApplication.Create(nil);
+  Application.Title:='RSA Application';
+  Application.Run;
+  Application.Free;
+end.
+
diff --git a/rsa.lps b/rsa.lps
new file mode 100644
index 0000000..5b7c4fe
--- /dev/null
+++ b/rsa.lps
@@ -0,0 +1,220 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<CONFIG>
+  <ProjectSession>
+    <Version Value="9"/>
+    <BuildModes Active="Default"/>
+    <Units Count="15">
+      <Unit0>
+        <Filename Value="rsa.lpr"/>
+        <IsPartOfProject Value="True"/>
+        <TopLine Value="45"/>
+        <CursorPos Y="45"/>
+        <UsageCount Value="60"/>
+        <Loaded Value="True"/>
+      </Unit0>
+      <Unit1>
+        <Filename Value="rsaunit.pas"/>
+        <IsPartOfProject Value="True"/>
+        <UnitName Value="rsaunit"/>
+        <IsVisibleTab Value="True"/>
+        <EditorIndex Value="1"/>
+        <CursorPos X="72" Y="18"/>
+        <UsageCount Value="58"/>
+        <Loaded Value="True"/>
+      </Unit1>
+      <Unit2>
+        <Filename Value="mlockunit.pas"/>
+        <IsPartOfProject Value="True"/>
+        <UnitName Value="mlockunit"/>
+        <EditorIndex Value="-1"/>
+        <CursorPos X="28" Y="6"/>
+        <UsageCount Value="41"/>
+      </Unit2>
+      <Unit3>
+        <Filename Value="mmanunit.pas"/>
+        <IsPartOfProject Value="True"/>
+        <UsageCount Value="41"/>
+      </Unit3>
+      <Unit4>
+        <Filename Value="/usr/lib/fpc/src/packages/gmp/src/gmp.pas"/>
+        <TopLine Value="70"/>
+        <CursorPos X="18" Y="485"/>
+        <UsageCount Value="9"/>
+      </Unit4>
+      <Unit5>
+        <Filename Value="/usr/src/dcpcrypt/Ciphers/dcprijndael.pas"/>
+        <TopLine Value="22"/>
+        <UsageCount Value="8"/>
+      </Unit5>
+      <Unit6>
+        <Filename Value="/usr/src/dcpcrypt/dcpcrypt2.pas"/>
+        <TopLine Value="201"/>
+        <CursorPos X="39" Y="222"/>
+        <UsageCount Value="9"/>
+      </Unit6>
+      <Unit7>
+        <Filename Value="/usr/src/dcpcrypt/dcpblockciphers.pas"/>
+        <TopLine Value="61"/>
+        <CursorPos X="3" Y="81"/>
+        <UsageCount Value="8"/>
+      </Unit7>
+      <Unit8>
+        <Filename Value="/usr/src/dcpcrypt/Hashes/dcphaval.pas"/>
+        <TopLine Value="25"/>
+        <UsageCount Value="7"/>
+      </Unit8>
+      <Unit9>
+        <Filename Value="/usr/src/dcpcrypt/Ciphers/dcpmars.pas"/>
+        <TopLine Value="16"/>
+        <UsageCount Value="7"/>
+      </Unit9>
+      <Unit10>
+        <Filename Value="/usr/src/dcpcrypt/Ciphers/dcpblowfish.pas"/>
+        <TopLine Value="19"/>
+        <UsageCount Value="7"/>
+      </Unit10>
+      <Unit11>
+        <Filename Value="/usr/src/dcpcrypt/Ciphers/dcptwofish.pas"/>
+        <TopLine Value="22"/>
+        <CursorPos X="33" Y="54"/>
+        <UsageCount Value="7"/>
+      </Unit11>
+      <Unit12>
+        <Filename Value="/usr/src/dcpcrypt/Ciphers/dcpserpent.pas"/>
+        <TopLine Value="22"/>
+        <UsageCount Value="7"/>
+      </Unit12>
+      <Unit13>
+        <Filename Value="/usr/lib/fpc/src/rtl/inc/ctypes.pp"/>
+        <TopLine Value="37"/>
+        <UsageCount Value="8"/>
+      </Unit13>
+      <Unit14>
+        <Filename Value="/usr/lib/fpc/src/rtl/unix/baseunix.pp"/>
+        <TopLine Value="18"/>
+        <UsageCount Value="8"/>
+      </Unit14>
+    </Units>
+    <JumpHistory Count="30" HistoryIndex="29">
+      <Position1>
+        <Filename Value="rsaunit.pas"/>
+        <Caret Line="282" Column="29" TopLine="234"/>
+      </Position1>
+      <Position2>
+        <Filename Value="rsa.lpr"/>
+        <Caret Line="50" Column="20" TopLine="29"/>
+      </Position2>
+      <Position3>
+        <Filename Value="rsa.lpr"/>
+        <Caret Line="54" Column="29" TopLine="24"/>
+      </Position3>
+      <Position4>
+        <Filename Value="rsa.lpr"/>
+        <Caret Line="30" Column="10" TopLine="21"/>
+      </Position4>
+      <Position5>
+        <Filename Value="rsa.lpr"/>
+        <Caret Line="53" Column="24" TopLine="30"/>
+      </Position5>
+      <Position6>
+        <Filename Value="rsa.lpr"/>
+        <Caret Line="49" Column="32" TopLine="33"/>
+      </Position6>
+      <Position7>
+        <Filename Value="rsa.lpr"/>
+        <Caret Line="50" Column="23" TopLine="28"/>
+      </Position7>
+      <Position8>
+        <Filename Value="rsa.lpr"/>
+        <Caret Line="63" Column="16" TopLine="43"/>
+      </Position8>
+      <Position9>
+        <Filename Value="rsaunit.pas"/>
+        <Caret Line="516" Column="28" TopLine="499"/>
+      </Position9>
+      <Position10>
+        <Filename Value="rsaunit.pas"/>
+        <Caret Line="64" Column="24" TopLine="37"/>
+      </Position10>
+      <Position11>
+        <Filename Value="rsaunit.pas"/>
+        <Caret Line="433" Column="30" TopLine="397"/>
+      </Position11>
+      <Position12>
+        <Filename Value="rsaunit.pas"/>
+        <Caret Line="65" TopLine="46"/>
+      </Position12>
+      <Position13>
+        <Filename Value="rsaunit.pas"/>
+        <Caret Line="670" Column="76" TopLine="635"/>
+      </Position13>
+      <Position14>
+        <Filename Value="rsaunit.pas"/>
+        <Caret Line="677" TopLine="637"/>
+      </Position14>
+      <Position15>
+        <Filename Value="rsaunit.pas"/>
+        <Caret Line="77" TopLine="40"/>
+      </Position15>
+      <Position16>
+        <Filename Value="rsa.lpr"/>
+        <Caret Line="47" Column="23" TopLine="23"/>
+      </Position16>
+      <Position17>
+        <Filename Value="rsaunit.pas"/>
+        <Caret Line="423" Column="97" TopLine="403"/>
+      </Position17>
+      <Position18>
+        <Filename Value="rsaunit.pas"/>
+        <Caret Line="196" Column="32" TopLine="164"/>
+      </Position18>
+      <Position19>
+        <Filename Value="rsaunit.pas"/>
+        <Caret Line="46" Column="18" TopLine="25"/>
+      </Position19>
+      <Position20>
+        <Filename Value="rsaunit.pas"/>
+        <Caret Line="511" TopLine="470"/>
+      </Position20>
+      <Position21>
+        <Filename Value="rsaunit.pas"/>
+        <Caret Line="690" Column="41" TopLine="659"/>
+      </Position21>
+      <Position22>
+        <Filename Value="rsaunit.pas"/>
+        <Caret Line="45" Column="12" TopLine="25"/>
+      </Position22>
+      <Position23>
+        <Filename Value="rsaunit.pas"/>
+        <Caret Line="206" Column="26" TopLine="185"/>
+      </Position23>
+      <Position24>
+        <Filename Value="rsaunit.pas"/>
+        <Caret Line="665" Column="17" TopLine="645"/>
+      </Position24>
+      <Position25>
+        <Filename Value="rsaunit.pas"/>
+        <Caret Line="690" Column="8" TopLine="659"/>
+      </Position25>
+      <Position26>
+        <Filename Value="rsaunit.pas"/>
+      </Position26>
+      <Position27>
+        <Filename Value="rsaunit.pas"/>
+        <Caret Line="700" TopLine="659"/>
+      </Position27>
+      <Position28>
+        <Filename Value="rsaunit.pas"/>
+        <Caret Line="690" Column="8" TopLine="659"/>
+      </Position28>
+      <Position29>
+        <Filename Value="rsaunit.pas"/>
+        <Caret Line="56" Column="75" TopLine="46"/>
+      </Position29>
+      <Position30>
+        <Filename Value="rsaunit.pas"/>
+        <Caret Line="12" Column="41"/>
+      </Position30>
+    </JumpHistory>
+  </ProjectSession>
+</CONFIG>
diff --git a/rsaunit.pas b/rsaunit.pas
new file mode 100644
index 0000000..cf0c5e7
--- /dev/null
+++ b/rsaunit.pas
@@ -0,0 +1,709 @@
+unit rsaunit;
+
+{$mode objfpc}{$H+}
+
+interface
+
+uses
+  Classes, SysUtils, gmp, math, crt, mlockunit,
+  dcprijndael, dcpmars, dcpblowfish, dcptwofish, dcpserpent, dcpcrypt2,
+  dcphaval;
+
+type
+  tRSAAction = (raUnk,raGen,raEnc,raDec,raChk,raUpd);
+  tEncryptionDirection = (edEnc,edDec);
+  tUsedCiphers = (ucRijndael,ucMars,ucBlowfish,ucTwofish,ucSerpent);
+
+  tLockedString = class
+  private
+    _inh:          pchar;
+    memstart:      pointer;
+    locked,memlen,
+      pagesize:    longint;
+    procedure lock;
+    procedure unlock;
+    procedure wInh(i: pchar);
+  public
+    constructor create;
+    destructor destroy; override;
+    procedure assign(ls: tLockedString);
+    procedure delete(posi,leng: longint);
+    procedure append(s: string);
+    function substr(start,leng: longint): string;
+    function len: longint;
+    function isEqual(s: tLockedString): boolean;
+    function teil(num,tot: longint): string; overload;
+    function teil(cph: tUsedCiphers): string; overload;
+    property inh: pchar
+      read _inh
+      write wInh;
+  end;
+
+  tNextPrimeThread = class(tThread)
+    fertig:      byte; // Bit 0: Primzahl gefunden; Bit 1: execute beendet
+    myNum:       mpz_t;
+    abbruch,
+      arbeite:   boolean;
+    myStep:      longint;
+    cnt:         int64;
+    constructor create(num: mpz_t; offset,step: longint);
+    destructor destroy; override;
+    procedure execute; override;
+  end;
+
+function acquireRandomness(bytes: int64): string; // hex-encoded
+function nextPrime(var num: mpz_t; threads: longint): boolean;
+function nextPrimeSt(var num: mpz_t; step: longint; var keepWorking, abort: boolean; var getestet: int64): boolean; // Prime found?
+function importKey(var m,e,d: mpz_t; out version: string; nam: string): byte; // bit 0: enc-Key found; bit 1: dec-Key found
+procedure symmetricEncryption(var input: mpz_t; key: tLockedString; direction: tEncryptionDirection; version: string);
+function hexdump(arr: array of byte): string; overload;
+function hexdump(s: string): string; overload;
+procedure readlnblind(out s: tLockedString);
+procedure userCallback;
+function mydatetimetostr(tm: extended): string;
+procedure readNewPassword(var pass: tLockedString; len: int64);
+function cpuUtilization: extended;
+
+const
+  cipherClasses: array[tUsedCiphers] of class of TDCP_blockcipher =
+    (tDCP_Rijndael,tDCP_Mars,tDCP_Blowfish,tDCP_Twofish,tDCP_Serpent);
+  ciphNam: array[tUsedCiphers] of string =
+    ('Rijndael','Mars','Blowfish','Twofish','Serpent');
+
+implementation
+
+var
+  _cpuLastUsed,_cpuLastIdle: int64;
+
+function acquireRandomness(bytes: int64): string;
+var
+  tf:   file;
+  buff: array of byte;
+  i,j:  int64;
+begin
+  write(stderr,'Zufall sammeln ...');
+  try
+    assignfile(tf,'/dev/random');
+    setlength(buff,bytes);
+    i:=0;
+    j:=0;
+    reset(tf,1);
+    while i<length(buff) do begin
+      blockread(tf,buff[i],(length(buff)-i)*sizeof(buff[0]),j);
+      i:=i+j;
+      if i<length(buff) then begin
+        write(stderr,'.');
+        sleep(100);
+        userCallback;
+      end;
+    end;
+  finally
+    closefile(tf);
+  end;
+  result:='';
+  for i:=0 to length(buff)-1 do
+    result:=result+inttohex(buff[i],2);
+  writeln(stderr,' fertig');
+end;
+
+function nextPrime(var num: mpz_t; threads: longint): boolean;
+// multi threaded
+var
+  npts:           array of tNextPrimeThread;
+  i,cnt,step,
+    x,y,penalty:  longint;
+  offsets:        array of longint;
+  dummy:          mpz_t;
+  total:          int64;
+  enps,start:     extended;
+begin
+  mpz_setbit(num,0);
+  result:=false;
+
+  setlength(offsets,0);
+  step:=0;
+
+  enps:=mpz_sizeinbase(num,2)*ln(2)/2;
+
+  mpz_init(dummy);
+  repeat
+    cnt:=0;
+    for i:=0 to length(offsets)-1 do begin
+      mpz_add_ui(dummy,num,offsets[i]);
+      if mpz_gcd_ui(dummy,dummy,step)=1 then inc(cnt)
+      else offsets[i]:=-1;
+    end;
+    if cnt<threads then begin // zu wenige wirklich arbeitende Threads?
+      setlength(offsets,max(threads,length(offsets)+1));
+      for i:=0 to length(offsets)-1 do
+        offsets[i]:=i*2;
+      step:=2*length(offsets);
+    end;
+  until cnt>=threads; // genug wirklich arbeitende Threads?
+  mpz_clear(dummy);
+
+  if cnt<>threads then
+    writeln(stderr,'Genau '+inttostr(threads)+' arbeitende Threads habe ich nicht hinbekommen, daher habe ich auf '+inttostr(cnt)+' Threads erhöht.');
+
+  setlength(npts,cnt);
+  cnt:=0;
+  for i:=0 to length(npts)-1 do begin
+    while (cnt<length(offsets)) and (offsets[cnt]=-1) do
+      inc(cnt);
+    if cnt>=length(offsets) then
+      raise Exception.create('Ich habe mich bei den Threads verzählt (zu viele Threads)!');
+
+    npts[i]:=tNextPrimeThread.create(num,offsets[cnt],step);
+    inc(cnt);
+  end;
+
+  while (cnt<length(offsets)) and (offsets[cnt]=-1) do
+    inc(cnt);
+
+  if cnt<>length(offsets) then
+    raise Exception.create('Ich habe mich bei den Threads verzählt (zu wenige Threads)!');
+
+  for i:=0 to length(npts)-1 do
+    npts[i].suspended:=false;
+
+  x:=whereX;
+  y:=whereY;
+  start:=now;
+  penalty:=0;
+  repeat
+    for i:=0 to length(npts)-1 do
+      result:=result or odd(npts[i].fertig);
+    if not result then begin
+      if penalty=0 then sleep(1000)
+      else sleep(100);
+      total:=0;
+      for i:=0 to length(npts)-1 do
+        total:=total+npts[i].cnt;
+
+      gotoxy(x,y);
+      x:=whereX;
+      y:=whereY;
+      write(' '+floattostrf(total/enps*100,ffFixed,10,3)+' % ETA: '+mydatetimetostr((now-start)/max(1,total)*enps)+'  ');
+
+      if cpuUtilization > 0.8 then begin
+        inc(penalty);
+        if penalty>2 then begin
+          for i:=0 to length(npts)-1 do
+            npts[i].arbeite:=false;
+          writeln('Zu hohe Gesamtlast auf der CPU, ich pausiere!');
+
+          repeat
+            userCallback;
+            sleep(1000);
+          until cpuUtilization<0.4;
+
+          penalty:=0;
+          writeln('CPU-Last ist wieder gesunken, ich mache weiter!');
+          for i:=0 to length(npts)-1 do
+            npts[i].arbeite:=true;
+        end;
+      end
+      else penalty:=0;
+
+      userCallback;
+    end;
+  until result;
+
+  for i:=0 to length(npts)-1 do
+    npts[i].abbruch:=true;
+
+  repeat
+    result:=true;
+    for i:=0 to length(npts)-1 do
+      result:=result and odd(npts[i].fertig shr 1);
+    if not result then sleep(100);
+  until result;
+
+  result:=false;
+  for i:=0 to length(npts)-1 do begin
+    if (not result) and odd(npts[i].fertig) then begin
+      result:=true;
+      mpz_set(num,npts[i].myNum);
+    end;
+    npts[i].free;
+  end;
+end;
+
+function nextPrimeSt(var num: mpz_t; step: longint; var keepWorking, abort: boolean; var getestet: int64): boolean;
+// single threaded
+begin
+  step:=step+byte(odd(step));
+  mpz_setbit(num,0);
+  result:=false;
+
+  getestet:=0;
+  result:=mpz_probab_prime_p(num,25) > 0;
+  while not (abort or result) do begin
+    while not keepWorking do
+      sleep(100);
+    userCallback;
+    mpz_add_ui(num,num,step);
+    inc(getestet);
+    result:=mpz_probab_prime_p(num,25) > 0;
+  end;
+end;
+
+function importKey(var m,e,d: mpz_t; out version: string; nam: string): byte; // bit 0: enc-Key found; bit 1: dec-Key found
+var
+  f: textfile;
+  s: string;
+begin
+  assignfile(f,nam);
+  reset(f);
+  result:=0;
+  version:='';
+  while not eof(f) do begin
+    readln(f,s);
+    if pos('Modul: ',s)=1 then begin
+      delete(s,1,pos(' ',s));
+      s:=trim(s);
+      mpz_set_str(m,pchar(s),16);
+      result:=result or $04;
+      continue;
+    end;
+    if pos('d-Exponent: ',s)=1 then begin
+      delete(s,1,pos(' ',s));
+      s:=trim(s);
+      mpz_set_str(d,pchar(s),16);
+      result:=result or $02;
+      continue;
+    end;
+    if pos('e-Exponent: ',s)=1 then begin
+      delete(s,1,pos(' ',s));
+      s:=trim(s);
+      mpz_set_str(e,pchar(s),16);
+      result:=result or $01;
+      continue;
+    end;
+    if pos('Version: ',s)=1 then begin
+      delete(s,1,pos(' ',s));
+      version:=trim(s);
+      continue;
+    end;
+    writeln(stderr,'Warnung: Unbekannte Zeile in Schlüsseldatei gefunden und ignoriert.');
+  end;
+  if (result and $04) = 0 then result:=$00
+  else result:=result and $03;
+  closefile(f);
+end;
+
+procedure symmetricEncryption(var input: mpz_t; key: tLockedString; direction: tEncryptionDirection; version: string);
+var
+  ciphers:      array[tUsedCiphers] of TDCP_blockcipher;
+  ciph:         tUsedCiphers;
+  i:            longint;
+  bs,vNum:      int64;
+  inh:          array[boolean] of array of byte;
+  curr:         boolean;
+  mpLen:        mpz_t;
+begin
+
+  if version='' then
+    vNum:=0
+  else if version='latest' then begin
+    vNum:=1;
+    version:=inttostr(vNum);
+  end
+  else
+    vNum:=strtoint(version);
+
+  if direction=edEnc then begin
+    bs:=input.size*sizeof(input.data^);
+
+    mpz_mul_2exp(input,input,sizeof(bs)*8);
+    mpz_add_ui(input,input,bs);
+  end;
+
+  mpz_init(mpLen);
+  mpz_set_ui(mpLen,1);
+
+  for ciph:=low(tUsedCiphers) to high(tUsedCiphers) do begin
+    ciphers[ciph]:=cipherClasses[ciph].Create(nil);
+    case vNum of
+      0: ciphers[ciph].InitStr(key.teil(ciph),TDCP_haval);
+      1: ciphers[ciph].InitStr(key.inh+ciphNam[ciph],TDCP_haval);
+    end{of case};
+    mpz_lcm_ui(mpLen,mpLen,ciphers[ciph].getBlockSize div 8);
+  end;
+
+  bs:=mpz_get_ui(mpLen);
+  mpz_clear(mpLen);
+  bs:=ceil(bs/(input.size*sizeOf(input.data^)))*input.size*sizeOf(input.data^);
+
+  for curr:=false to true do begin
+    setlength(inh[curr],bs);
+    fillchar(inh[curr][0],length(inh[curr]),$00);
+    move(input.data^,inh[curr][0],min(length(inh[curr]),input.size*sizeOf(input.data^)));
+  end;
+
+  curr:=false;
+
+  if direction=edEnc then begin
+    for ciph:=low(tUsedCiphers) to high(tUsedCiphers) do begin
+      bs:=ciphers[ciph].getBlockSize div 8;
+      for i:=0 to (length(inh[curr]) div bs)-1 do begin
+        inh[curr][i*bs]:=inh[curr][i*bs] xor (i and $ff);
+        ciphers[ciph].EncryptECB(inh[curr][i*bs],inh[not curr][i*bs]);
+      end;
+      curr:=not curr;
+    end;
+  end
+  else
+    for ciph:=high(tUsedCiphers) downto low(tUsedCiphers) do begin
+      bs:=ciphers[ciph].getBlockSize div 8;
+      for i:=0 to (length(inh[curr]) div bs)-1 do begin
+        ciphers[ciph].DecryptECB(inh[curr][i*bs],inh[not curr][i*bs]);
+        inh[not curr][i*bs]:=inh[not curr][i*bs] xor (i and $ff);
+      end;
+      curr:=not curr;
+    end;
+
+  if direction=edDec then begin
+    bs:=0;
+    for i:=sizeof(bs)-1 downto 0 do
+      bs:=(bs shl 8) or inh[curr][i];
+
+    mpz_realloc2(input,bs*8);
+    move(inh[curr][sizeof(bs)],input.data^,input.alloc*sizeof(input.data^));
+  end
+  else begin
+    mpz_realloc2(input,length(inh[curr])*8);
+    move(inh[curr][0],input.data^,input.alloc*sizeof(input.data^));
+  end;
+
+  input.size:=input.alloc;
+
+  for curr:=false to true do
+    setlength(inh[curr],0);
+
+  for ciph:=low(tUsedCiphers) to high(tUsedCiphers) do
+    ciphers[ciph].free;
+end;
+
+function hexdump(arr: array of byte): string;
+var i: longint;
+begin
+  result:='';
+  for i:=0 to length(arr)-1 do
+    result:=result + inttohex(arr[i],2);
+end;
+
+function hexdump(s: string): string;
+var i: longint;
+begin
+  result:='';
+  for i:=1 to length(s) do
+    result:=result + inttohex(ord(s[i]),2);
+end;
+
+procedure readlnblind(out s: tLockedString);
+var c: char;
+begin
+  s:=tLockedString.create;
+  c:=#0;
+  while not (c in [#13,#27]) do begin
+    c:=readkey;
+    case c of
+      #8:
+        s.delete(s.len,1);
+      #13,#27:
+        writeln;
+      else
+        s.append(c);
+    end{of case};
+  end;
+end;
+
+procedure userCallback;
+begin
+  if keypressed then
+    if readkey in [#27,'q'] then begin
+      writeln('Abbruch durch Benutzer!');
+      halt;
+    end;
+end;
+
+function mydatetimetostr(tm: extended): string;
+var
+  zeit: int64;
+begin
+  zeit:=floor(tm*24*60*60);                 // in Sekunden
+  result:=inttostr(zeit mod 60);            // Sekunden
+  zeit:=zeit div 60;
+  if zeit=0 then exit;
+  while length(result)<2 do
+    result:='0'+result;
+  result:=inttostr(zeit mod 60)+':'+result; // Minuten
+  zeit:=zeit div 60;
+  if zeit=0 then exit;
+  while length(result)<5 do
+    result:='0'+result;
+  result:=inttostr(zeit mod 24)+':'+result; // Stunden
+  zeit:=zeit div 24;
+  if zeit=0 then exit;
+  result:=', '+result;
+  if (zeit mod 7)<>1 then result:='e'+result;
+  result:=inttostr(zeit mod 7)+' Tag'+result;
+  zeit:=zeit div 7;
+  if zeit=0 then exit;
+  result:=', '+result;
+  if zeit<>1 then result:='n'+result;
+  result:=inttostr(zeit)+' Woche'+result;
+end;
+
+procedure readNewPassword(var pass: tLockedString; len: int64);
+var
+  cPass: tLockedString;
+begin
+  cPass:=nil;
+  repeat
+    if cPass<>nil then
+      writeln('Fehler: Die Passwörter unterscheiden sich!');
+    pass.free;
+    write('Passwort zum Sichern des Schlüssels eingeben: ');
+    readlnblind(pass);
+    cPass.Free;
+    write('Wiederholen: ');
+    readlnblind(cPass);
+    if pass.inh='' then begin
+      writeln('Fehler: Leeres Passwort!');
+      pass.free;
+      cPass.free;
+      halt(1);
+    end;
+    if pass.len<len then begin
+      writeln('Fehler: Passwort zu kurz, sollte mindestens '+inttostr(len)+' Zeichen lang sein!');
+      pass.inh:='';
+      continue;
+    end;
+  until pass.isEqual(cPass) and (pass.len<>0);
+  cPass.Free;
+end;
+
+function cpuUtilization: extended;
+var
+  procstat:  textfile;
+  s:         string;
+  used,idle: int64;
+  i:         integer;
+begin
+  result:=0;
+  s:='';
+  assignfile(procstat,'/proc/stat');
+  reset(procstat);
+  while not eof(procstat) do begin
+    readln(procstat,s);
+    if pos('cpu ',s)=1 then break;
+  end;
+  closefile(procstat);
+  if pos('cpu ',s)<>1 then exit;
+  delete(s,1,pos(' ',s));
+  s:=trim(s);
+  used:=0;
+  idle:=0;
+  for i:=0 to 3 do begin
+    used:=used+idle;
+    idle:=strtoint(copy(s,1,pos(' ',s)-1));
+    delete(s,1,pos(' ',s));
+    s:=trim(s);
+  end;
+  result:=(used-_cpuLastUsed)/max(1,used-_cpuLastUsed + idle-_cpuLastIdle);
+  _cpuLastUsed:=used;
+  _cpuLastIdle:=idle;
+end;
+
+// tLockedString ***************************************************************
+
+constructor tLockedString.create;
+begin
+  inherited create;
+  pagesize:=sysconf(_SC_PAGESIZE);
+
+  locked:=0;
+  memlen:=0;
+  _inh:=nil;
+  memstart:=nil;
+end;
+
+destructor tLockedString.destroy;
+begin
+  unlock;
+  inherited destroy;
+end;
+
+procedure tLockedString.lock;
+begin
+  if locked>0 then begin
+    if (locked and (pagesize-1)) <> 0 then          // nur ganze Speicherseiten locken!
+      locked:=(locked and not (pagesize-1)) + pagesize;
+    memlen:=locked+pagesize;
+    getmem(memstart,memlen);
+    if memstart=nil then begin
+      writeln('Fehler beim Reservieren des Speichers!');
+      halt(1);
+    end;
+    _inh:=pchar(uint64(memstart) and not (pagesize-1)) + pagesize;
+    if mlock(_inh,locked)<>0 then begin
+      writeln('Fehler beim Sperren des Speichers!');
+      halt(1);
+    end;
+  end;
+end;
+
+procedure tLockedString.unlock;
+begin
+  if locked>0 then begin
+    fillchar(memstart^,memlen,$00);
+    if munlock(_inh,locked)<>0 then begin
+      writeln('Fehler beim Entsperren des Speichers!');
+      halt(1);
+    end;
+    freemem(memstart,memlen);
+    memlen:=0;
+    locked:=0;
+  end;
+end;
+
+procedure tLockedString.wInh(i: pchar);
+begin
+  if length(i)>=locked-1 then begin
+    unlock;
+    locked:=length(i)+1;
+    lock;
+  end;
+  move(i^,_inh^,length(i)+1);
+end;
+
+procedure tLockedString.assign(ls: tLockedString);
+begin
+  unlock;
+  locked:=ls.len+1;
+  lock;
+  move(ls._inh^,_inh^,ls.len+1);
+end;
+
+procedure tLockedString.delete(posi,leng: longint);
+var
+  tmp: tLockedString;
+begin
+  if len=0 then exit;
+  while posi<1 do
+    posi:=posi+len;
+  leng:=min(leng,len-posi+1);
+  if leng=0 then exit;
+
+  tmp:=tLockedString.create;
+  tmp.assign(self);
+  move((tmp._inh+posi-1+leng)^,(_inh+posi-1)^,len+2-posi-leng);
+  tmp.free;
+end;
+
+procedure tLockedString.append(s: string);
+var
+  tmp: tLockedString;
+begin
+  if length(s)=0 then exit;
+  if len=0 then begin
+    inh:=pchar(s);
+    exit;
+  end;
+
+  tmp:=tLockedString.create;
+  tmp.assign(self);
+  unlock;
+
+  locked:=tmp.len+length(s)+1;
+  lock;
+
+  move(tmp._inh^,_inh^,tmp.len);        // Teil 1
+  move(s[1],(_inh+tmp.len)^,length(s)); // Teil 2
+  (_inh+tmp.len+length(s)+1)^:=#0;      // Terminator
+
+  tmp.free;
+end;
+
+function tLockedString.substr(start,leng: longint): string;
+begin
+  leng:=min(leng,len-start+1);
+  if leng<=0 then begin
+    result:='';
+    exit;
+  end;
+  setlength(result,leng);
+  move((_inh+(start-1))^,result[1],length(result));
+end;
+
+function tLockedString.len: longint;
+begin
+  result:=length(_inh);
+end;
+
+function tLockedString.isEqual(s: tLockedString): boolean;
+begin
+  result:=s.len=len;
+  if result and (len<>0) then
+    result:=compareMem(s._inh,_inh,len+1);
+end;
+
+function tLockedString.teil(cph: tUsedCiphers): string;
+begin
+  result:=
+    teil(ord(cph),ord(high(tUsedCiphers))-ord(low(tUsedCiphers))+1);
+end;
+
+function tLockedString.teil(num,tot: longint): string;
+begin
+  result:=
+    substr(
+      round(1 + num/(2*tot+1)*2*len),
+      ceil(3*len/(2*tot+1))
+    );
+end;
+
+// tNextPrimeThread ************************************************************
+
+constructor tNextPrimeThread.create(num: mpz_t; offset,step: longint);
+begin
+  inherited create(true);
+  fertig:=0;
+  abbruch:=false;
+  arbeite:=true;
+  mpz_init(myNum);
+  mpz_add_ui(myNum,num,offset);
+  myStep:=step;
+  cnt:=0;
+end;
+
+destructor tNextPrimeThread.destroy;
+begin
+  mpz_clear(myNum);
+  inherited destroy;
+end;
+
+procedure tNextPrimeThread.execute;
+var
+  dummy:        mpz_t;
+  hoffnungslos: boolean;
+begin
+  mpz_init(dummy);
+  hoffnungslos:=mpz_gcd_ui(dummy,myNum,myStep)>1;
+  mpz_clear(dummy);
+  if hoffnungslos then
+    writeln(stderr,'Warnung: Dieser Thread kann keine Primzahlen finden.')
+  else
+    if nextPrimeSt(myNum,myStep,arbeite,abbruch,cnt) then
+      fertig:=fertig or $01;
+  fertig:=fertig or $02;
+end;
+
+begin
+  ReturnNilIfGrowHeapFails:=true;
+  _cpuLastUsed:=0;
+  _cpuLastIdle:=0;
+end.
+