Newsgroup: it.comp.lang.delphi
Titolo: Protezione Applicativo Delphi

Sono in un mare di interrogativi.
Come proteggere un programma in modo che non sia copiabile.
Esiste qualche applicativo Delphi a rigurado ?
La chiave hardware è un problema spedizioni etc, il codice processore
funziona bene ? E' clonabile ?
Ciao

 
spero che questo ti dia delle risposte:
Tmxprotector
http://www.maxcomponents.net/index.php?id=1&page=1#TmxProtector
Mario

 Esiste qualche applicativo Delphi a rigurado ?
Esiste tmxprotector, oppure turbopower onguard: cerca in questo stesso NG
con google.
Ciao
-- 
Morde

Pensavo in definitiva di usare il codice del HD.
qualcuno ha qualche idea su
Win32_PhysicalMedia Class come recuperarlo....
Grazie mille

Ragazzi non so come ringraziarvi siete veramente gentili.
Credo che l'unica protezione possibile nel mio caso sia basata
sull'hardware.
Adesso mi studio i componenti.
Ciao

Io uso da tempo e senza problemi execryptor, costo ragionevole e molte
possibilità di scelta delle modalità di protezione.
ciao
Marco
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 possibilità di scelta delle modalità di protezione.
L'ho visto, in effetti supporta la protezione su ID hardware che è
quella più interessante per la mia applicazione.
Vorrei fare due domande, sviluppando personalmente la protezione:
Come faccio in ad eliminare le info di debug dall'applicazione ?
Pensate che la protezione sull'id hardware del Harddisk sia sicura ?
Posto procedure di lettura del suddetto trovate in rete che sembrano
funzionare benone.
unit uMain;
interface
uses
 Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls,
Forms,
 Dialogs, StdCtrls;
const
 IDENTIFY_BUFFER_SIZE   = 512;
 // SMART IOCTL commands
 DFP_GET_VERSION        = $00074080;
 DFP_SEND_DRIVE_COMMAND = $0007c084;
 DFP_RECEIVE_DRIVE_DATA = $0007c088;
 IDE_ID_FUNCTION        = $EC;
type
 USHORT = Word;
 TIdSector = packed record
   wGenConfig                : USHORT;
   wNumCyls                  : USHORT;
   wReserved                 : USHORT;
   wNumHeads                 : USHORT;
   wBytesPerTrack            : USHORT;
   wBytesPerSector           : USHORT;
   wSectorsPerTrack          : USHORT;
   wVendorUnique             : array[0..2] of USHORT;
   sSerialNumber             : array[0..19] of Char;
   wBufferType               : USHORT;
   wBufferSize               : USHORT;
   wECCSize                  : USHORT;
   sFirmwareRev              : array[0..7] of Char;
   sModelNumber              : array[0..39] of Char;
   wMoreVendorUnique         : USHORT;
   wDoubleWordIO             : USHORT;
   wCapabilities             : USHORT;
   wReserved1                : USHORT;
   wPIOTiming                : USHORT;
   wDMATiming                : USHORT;
   wBS                       : USHORT;
   wNumCurrentCyls           : USHORT;
   wNumCurrentHeads          : USHORT;
   wNumCurrentSectorsPerTrack: USHORT;
   ulCurrentSectorCapacity   : ULONG;
   wMultSectorStuff          : USHORT;
   ulTotalAddressableSectors : ULONG;
   wSingleWordDMA            : USHORT;
   wMultiWordDMA             : USHORT;
   bReserved                 : array[0..127] of Byte;
 end;
 TIDERegs = packed record
   bFeaturesReg    : Byte;
   bSectorCountReg : Byte;
   bSectorNumberReg: Byte;
   bCylLowReg      : Byte;
   bCylHighReg     : Byte;
   bDriveHeadReg   : Byte;
   bCommandReg     : Byte;
   bReserved       : Byte;
 end;
 TSendCmdInParams = packed record
   cBufferSize  : DWord;
   irDriveRegs  : TIDERegs;
   bDriveNumber : Byte;
   bReserved    : array[0..2] of Byte;
   dwReserved   : array[0..3] of DWord;
   bBuffer      : array[0..0] of Byte;
 end;
 TDriverStatus = packed record
   bDriverError: Byte;
   bIDEStatus  : Byte;
   bReserved   : array[0..1] of Byte;
   dwReserved  : array[0..1] of DWord;
 end;
 TSendCmdOutParams = packed record
   cBufferSize : DWord;
   DriverStatus: TDriverStatus;
   bBuffer     : array[0..0] of Byte;
 end;
