Cracker

   
Zanim zacznę ten kurs muszę zaznaczyć, że jest on przeznaczony tylko do celów edukacyjnych i wykorzystywanie go w innym celu jest sprzeczne z prawem.
Rozczaruję jednak tych, którzy sądzą że pokażę jak można ingerować w kod źródłowy programów tak żeby ominąć zabezpieczenia wprowadzone przez autora programu. Istnieje jednak pewna grupa programów typu shareware (w wersjach komercyjnych raczej się to nie sprawdzi) np. Microangelo 5.56, które są udostępniane do użytku z ograniczeniem czasowym, tzn. program działa przez np. 21 dni po czym następuje blokada, ale cofnięcie daty umożliwia dalsze korzystanie z programu. Ręczne cofanie daty przed każdym uruchomieniem programu i przywracanie jej byłoby bardzo niewygodne, dlatego napiszemy program który zautomatyzuje całą operację.

Co powinien robić taki program?

  1. Powinien w chwili uruchomienia odczytać aktualną datę.
  2. Powinien pobrać np. z pliku informację o dacie zainstalowania programu, który chcemy uruchomić.
  3. Powinien pobrać np. z pliku informację o lokalizacji programu, który chcemy uruchomić.
  4. Powinien zmienić aktualną datę na datę zainstalowania programu (patrz punkt 2).
  5. Powinien uruchomić właściwy program (patrz punkt 3).
  6. Powinien odczekać aż program się uruchomi i następnie przywrócić aktualną datę (patrz punkt 1).
  7. Powinien się zamknąć.

Krok 1. - tworzymy nowy projekt.

    Tworzymy nowy projekt i zapisujemy go pod nazwą Cracker (nazwa jest dowolna). Następnie umieszczamy na formularzu Form1 trzy przyciski Button1, Button2 i Button3, dwie etykiety Label1 i Label2, a następnie ustawiamy ich właściwości tak:


Krok 2. - odczytywanie aktualnej daty (patrz punkt 1).

    Po umieszczeniu wszystkich potrzebnych komponentów na formularzu przechodzimy do pliku źródłowego Unit1.cpp i w sekcji include importujemy plik dos.h:

// Plik źródłowy Unit1.cpp
//--------------------------------
#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
#include <dos.h>

//--------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"

TForm1 *Form1;
//--------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//--------------------------------

Następnie przechodzimy do pliku nagłówkowego Unit1.h i w sekcji private definiujemy trzy zmienne typu int, które posłużą nam do przechowywania informacji o aktualnej dacie:

// Plik nagłówkowy Unit1.h
//--------------------------------
private:
        int day, month, year;

//--------------------------------

Powracamy do pliku źródłowego i w zdarzeniu OnShow dla formularza Form1 definiujemy klasę TDateTime, która pobierze informację o aktualnej dacie i przepisze ją do zmiennych day, mont i year:

// Plik źródłowy Unit1.cpp
//--------------------------------
void __fastcall TForm1::FormShow(TObject *Sender)
{
 ShowWindow(Application->Handle, SW_HIDE);

 TDateTime Now = TDateTime::CurrentDate();
 day   = (Now.FormatString("dd")).ToInt();
 month = (Now.FormatString("mm")).ToInt();
 year  = (Now.FormatString("yyyy")).ToInt();
}
//--------------------------------

Opis zastosowanej tutaj funkcji znajduje się w dziale porady - formatowanie tekstu i liczb.
I w ten oto sposób nasz program odczytał i zapamiętał informację o aktualnej dacie.

Krok 3. - pobranie informacji o dacie zainstalowania programu (patrz punkt 2).

    Żeby pobrać informację z pliku, trzeba najpierw ten plik utworzyć, moglibyśmy to zrobić ręcznie przy pomocy np. notatnika, ale znacznie lepszym rozwiązaniem będzie umieszczenie w naszym programie edytora, który ustawi parametry pracy Crackera.
W tym celu z menu File wybieramy New Form i zapisujemy nowo utworzoną jednostkę pod nazwą Unit2. Następnie umieszczamy na formularzu Form2 trzy przyciski Button1, Button2 i Button3, pięć etykiet Label1, Label2, Label3, Label4 i Label5, cztery komponenty CSpinEdit1, CSpinEdit2, CSpinEdit3 i CSpinEdit4  (te komponenty znajdują się na palecie Samples) oraz jeden komponent OpenDialog1, po czym ustawiamy ich właściwości:

