home *** CD-ROM | disk | FTP | other *** search
/ Reverse Code Engineering RCE CD +sandman 2000 / ReverseCodeEngineeringRceCdsandman2000.iso / RCE / Quantico / km / keym1.pas.txt < prev    next >
Encoding:
Text File  |  2000-05-25  |  10.6 KB  |  235 lines
  1. Program Keymaker1;
  2.  
  3. uses crt,palette,dos;
  4.  
  5.  
  6.  
  7. {$L ULONGS.OBJ}                         { link in the assembly code }
  8.  
  9. FUNCTION LongADD (Addend1,Addend2:LONGINT):LONGINT;   EXTERNAL;
  10.  
  11. FUNCTION LongSUB (LongWord,Subtrahend:LONGINT):LONGINT;  EXTERNAL;
  12.  
  13. FUNCTION LongMUL (Multiplicand,Multiplier:LONGINT):LONGINT; EXTERNAL;
  14.  
  15. FUNCTION LongDIV (Dividend,Divisor:LONGINT):LONGINT;  EXTERNAL;
  16.  
  17. FUNCTION LongMOD (Dividend,Divisor:LONGINT):LONGINT;  EXTERNAL;
  18.  
  19. PROCEDURE WriteULong (LongWord:LONGINT;     { the longword          }
  20.  
  21.                       Width:BYTE;           { _minimum_ field width }
  22.  
  23.                       FillChar:CHAR;        { leading space char    }
  24.  
  25.                       Base:BYTE); EXTERNAL; { number base 2..26     }
  26.  
  27.  
  28.  
  29. const Base: array[0..1023] of byte = (
  30.  
  31.     $00, $00, $00, $00, $96, $30, $07, $77, $2C, $61, $0E, $EE, $BA, $51, $09, $99,
  32.  
  33.     $19, $C4, $6D, $07, $8F, $F4, $6A, $70, $35, $A5, $63, $E9, $A3, $95, $64, $9E,
  34.  
  35.     $32, $88, $DB, $0E, $A4, $B8, $DC, $79, $1E, $E9, $D5, $E0, $88, $D9, $D2, $97,
  36.  
  37.     $2B, $4C, $B6, $09, $BD, $7C, $B1, $7E, $07, $2D, $B8, $E7, $91, $1D, $BF, $90,
  38.  
  39.     $64, $10, $B7, $1D, $F2, $20, $B0, $6A, $48, $71, $B9, $F3, $DE, $41, $BE, $84,
  40.  
  41.     $7D, $D4, $DA, $1A, $EB, $E4, $DD, $6D, $51, $B5, $D4, $F4, $C7, $85, $D3, $83,
  42.  
  43.     $56, $98, $6C, $13, $C0, $A8, $6B, $64, $7A, $F9, $62, $FD, $EC, $C9, $65, $8A,
  44.  
  45.     $4F, $5C, $01, $14, $D9, $6C, $06, $63, $63, $3D, $0F, $FA, $F5, $0D, $08, $8D,
  46.  
  47.     $C8, $20, $6E, $3B, $5E, $10, $69, $4C, $E4, $41, $60, $D5, $72, $71, $67, $A2,
  48.  
  49.     $D1, $E4, $03, $3C, $47, $D4, $04, $4B, $FD, $85, $0D, $D2, $6B, $B5, $0A, $A5,
  50.  
  51.     $FA, $A8, $B5, $35, $6C, $98, $B2, $42, $D6, $C9, $BB, $DB, $40, $F9, $BC, $AC,
  52.  
  53.     $E3, $6C, $D8, $32, $75, $5C, $DF, $45, $CF, $0D, $D6, $DC, $59, $3D, $D1, $AB,
  54.  
  55.     $AC, $30, $D9, $26, $3A, $00, $DE, $51, $80, $51, $D7, $C8, $16, $61, $D0, $BF,
  56.  
  57.     $B5, $F4, $B4, $21, $23, $C4, $B3, $56, $99, $95, $BA, $CF, $0F, $A5, $BD, $B8,
  58.  
  59.     $9E, $B8, $02, $28, $08, $88, $05, $5F, $B2, $D9, $0C, $C6, $24, $E9, $0B, $B1,
  60.  
  61.     $87, $7C, $6F, $2F, $11, $4C, $68, $58, $AB, $1D, $61, $C1, $3D, $2D, $66, $B6,
  62.  
  63.     $90, $41, $DC, $76, $06, $71, $DB, $01, $BC, $20, $D2, $98, $2A, $10, $D5, $EF,
  64.  
  65.     $89, $85, $B1, $71, $1F, $B5, $B6, $06, $A5, $E4, $BF, $9F, $33, $D4, $B8, $E8,
  66.  
  67.     $A2, $C9, $07, $78, $34, $F9, $00, $0F, $8E, $A8, $09, $96, $18, $98, $0E, $E1,
  68.  
  69.     $BB, $0D, $6A, $7F, $2D, $3D, $6D, $08, $97, $6C, $64, $91, $01, $5C, $63, $E6,
  70.  
  71.     $F4, $51, $6B, $6B, $62, $61, $6C, $1C, $D8, $30, $65, $85, $4E, $00, $62, $F2,
  72.  
  73.     $ED, $95, $06, $6C, $7B, $A5, $01, $1B, $C1, $F4, $08, $82, $57, $C4, $0F, $F5,
  74.  
  75.     $C6, $D9, $B0, $65, $50, $E9, $B7, $12, $EA, $B8, $BE, $8B, $7C, $88, $B9, $FC,
  76.  
  77.     $DF, $1D, $DD, $62, $49, $2D, $DA, $15, $F3, $7C, $D3, $8C, $65, $4C, $D4, $FB,
  78.  
  79.     $58, $61, $B2, $4D, $CE, $51, $B5, $3A, $74, $00, $BC, $A3, $E2, $30, $BB, $D4,
  80.  
  81.     $41, $A5, $DF, $4A, $D7, $95, $D8, $3D, $6D, $C4, $D1, $A4, $FB, $F4, $D6, $D3,
  82.  
  83.     $6A, $E9, $69, $43, $FC, $D9, $6E, $34, $46, $88, $67, $AD, $D0, $B8, $60, $DA,
  84.  
  85.     $73, $2D, $04, $44, $E5, $1D, $03, $33, $5F, $4C, $0A, $AA, $C9, $7C, $0D, $DD,
  86.  
  87.     $3C, $71, $05, $50, $AA, $41, $02, $27, $10, $10, $0B, $BE, $86, $20, $0C, $C9,
  88.  
  89.     $25, $B5, $68, $57, $B3, $85, $6F, $20, $09, $D4, $66, $B9, $9F, $E4, $61, $CE,
  90.  
  91.     $0E, $F9, $DE, $5E, $98, $C9, $D9, $29, $22, $98, $D0, $B0, $B4, $A8, $D7, $C7,
  92.  
  93.     $17, $3D, $B3, $59, $81, $0D, $B4, $2E, $3B, $5C, $BD, $B7, $AD, $6C, $BA, $C0,
  94.  
  95.     $20, $83, $B8, $ED, $B6, $B3, $BF, $9A, $0C, $E2, $B6, $03, $9A, $D2, $B1, $74,
  96.  
  97.     $39, $47, $D5, $EA, $AF, $77, $D2, $9D, $15, $26, $DB, $04, $83, $16, $DC, $73,
  98.  
  99.     $12, $0B, $63, $E3, $84, $3B, $64, $94, $3E, $6A, $6D, $0D, $A8, $5A, $6A, $7A,
  100.  
  101.     $0B, $CF, $0E, $E4, $9D, $FF, $09, $93, $27, $AE, $00, $0A, $B1, $9E, $07, $7D,
  102.  
  103.     $44, $93, $0F, $F0, $D2, $A3, $08, $87, $68, $F2, $01, $1E, $FE, $C2, $06, $69,
  104.  
  105.     $5D, $57, $62, $F7, $CB, $67, $65, $80, $71, $36, $6C, $19, $E7, $06, $6B, $6E,
  106.  
  107.     $76, $1B, $D4, $FE, $E0, $2B, $D3, $89, $5A, $7A, $DA, $10, $CC, $4A, $DD, $67,
  108.  
  109.     $6F, $DF, $B9, $F9, $F9, $EF, $BE, $8E, $43, $BE, $B7, $17, $D5, $8E, $B0, $60,
  110.  
  111.     $E8, $A3, $D6, $D6, $7E, $93, $D1, $A1, $C4, $C2, $D8, $38, $52, $F2, $DF, $4F,
  112.  
  113.     $F1, $67, $BB, $D1, $67, $57, $BC, $A6, $DD, $06, $B5, $3F, $4B, $36, $B2, $48,
  114.  
  115.     $DA, $2B, $0D, $D8, $4C, $1B, $0A, $AF, $F6, $4A, $03, $36, $60, $7A, $04, $41,
  116.  
  117.     $C3, $EF, $60, $DF, $55, $DF, $67, $A8, $EF, $8E, $6E, $31, $79, $BE, $69, $46,
  118.  
  119.     $8C, $B3, $61, $CB, $1A, $83, $66, $BC, $A0, $D2, $6F, $25, $36, $E2, $68, $52,
  120.  
  121.     $95, $77, $0C, $CC, $03, $47, $0B, $BB, $B9, $16, $02, $22, $2F, $26, $05, $55,
  122.  
  123.     $BE, $3B, $BA, $C5, $28, $0B, $BD, $B2, $92, $5A, $B4, $2B, $04, $6A, $B3, $5C,
  124.  
  125.     $A7, $FF, $D7, $C2, $31, $CF, $D0, $B5, $8B, $9E, $D9, $2C, $1D, $AE, $DE, $5B,
  126.  
  127.     $B0, $C2, $64, $9B, $26, $F2, $63, $EC, $9C, $A3, $6A, $75, $0A, $93, $6D, $02,
  128.  
  129.     $A9, $06, $09, $9C, $3F, $36, $0E, $EB, $85, $67, $07, $72, $13, $57, $00, $05,
  130.  
  131.     $82, $4A, $BF, $95, $14, $7A, $B8, $E2, $AE, $2B, $B1, $7B, $38, $1B, $B6, $0C,
  132.  
  133.     $9B, $8E, $D2, $92, $0D, $BE, $D5, $E5, $B7, $EF, $DC, $7C, $21, $DF, $DB, $0B,
  134.  
  135.     $D4, $D2, $D3, $86, $42, $E2, $D4, $F1, $F8, $B3, $DD, $68, $6E, $83, $DA, $1F,
  136.  
  137.     $CD, $16, $BE, $81, $5B, $26, $B9, $F6, $E1, $77, $B0, $6F, $77, $47, $B7, $18,
  138.  
  139.     $E6, $5A, $08, $88, $70, $6A, $0F, $FF, $CA, $3B, $06, $66, $5C, $0B, $01, $11,
  140.  
  141.     $FF, $9E, $65, $8F, $69, $AE, $62, $F8, $D3, $FF, $6B, $61, $45, $CF, $6C, $16,
  142.  
  143.     $78, $E2, $0A, $A0, $EE, $D2, $0D, $D7, $54, $83, $04, $4E, $C2, $B3, $03, $39,
  144.  
  145.     $61, $26, $67, $A7, $F7, $16, $60, $D0, $4D, $47, $69, $49, $DB, $77, $6E, $3E,
  146.  
  147.     $4A, $6A, $D1, $AE, $DC, $5A, $D6, $D9, $66, $0B, $DF, $40, $F0, $3B, $D8, $37,
  148.  
  149.     $53, $AE, $BC, $A9, $C5, $9E, $BB, $DE, $7F, $CF, $B2, $47, $E9, $FF, $B5, $30,
  150.  
  151.     $1C, $F2, $BD, $BD, $8A, $C2, $BA, $CA, $30, $93, $B3, $53, $A6, $A3, $B4, $24,
  152.  
  153.     $05, $36, $D0, $BA, $93, $06, $D7, $CD, $29, $57, $DE, $54, $BF, $67, $D9, $23,
  154.  
  155.     $2E, $7A, $66, $B3, $B8, $4A, $61, $C4, $02, $1B, $68, $5D, $94, $2B, $6F, $2A,
  156.  
  157.     $37, $BE, $0B, $B4, $A1, $8E, $0C, $C3, $1B, $DF, $05, $5A, $8D, $EF, $02, $2D);
  158.  
  159.  
  160.  
  161. Type u32 = array[1..4] of byte; { no 32-bit unsigned integers in TP7.1 :( }
  162.  
  163.  
  164.  
  165. var edx,esi,ebx,eax,ecx : u32;
  166.  
  167.     RegName,Licenses,CombinedRegName : String;
  168.  
  169.     i,j : word;
  170.  
  171.     dummy:byte;
  172.  
  173.     eeax,eecx:longint;
  174.  
  175.     flag:boolean;
  176.  
  177. const
  178.  
  179.  hex : array[0..$F] of Char = '0123456789ABCDEF';
  180.  
  181.  
  182.  
  183.  
  184.  
  185.  
  186.  
  187. function B( B : Byte) : String; assembler;
  188.  
  189. asm
  190.  
  191.  les di,@Result
  192.  
  193.  mov al,2
  194.  
  195.  stosb
  196.  
  197.  mov bl,B
  198.  
  199.  xor bh,bh
  200.  
  201.  mov dl,bl
  202.  
  203.  shr bl,1
  204.  
  205.  shr bl,1
  206.  
  207.  shr bl,1
  208.  
  209.  shr bl,1
  210.  
  211.  mov al,byte ptr hex[bx]
  212.  
  213.  mov bl,dl
  214.  
  215.  and bl,$F
  216.  
  217.  mov ah,byte ptr hex[bx]
  218.  
  219.  stosw
  220.  
  221. end;
  222.  
  223.  
  224.  
  225. Procedure Output;
  226.  
  227.  
  228.  
  229. Begin
  230.  
  231.   writeln('EAX=',B(eax[1]),B(eax[2]),B(eax[3]),B(eax[4]),'  ',
  232.  
  233.           'EBX=',B(ebx[1]),B(ebx[2]),B(ebx[3]),B(ebx[4]),'  ',
  234.  
  235.           'EdX=',B(edx[1]),B(edx[2]),B(edx[3]),B(edx[4]),'  ');
  236.  
  237. end;
  238.  
  239.  
  240.  
  241.  
  242.  
  243. Procedure Keymaker;
  244.  
  245.  
  246.  
  247. begin
  248.  
  249.    for i:=1 to 4 do edx[i]:=255;                  { mov edx,$ffffffff }
  250.  
  251.    for i:=1 to 4 do eax[i]:=255;                  { mov eax,$ffffffff }
  252.  
  253.  
  254.  
  255.  
  256.  
  257.    for i:=1 to 3 do esi[i]:=0;                    { mov esi,length(Combined..) }
  258.  
  259.    esi[4]:=length(CombinedRegName);
  260.  
  261.  
  262.  
  263.    for i:=1 to esi[4] do begin
  264.  
  265.      for j:=1 to 4 do edx[j]:=eax[j];             { mov edx,eax }
  266.  
  267.      for j:=1 to 4 do ebx[j]:=0;                  { xor ebx,ebx }
  268.  
  269.      for j:=1 to 3 do ebx[j]:=0;                  { mov bl,[ecx] }
  270.  
  271.      ebx[4]:=ord(CombinedRegName[i]);
  272.  
  273.      for j:=1 to 3 do edx[j]:=0;                  { and edx,$ff }
  274.  
  275.  
  276.  
  277.      for j:=1 to 4 do edx[j]:=edx[j] xor ebx[j];
  278.  
  279.  
  280.  
  281.      for j:=3 downto 1 do eax[j+1]:=eax[j];       { shr eax,8 }
  282.  
  283.      eax[1]:=0;
  284.  
  285.  
  286.  
  287.      dummy:=edx[4];
  288.  
  289.      for j:=1 to 4 do edx[j]:=Base[dummy*4+(4-j)];{ mov edx,[edx*4+c] }
  290.  
  291.      for j:=1 to 4 do eax[j]:=eax[j] xor edx[j];
  292.  
  293. {     output;}
  294.  
  295.    end;
  296.  
  297.    eecx:=LongADD(
  298.  
  299.          LongADD( LongMUL(eax[1],$1000000),LongMUL(eax[2],$10000) ),
  300.  
  301.          LongADD( LongMUL(eax[3],$100),LongMUL(eax[4],1) )
  302.  
  303.          );
  304.  
  305.    eeax:=$47961B7;
  306.  
  307.    eeax:=LongMUL(EEAX,(EECX));
  308.  
  309.    eecx:=$2c041e0;
  310.  
  311.    eeax:=LongMUL(eeax,$2c041e0);
  312.  
  313. end;
  314.  
  315.  
  316.  
  317.  
  318.  
  319. Procedure Curs(n:integer);
  320.  
  321.  
  322.  
  323. Var regs : registers;
  324.  
  325.  
  326.  
  327. Begin
  328.  
  329.   regs.ah:=1;
  330.  
  331.   case n of
  332.  
  333.   0 : begin
  334.  
  335.         regs.cl:=32;
  336.  
  337.         regs.ch:=32;
  338.  
  339.       end;
  340.  
  341.   1 : begin
  342.  
  343.         regs.cl:=8;
  344.  
  345.         regs.ch:=7;
  346.  
  347.       end;
  348.  
  349.   end;
  350.  
  351.   intr($10,regs);
  352.  
  353. End;
  354.  
  355.  
  356.  
  357. begin
  358.  
  359.   curs(0);
  360.  
  361.   FadeDown;
  362.  
  363.   Clrscr;
  364.  
  365.   textcolor(white);
  366.  
  367.   writeln('      T  ·  H  ·  E     F  ·  O  ·  R  ·  C  ·  E     T  ·  E  ·  A  ·  M');
  368.  
  369.   textcolor(blue);
  370.  
  371.   writeln('');
  372.  
  373.   writeln('         S²²²²²²²²²Ss.          .sS2²²²²²²²²²²²²²2Ss.sS²²²²²²²²²Ss. ');
  374.  
  375.   writeln('         $ $$$$$$$! $$         $²~.sS$$$$$$$$$$$Ss.~²$$ $$$$$$$! $$');
  376.  
  377.   writeln('         $ I$$$$$$$,²$         $ I$$$$$$$;^:$$$$$$$$ $$ $$$$$$$$,²$');
  378.  
  379.   writeln('      .sS$ $$$$$$$$: $Ss.      $ $$$$$$$$: l$$$$$$$$ $$ $$$$$$$$: $Ss.');
  380.  
  381.   writeln('      $ sss$$$$$$$$lsss $   .sS$ $$$$$$$$l :$$$$$$$I sss$$$$$$$$lsss $');
  382.  
  383.   writeln('      $sss $$$$$$$$; sss$   $ sss$$$$$$$$;sss ...... ss $$$$$$$$; sss$');
  384.  
  385.   writeln('         $ $$$$$$$$. ²²²²²²²²··s $$$$$$$$, sss$$$$$$$$$ I$$$$$$$. ²²²²²²²²²²S');
  386.  
  387.   writeln('         $ $$$$$$$$: .$$$$$$$! $ $$$$$$$$l $          $ $$$$$$$$: .$$$$$$$! $');
  388.  
  389.   writeln('         $ $$$$$$$$I :$$$$$$$$ $ $$$$$$$$. $          $ $$$$$$$$I :$$$$$$$$ $');
  390.  
  391.   writeln('         $ :$$$$$$$: :$$$$$$$; $ $$$$$$$$; $          $ :$$$$$$$: :$$$$$$$; $');
  392.  
  393.   writeln('         :$.`~²2$$$$s$$$$$2²~∩,$ !$$$$$$!  $          $$ `~²2$$$$s$$$$$2²~∩.;');
  394.  
  395.   writeln('         `~²2$Ss..........sS2²∩`²ssssssss2²∩          `~²2$Ss..........sS2²~∩');
  396.  
  397.   writeln;
  398.  
  399.   writeln;
  400.  
  401.   textcolor(white);
  402.  
  403.   writeln('               · Get Time Server v.2.1, Keymaker by MiRaMaX ·');
  404.  
  405.   textcolor(lightgray);
  406.  
  407.   writeln;
  408.  
  409.   writeln;
  410.  
  411.   gotoxy(1,19);
  412.  
  413.   write('             Enter Registration name   : ');
  414.  
  415.   fadeup;
  416.  
  417.   curs(1);
  418.  
  419.   readln(RegName);
  420.  
  421.   write('             Number of licenses        : ');
  422.  
  423.   curs(1);
  424.  
  425.   readln(Licenses);
  426.  
  427.   curs(0);
  428.  
  429.   flag:=true;
  430.  
  431.   for i:=1 to length(licenses) do if not((licenses[i]>='0')and(licenses[i]<='9')) then flag:=false;
  432.  
  433.   if flag then begin
  434.  
  435.     for i:=1 to length(RegName) do Regname[i]:=upcase(Regname[i]);
  436.  
  437.     CombinedRegName:=RegName+Licenses;
  438.  
  439.     keymaker;
  440.  
  441.     gotoxy(1,19);
  442.  
  443.     Writeln('             Registration name         : ',regname);
  444.  
  445.     Writeln('             Number of licenses        : ',licenses);
  446.  
  447.     Write('             Your registration code is : ');
  448.  
  449.     WriteULong ( eeax,10,' ',10);
  450.  
  451.   end else begin
  452.  
  453.     writeln;
  454.  
  455.     writeln('             You may only enter numbers... try again...');
  456.  
  457.   end;
  458.  
  459.   readkey;
  460.  
  461.   fadedown;
  462.  
  463.   clrscr;
  464.  
  465.   fadeup;
  466.  
  467. end.
  468.  
  469.