type
 TfMain = class(TForm)
   btnEnum: TButton;
   lbDrives: TListBox;
   procedure btnEnumClick(Sender: TObject);
   procedure FormCreate(Sender: TObject);
 private
 public
 end;
var
 fMain    : TfMain;
 tagOSInfo: TOSVersionInfo;
implementation
{$R *.dfm}
function GetPhysicalDriveHandle( bDriveNum: Byte; dwDesiredAccess:
ACCESS_MASK ): THandle;
begin
 if( tagOSInfo.dwPlatformId=VER_PLATFORM_WIN32_NT ) then begin
   // Windows NT, Windows 2000
   Result:=CreateFile
   (
     PChar(Format('\\.\PhysicalDrive%d', [bDriveNum])),
     dwDesiredAccess,
     FILE_SHARE_READ or FILE_SHARE_WRITE,
     nil,
     OPEN_EXISTING,
     0,
     0
   );
 end else begin
   // Windows 95 OSR2, Windows 98
   Result:=CreateFile( '\\.\SMARTVSD', 0, 0, nil, CREATE_NEW, 0, 0 );
 end;
end;
function SmartIdentifyDirect( hDevice: THandle; bDriveNum, bIDCmd:
Byte; var IdSector: TIdSector; var IdSectorSize: Longint ): Boolean;
const nBufferSz = SizeOf(TSendCmdOutParams)+IDENTIFY_BUFFER_SIZE-1;
var
 SCIP      : TSendCmdInParams;
 abBuffer  : array [0..nBufferSz-1] of Byte;
 SCOP      : TSendCmdOutParams absolute abBuffer;
 dwBytesRet: DWord;
begin
 ZeroMemory( @SCIP, SizeOf(TSendCmdInParams) );
 ZeroMemory( @abBuffer, nBufferSz );
 dwBytesRet  :=0;
 IdSectorSize:=0;
 with SCIP do begin
   cBufferSize :=IDENTIFY_BUFFER_SIZE;
   bDriveNumber:=bDriveNum;
   with irDriveRegs do begin
     bFeaturesReg    :=0;
     bSectorCountReg :=1;
     bSectorNumberReg:=1;
     bCylLowReg      :=0;
     bCylHighReg     :=0;
     bDriveHeadReg   :=$A0 or ((bDriveNum and 1) shl 4);
     bCommandReg     :=bIDCmd;
   end;
 end;
 Result:=DeviceIoControl( hDevice, DFP_RECEIVE_DRIVE_DATA, @SCIP,
SizeOf(TSendCmdInParams)-1, @SCOP, nBufferSz, dwBytesRet, nil );
 if( Result ) then begin
   IdSectorSize:=dwBytesRet-SizeOf(TSendCmdOutParams)+1;
   if( IdSectorSize<0 ) then
     IdSectorSize:=0
   else System.Move( SCOP.bBuffer, IdSector, IdSectorSize );
 end;
end;
procedure ChangeByteOrder( var Data; Size: Longint );
var
 lpTmp: PChar;
 ii   : Longint;
 cTmp : Char;
begin
 lpTmp:=@Data;
 for ii:=0 to (Size shr 1)-1 do begin
   cTmp:=lpTmp^;
   lpTmp^:=(lpTmp+1)^;
   (lpTmp+1)^:=cTmp;
   Inc(lpTmp,2);
 end;
end;
function PrintIdSectorInfo( IdSector : TIdSector ): string;
var acOutBuffer: array [0..40] of Char;
begin
 with IdSector do begin
   ChangeByteOrder( sModelNumber, SizeOf(sModelNumber) );
   acOutBuffer[SizeOf(sModelNumber)] := #0;
   Result:='Model: '+Trim(sModelNumber);
   ChangeByteOrder( sFirmwareRev, SizeOf(sFirmwareRev) );
   acOutBuffer[SizeOf(sFirmwareRev)] := #0;
   Result:=Result+', Firmware: '+Trim(sFirmwareRev);
   ChangeByteOrder( sSerialNumber, SizeOf(sSerialNumber) );
   acOutBuffer[SizeOf(sSerialNumber)] := #0;
   Result:=Result+', Serial: '+Trim(sSerialNumber);
 end;