Teraz przechodzimy do pliku nagłówkowego Unit2.h i w sekcji include importujemy plik inifiles.hpp:

// Plik nagłówkowy Unit2.h
//--------------------------------
#ifndef Unit2H
#define Unit2H

//--------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
#include "CSPIN.h"
#include <Dialogs.hpp>
#include <inifiles.hpp>
//--------------------------------

Następnie w sekcji public deklarujemy dwie funkcje Start i SavePar (nazwy są dowolne) oraz cztery zmienne typu int:

// Plik nagłówkowy Unit2.h
//--------------------------------
public:
        void __fastcall Start(AnsiString FileName);
       
void __fastcall SavePar(AnsiString FileName);
    
   int OldDay, OldMonth, OldYear, sleep;

//--------------------------------

Funkcja Start będzie próbowała pobrać z pliku parametry, natomiast funkcja SavePar będzie zapisywała zadane parametry do pliku.
    Przechodzimy do pliku źródłowego Unit2.cpp i definiujemy zadeklarowane funkcje umieszczając od razu instrukcje potrzebne do ich prawidłowego działania:

// Plik źródłowy Unit2.cpp
//--------------------------------
void __fastcall TForm2::Start(AnsiString FileName)
{
 TIniFile *Ini = new TIniFile(FileName);

 String A = Ini->ReadString("CRACK", "PROGRAM", "");
 Label1->Caption = A;
 OpenDialog1->FileName = A;

 CSpinEdit1->Value = Ini->ReadInteger("CRACK", "SLEEP", 100);
 sleep = CSpinEdit1->Value;
 OldDay   = Ini->ReadInteger("CRACK", "DAY", 1);
 OldMonth = Ini->ReadInteger("CRACK", "MONTH", 1);
 OldYear  = Ini->ReadInteger("CRACK", "YEAR", 2003);

 CSpinEdit2->Value = OldDay;
 CSpinEdit3->Value = OldMonth;
 CSpinEdit4->Value = OldYear;

 Ini->Free();
}
//---------------------------------
void __fastcall TForm2::SavePar(AnsiString FileName)
{
 TIniFile *Ini = new TIniFile(FileName);

 Ini->WriteString("CRACK", "PROGRAM", OpenDialog1->FileName);
 Ini->WriteInteger("CRACK", "SLEEP", CSpinEdit1->Value);
 Ini->WriteInteger("CRACK", "DAY", CSpinEdit2->Value);
 Ini->WriteInteger("CRACK", "MONTH", CSpinEdit3->Value);
 Ini->WriteInteger("CRACK", "YEAR", CSpinEdit4->Value);

 sleep = CSpinEdit1->Value;

 Ini->Free();
}
//--------------------------------

Zanim zacznę wyjaśniać co do czego służy, podłączymy funkcje do odpowiednich zdarzeń i tak zaczynając od przycisku Button1 w zdarzeniu OnClick wywołujemy okienko dialogowe do wyszukiwania plików, w naszym przypadku programów, tzn. po wciśnięciu przycisku Button1 zostanie wywołane okienko OpenDialog1 w którym wskażemy program, który chcemy uruchomić za pomocą naszego Cracker'a:

// Plik źródłowy Unit2.cpp
//--------------------------------
void __fastcall TForm2::Button1Click(TObject *Sender)
{
 if(OpenDialog1->Execute())
    Label1->Caption = OpenDialog1->FileName;
}
//--------------------------------

W zdarzeniu OnClick dla przycisku Button2 wywołujemy funkcję SavePar i tutaj nastąpi po prostu zapisanie do pliku Crack.ini (nazwa pliku jest dowolna) parametrów pracy Cracker'a:

// Plik źródłowy Unit2.cpp
//--------------------------------
void __fastcall TForm2::Button2Click(TObject *Sender)
{
 SavePar(ExtractFileDir(Application->ExeName) + "\\Crack.ini");
}
//--------------------------------

W zdarzeniu OnClick przycisku Button3 umieszczamy instrukcję zamykającą okno opcji bez zapisywania zmian:

