unit RplDecode;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, libeay32, StdCtrls, RC4, PrivateKey;

type

  TRPLRecord = record
    NPC:string;
    CCC:string;
    HWC:string;
    SIMLOCK:string;
    SIMLOCK_KEY:string;
    SUPERDONGLE_KEY:string;
    CMLA_KEY:string;
    WMDRM_PD:string;
  end;

  function DecodeRpl(filename: string; savefile: boolean = false): TRPLRecord;

  
implementation

function GetErrorMessage: string;
var
 ErrMsg: array [0..160] of char;
begin
 ERR_error_string(ERR_get_error, @ErrMsg);
 result := StrPas(@ErrMsg);
end;

procedure InitOpenSSL;
begin
 OpenSSL_add_all_algorithms;
 OpenSSL_add_all_ciphers;
 OpenSSL_add_all_digests;
 ERR_load_crypto_strings;
end;

procedure FreeOpenSSL;
begin
 EVP_cleanup;
end;




function ReadPrivateKey(AFileName: TFileName): pEVP_PKEY;
var
 keyfile: pBIO;
 x: pEVP_PKEY;

 function cb(buffer: PChar; blength: integer; verify: integer; data: pointer): integer; cdecl;
 begin
  result := 0;
 end;

begin
 keyfile := BIO_new(BIO_s_file());
 BIO_read_filename(keyfile, PChar(AFilename));
 x:=nil;
 result := PEM_read_bio_PrivateKey(keyfile, x, @cb, nil);
 if result = nil then
  raise Exception.Create('Unable to read private key. ' + GetErrorMessage);
 BIO_free(keyfile);
end;


procedure RSADecrypt(KeyFile, CleartextFile, CryptedFile: string; padding: integer);
var
 rsa: pRSA;
 keysize: integer;
 key: pEVP_PKEY;
 cleartext, crypted: pBIO;
 rsa_in, rsa_out: pointer;
 rsa_inlen, rsa_outlen: integer;
begin
 key := ReadPrivateKey(KeyFile);
 rsa := EVP_PKEY_get1_RSA(key);
 EVP_PKEY_free(key);
 if rsa = nil then
  raise Exception.Create('Error getting RSA key. ' + GetErrorMessage);
 cleartext := BIO_new_file(PChar(CleartextFile), 'rb');
 if cleartext = nil then
  raise Exception.Create('Error Reading Input File. ' + GetErrorMessage);
 crypted := BIO_new_file(PChar(CryptedFile), 'wb');
 if crypted = nil then
  raise Exception.Create('Error Reading Output File. ' + GetErrorMessage);
 keysize := RSA_size(rsa);
 rsa_in := OPENSSL_malloc(keysize);
 rsa_out := OPENSSL_malloc(keysize);
 rsa_inlen := BIO_read(cleartext, rsa_in, keysize * 2);
 if rsa_inlen <= 0 then
  raise Exception.Create('Error reading input Data.');
 rsa_outlen := RSA_Private_Decrypt(rsa_inlen, rsa_in, rsa_out, rsa, padding);
 if rsa_outlen <= 0 then
  raise Exception.Create('RSA operation error. ' + GetErrorMessage);
 BIO_write(crypted, rsa_out, rsa_outlen);
 RSA_free(rsa);
 BIO_free(cleartext);
 BIO_free_all(crypted);
 if rsa_in <> nil then OPENSSL_free(rsa_in);
 if rsa_out <> nil then OPENSSL_free(rsa_out);
end;






function str2hex(s: string; var buf: array of byte): integer;
var
 i: integer;
begin
 result:=0;
 for i:=1 to length(s) div 2 do begin
  buf[i-1]:= strtoint('$'+copy(s,i*2-1,2));
  inc(result);
 end;
end;



function decodeRC4(source: TFileStream; var dest: TFileStream; enckey: string): boolean;
const
 BLOCKSIZE: Integer = 1024;
var
 RC4: TRC4Context;
 Len: Int64;
 SourceBuffer, DestBuffer: Pointer;
begin
 try
  GetMem(SourceBuffer, BLOCKSIZE);
  GetMem(DestBuffer, BLOCKSIZE);
  try
   RC4Init(RC4, enckey);
   while source.Position < source.Size do begin
    if source.Size - source.Position > BLOCKSIZE then Len := BLOCKSIZE
     else Len := source.Size - source.Position;
    source.ReadBuffer(SourceBuffer^, Len);
    RC4Code(RC4, SourceBuffer^, DestBuffer^, len);
    dest.WriteBuffer(DestBuffer^, Len);
   end;
   RC4Done(RC4);
   result:=true;
  finally
   FreeMemory(SourceBuffer);
   FreeMemory(DestBuffer);
  end;
 finally
 end;
end;



procedure RPLRClear(var source: TRplRecord);
begin
     source.NPC:='';
     source.CCC:='';
     source.HWC:='';
     source.SIMLOCK:='';
     source.SIMLOCK_KEY:='';
     source.SUPERDONGLE_KEY:='';
     source.CMLA_KEY:='';
     source.WMDRM_PD:='';
end;


function PlainRplPar(RS: TStrings): TRPLRecord;
var
 i:integer;
 sn,sv:string;
 RPLRecord: TRplRecord;