end;
procedure TfMain.btnEnumClick(Sender: TObject);
var
 ii         : Longint;
 hDevice    : THandle;
 nIdSectorSz: LongInt;
 aIdBuffer  : array [0..IDENTIFY_BUFFER_SIZE-1] of Byte;
 IdSector   : TIdSector absolute aIdBuffer;
begin
 for ii:=0 to 10 do begin
   ZeroMemory( @aIdBuffer, SizeOf(aIdBuffer) );
   hDevice:=GetPhysicalDriveHandle( ii, GENERIC_READ or
GENERIC_WRITE );
   if( hDevice=INVALID_HANDLE_VALUE ) then
     Break
   else begin
     try
       if( SmartIdentifyDirect( hDevice, 0, IDE_ID_FUNCTION, IdSector,
nIdSectorSz ) ) then begin
         lbDrives.Items.Add( inttostr(ii)
+'-'+PrintIdSectorInfo( IdSector ) );
       end;
     finally
       CloseHandle(hDevice);
     end;
   end;
 end;
end;
procedure TfMain.FormCreate(Sender: TObject);
begin
 tagOSInfo.dwOSVersionInfoSize:=SizeOf(TOSVersionInfo);
 GetVersionEx(tagOSInfo);
end;
end.
Unica cosa non so come determinare l'handle del harddisk sul quale si
trova l'applicazione, dalla lettera credo non sia possibile.
Ciao Ambro

 trova l'applicazione, dalla lettera credo non sia possibile.
Qui dentro si è parlato numerose volte di protezione, se cerchi troverai
molto materiale... vedi, da quello che scrivi e dal come lo scrivi sembra
che non hai un approccio professionale e sembra che vai "per tentativi":
utilizzare codice trovato in rete..che "sembra funzionare" (uso parole tue)
che garanzie ti dà?
Ad esempio ti avevo consigliato due prodotti (free) che ho usato con
successo in programmi poi venduti a clienti dell'azienda in cui operavo.
E' inutile che scandagli la rete con google e collezioni informazioni e
codice, se prima non ti fai un'idea precisa e funzionale di quello che vuoi
ottenere: sia tmxprotector che onguard si possono appoggiare all'hardware
della macchina per la protezione. OnGuard è un pò più tosto di mxprotector,
ma il motivo c'è: è un ottimo prodotto, costava parecchio ed è stato
venduto molto da turbopower prima che decidessero di donarlo alla comunità
open source.
Ti sei studiato il manuale di onguard? oppure l'help di mxprotector? 
Se vuoi un'opinione sui pezzi di codice che hai postato, beh la mia è
questa: nessuna opinione. Io mi appoggerei ai prodotti che ho utilizzato
già in passato e che non mi hanno mai tradito (ancora dopo due anni dal
primo rilascio, grazie a tmxprotector avevamo scoperto dei tentativi di
copia del software..)
Insomma, alla fine la mia osservazione che mi permetto di farti è : perchè
cerchi di reinventarti l'acqua calda?
:-)
-- 
Morde

 Ti sei studiato il manuale di onguard? oppure l'help di mxprotector?
Grazie, avevo scartato queste soluzioni perchè leggendo molto
velocemente il manuale non mi era sembrato che si appoggiassero
sull'hardware. Invece come giustamente dici lo fanno.
Posso chiederti una cosa vista la mole dei manuali ?
Vorrei chiederti se utilizzando queste protezioni compaiono scritte
tipo "on guard protection" etc. ?
Infine se vi sono delle limitazioni sulla licenza che riguarda il
numero delle vendite.
Chiedo scusa per la mia scarsa professionalità su delphi, e in ogni
caso grazie. Ambro

 caso grazie. Ambro
Non c'e' alcuna scusa da fare: il mio era solo un appunto sul modo di porre
le domande, che lasciava intravedere un approccio non proprio ortodosso al
problema... almeno, dal mio punto di vista, imho...
Quanto alle altre domande, la risposta è positiva: non ci sono limiti di
licenze rilasciate ne' compaiono scritte indesiderate.
Metti un lock sull'hardware ID e poi divertiti ad impostare eventualmente
licenze a scadenza temporale, di utilizzi in rete, ecc.... insomma: buon
divertimento e buono studio.
;)
Ciao
-- 
Morde