// Plik źródłowy Unit2.cpp
//--------------------------------
void __fastcall TForm2::Button3Click(TObject *Sender)
{
 Close();
}
//--------------------------------

Teraz gwoli wyjaśnienia:

Krok 4. - wykańczanie programu.

Powracamy do pliku źródłowego Unit1.cpp i w zdarzeniu OnClick przycisku Button2 umieszczamy kod wywołujący okno opcji - Form2:

// Plik źródłowy Unit1.cpp
//--------------------------------
void __fastcall TForm1::Button2Click(TObject *Sender)
{
 Form2->ShowModal();
}
//--------------------------------

W sekcji include pliku źródłowego Unit1.cpp dołączmy plik Unit2.h:

// Plik źródłowy Unit1.cpp
//--------------------------------
#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
#include "Unit2.h"
#include <dos.h>

//--------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"

TForm1 *Form1;
//--------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//--------------------------------

W zdarzeniu OnPaint dla formularza Form1 uruchamiamy funkcję Start z formularza Form2:

// Plik źródłowy Unit1.cpp
//--------------------------------
void __fastcall TForm1::FormPaint(TObject *Sender)
{
 Form2->Start(ExtractFileDir(Application->ExeName) + "\\Crack.ini");
 Label2->Caption = ExtractFileName(Form2->OpenDialog1->FileName);
}
//--------------------------------

Przechodzimy do pliku nagłówkowego Unit1.h i w sekcji private deklarujemy trzy funkcje:  ChangeDate, RestoreDate i RunCracker (nazwy dowolne), a następnie definiujemy je w pliku źródłowym Unit1.cpp:

// Plik nagłówkowy Unit1.h
//--------------------------------
private:
        void __fastcall ChangeDate(void);
      
 void __fastcall RestoreDate(void);
        void __fastcall RunCracker(AnsiString FileName);


        int day, month, year;

//--------------------------------

 

// Plik źródłowy Unit1.cpp
//--------------------------------
void __fastcall TForm1::ChangeDate(void)
{
 struct date d;
 d.da_day = (char)Form2->OldDay;
 d.da_mon = (char)Form2->OldMonth;
 d.da_year = Form2->OldYear;
 setdate(&d);
}
//---------------------------------

void __fastcall TForm1::RestoreDate(void)
{
 struct date d;
 d.da_day = (char)day;
 d.da_mon = (char)month;
 d.da_year = year;
 setdate(&d);
}
//--------------------------------
void __fastcall TForm1::RunCracker(AnsiString FileName)
{
 ChangeDate();
 Sleep(100);
 WinExec(FileName.c_str(), SW_SHOW);
 Sleep(Form2->sleep);
 RestoreDate();
 Application->Terminate();
}
//--------------------------------

Następnie w zdarzeniu OnClick dla przycisku Button1 wywołujemy funkcję RunCracker, która to zmieni aktualną datę na datę w której nastąpiła instalacja uruchamianego programu, następnie uruchomi tenże program (pod warunkiem, że odpowiednio wcześniej zaprogramowaliśmy Cracker'a w opcjach), potem przywróci aktualną datę i zamknie Cracker'a:

// Plik źródłowy Unit1.cpp
//--------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
 RunCracker(Form2->OpenDialog1->FileName);
}
//--------------------------------

W zdarzeniu OnClick dla przycisku Button3 umieszczamy kod zamykający Crackera bez wykonania żadnego działania:

// Plik źródłowy Unit1.cpp
//--------------------------------
void __fastcall TForm1::Button3Click(TObject *Sender)
{
 Application->Terminate();
}
//--------------------------------

I to jest już w zasadzie wszystko, jak już zapewne zauważyliście niewiele to ma wspólnego z crack'owaniem, ale ja się po prostu na tym nie znam więc wymyśliłem ten program, żeby Wam uzmysłowić jak można z kilku prostych funkcji i metod złożyć prosty program, który będzie coś robił.
 
 Pytania proszę kierować na skrzynkę pocztową cyfrowy.baron@wp.pl. Nie biorę żadnej odpowiedzialności za błędy i szkody jakie może spowodować korzystanie z kursu, plików i programów w nim zamieszczonych


Przygotował: Cyfrowy Baron.

    ...pliki żródłowe (BCB4)