begin
 RPLRClear(RplRecord);
 for i:=0 to RS.Count-1 do begin
  sn:='';
  sv:='';
  if ((Pos('DATA',RS.Strings[i])<> 0) and (Pos('=',RS.Strings[i])<> 0)) then begin
   RS.NameValueSeparator:='=';
   sn:=RS.Names[i];
   sv:=RS.ValueFromIndex[i];
   if Pos ('NPC',sn)<>0 then RPLRecord.NPC:=RPLRecord.NPC+sv;
   if Pos ('CCC',sn)<>0  then RPLRecord.CCC:=RPLRecord.CCC+sv;
   if Pos ('HWC',sn)<>0  then RPLRecord.HWC:=RPLRecord.HWC+sv;
   if Pos ('SIMLOCK_DATA',sn)<>0  then RPLRecord.SIMLOCK:=RPLRecord.SIMLOCK+sv;
   if Pos ('SIMLOCK_KEY',sn)<>0 then RPLRecord.SIMLOCK_KEY:=RPLRecord.SIMLOCK_KEY+sv;
   if Pos ('SUPERDONGLE_KEY',sn)<>0  then RPLRecord.SUPERDONGLE_KEY:=RPLRecord.SUPERDONGLE_KEY+sv;
   if Pos ('CMLA_KEY',sn)<>0  then RPLRecord.CMLA_KEY:=RPLRecord.CMLA_KEY+sv;
   if Pos ('WMDRM_PD',sn)<>0  then RPLRecord.WMDRM_PD:=RPLRecord.WMDRM_PD+sv;
  end;
 end;
 result:=RplRecord;
end;


procedure CreatePrivateKey(key: string);
var
 keyfile: THandle;
 count: Cardinal;
begin
 keyfile:= CreateFile(PChar(key), GENERIC_READ or GENERIC_WRITE, 0, nil, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
 WriteFile(keyfile,datakey,1704,count,nil);
 CloseHandle(keyfile);
end;


function DecodeRPL(filename: string; savefile: boolean = false): TRPLRecord;
var
 stream, temp_stream, stream_rpl: TMemoryStream;
 buff, buff_temp: array of byte;
 tempvalue: byte;
 temp1,temp2: char;
 i, size: integer;
 programdir, tempfilename, enckey: string;
 source, dest: TFileStream;
 recordrpl: TStrings;
begin
 GetDir(0,programdir);
 InitOpenSSL;
 stream:=TMemoryStream.Create;
 stream_rpl:=TMemoryStream.Create;
 temp_stream:=TMemoryStream.Create;

 stream.LoadFromFile(filename);
 stream.Seek($E,soFromBeginning);
 setlength(buff,512);
 enckey:='';
 for i:=0 to 511 do begin
  stream.Read(buff[i],1);
  if buff[i]=$0D then stream.Read(buff[i],1);
  if buff[i]=$0A then stream.Read(buff[i],1);
  enckey:=enckey+chr(buff[i]);
 end;
 setlength(buff_temp,256);
 size:=str2hex(enckey,buff_temp);

 if size=256 then begin
  initopenssl;
  for i:=0 to high(buff_temp) do temp_stream.WriteBuffer(buff_temp[i], 1);
  temp_stream.SaveToFile('temp1.rpl');
  tempfilename:=ExtractFilePath(Application.ExeName)+'flash\ADLREVFFF.adl';
  //tempfilename:='ADLREVFFF.adl';
  CreatePrivateKey(tempfilename);
  rsadecrypt(tempfilename,'temp1.rpl','temp2.rpl',RSA_PKCS1_OAEP_PADDING);
  freeopenssl;
  deletefile(PChar(tempfilename));
  deletefile('temp1.rpl');
  temp_stream.Clear;

  temp_stream.LoadFromFile('temp2.rpl');
  buff:=nil;
  setlength(buff,temp_stream.size);
  enckey:='';
  for i:=0 to temp_stream.size-1 do begin
   temp_stream.Read(buff[i],1);
   enckey:=enckey+chr(buff[i]);
  end;
  deletefile('temp2.rpl');

  temp_stream.Clear;
  size:=stream.Size-stream.Position;
  for i:=1 to size do begin
   stream.Read(tempvalue,1);
   if (tempvalue<>$0D)and(tempvalue<>$0A) then begin
    stream.Seek(-1,soFromCurrent);
    temp_stream.CopyFrom(stream,1);
   end;
  end;
  temp_stream.Seek(0,soFromBeginning);
  buff_temp:=nil;
  stream_rpl.Clear;
  setlength(buff_temp,temp_stream.size div 2);
  for i:=1 to temp_stream.Size div 2 do begin
   temp_stream.Read(temp1,1);
   temp_stream.Read(temp2,1);
   tempvalue:= strtoint('$'+temp1+temp2);
   stream_rpl.WriteBuffer(tempvalue,1);
  end;
  stream_rpl.SaveToFile('prepare.rpl');

  source:=TFileStream.Create('prepare.rpl',fmOpenRead);
  tempfilename:=copy(FileName,1,length(FileName)-4)+'_plain.rpl';
  dest:=TFileStream.Create(tempfilename,fmCreate);
  decodeRC4(source,dest,enckey);
  source.Free;
  dest.Free;
  deletefile('prepare.rpl');

  recordrpl:= TStringList.Create;
  recordrpl.LoadFromFile(tempfilename);
  result:=PlainRplPar(recordrpl);
  //showmessage(copy(result.NPC,1,10));
  if not savefile then deletefile(tempfilename);
 end;
end;





end.