Articoli,howto,guide di programmazione & Informatica generale.

Questo breve tutorial ha lo scopo di spiegarvi brevemente l'uso delle Gtk per creare semplici crackme, ovvero quei software che di solito vengono realizzati per esercitarsi nel reverse engineering di software che richiedono il codice seriale per l'utilizzo; i requisiti per questo tutorial sono una discreta conoscenza del linguaggio C.

Iniziamo! :D

1) Prima di tutto, dobbiamo inserire nel nostro codice gli header file da importare per il nostro scopo:

#include <string.h> /* Verra' utilizzata la funzione strcpy per copiare una stringa */

#include <gtk/gtk.h> /* Necessario per tutte le funzioni delle gtk */

Potra' essere necessario importare altri header, a seconda del metodo con cui volete verificare il seriale inserito (vedremo in seguito).

#define MAX_CHARS 20 /* Questa costante indica la dimensione del serial */

2) Iniziamo ora a scrivere il main:

int main(int argc,char *argv[])

{

Per contenere tutti i widgets gtk (tasti,box,finestre,etc) esiste il tipo GtkWidget, che non e' altro che un puntatore al widget. Le box non sono altro che dei widget che possono contenere altri widget, sono usati per mettere l'ordine dei widgets. Il widget main puo' contenere solo 1 altro widget, quindi sara' necessario creare una box che contenga tutte le altre. Le funzioni gtk sono molto intuitive gia' dal nome, quindi non credo sara' necessaria 1 lunga spiegazione.

GtkWidget *window; /* Finestra principale del programma */

GtkWidget *box_main; /* Box che contiene tutti i widget */

GtkWidget *box_serial; /* Box che contiene tutto cio' che riguarda il serial */

GtkWidget *box_button; /* Box che contiene i tasti */

GtkWidget *label_serial; /* Label */

GtkWidget *entry_serial; /* Entry per l'inserimento del seriale */

GtkWidget *button_check; /* Tasto per controllare il seriale */

GtkWidget *button_exit; /* Tasto di uscita */

Inizializziamo le gtk:

gtk_init(&argc, &argv);

Mettiamo nel widget window, una nuova finestra, con un titolo, ed al centro:

window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

gtk_window_set_title(GTK_WINDOW(window),"CrackMe!");

gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_CENTER);

Riempiamo le box:

box_main = gtk_vbox_new(FALSE,0); /* box_main sara' una box verticale */

box_serial = gtk_hbox_new(FALSE,0); /* le altre sono orizzontali, per contenere */

box_button = gtk_hbox_new(FALSE,0); /* i widget del seriale e dei tasti */

Creiamo una label ed un entry che potra' contenere 20 caratteri:

label_serial = gtk_label_new("Serial: ");

entry_serial = gtk_entry_new_with_max_length(MAX_CHARS);

Creiamo i tasti di check e di uscita:

button_check = gtk_button_new_with_label("Check");

button_exit = gtk_button_new_with_label("Exit");

Ora e' arrivato il momento di aggiungere i widget nelle rispettive box, e cio' si fa con la funzione gtk_container_add, dove viene indicata la box contenitore ed il Widget da inserire.

gtk_container_add(GTK_CONTAINER(box_serial),label_serial);

gtk_container_add(GTK_CONTAINER(box_serial),entry_serial);

gtk_container_add(GTK_CONTAINER(box_button),button_check);

gtk_container_add(GTK_CONTAINER(box_button),button_exit);

gtk_container_add(GTK_CONTAINER(box_main),box_serial);

gtk_container_add(GTK_CONTAINER(box_main),box_button);

Mettiamo il box_main dentro la finestra principale:

gtk_container_add(GTK_CONTAINER(window),box_main);

Ora e' arrivato il momento di gestire gli eventi, con la funzione g_signal_connect. Se viene premuto il tasto exit, o la x in alto a destra, viene richiamata la funzione quit, altrimenti se viene premuto il tasto check, viene chiamata la funzione check, e viene passato come argomento il widget entry_serial, necessario per prelevare il seriale:

g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK (quit), NULL);

g_signal_connect(G_OBJECT(button_exit), "clicked", G_CALLBACK (quit), NULL);

g_signal_connect(G_OBJECT(button_check), "clicked", G_CALLBACK (check), entry_serial);

Visualizziamo tutti i widget della window:

gtk_widget_show_all(window);

E lanciamo le gtk :D

gtk_main();

return 0;

}

3) Ora che abbiamo terminato il main, dobbiamo sviluppare le due funzioni che vengono richiamate dalla pressione dei tasti, la quit() e la check(). La funzione quit() e' una semplice funzione che richiama la funzione gtk_main_quit(), potremo direttamente metterla come callback collegata al segnale di uscita.

void quit(){ gtk_main_quit(); }

L'ultima funzione, sara' quella che controllera' se il seriale inserito e' corretto, la funzione check. Come argomenti avra' il widget del tasto premuto, ed il widget dell'entry in cui e' stato inserito il seriale:

void check(GtkWidget *button, GtkWidget *seriale)

{

Le variabili necessarie sono un int (che ho chiamato istrue) che viene impostato ad 1 se il seriale e' corretto, mentre rimarra' a 0 (come impostato in questa riga) se e' errato, un GtkWidget per la finestra che ci indichera' se il seriale e' corretto o sbagliato, ed un array di caratteri che conterra' il seriale.

unsigned int istrue = 0;

GtkWidget *dialog;

gchar serial[MAX_CHARS];

Per prima cosa mettiamo nell'array seriale, il seriale inserito nell'entri, con un semplice strcpy e la funzione gtk_entry_get_text che restituisce 1 stringa.

strcpy(serial,gtk_entry_get_text(GTK_ENTRY(seriale)));

A questo punto ci sara' il blocco istruzioni per la verifica del seriale, che lascio programmare a voi. Come esempio ho messo un strcmp, che restituira' 0, se le stringhe coincidono, quindi basta mettere una not, ed otterremo 1 solo se la comparazione e' corretta.

/*

Blocco codice di verifica per il seriale

Uno stupido esempio:

istrue = !strcmp("asd",serial);

*/

Se istrue e' vera, allora visualizza il messaggio “Serial correctâ€ﾝ:

if(istrue) dialog = gtk_message_dialog_new( NULL,

GTK_DIALOG_DESTROY_WITH_PARENT,

GTK_MESSAGE_INFO,

GTK_BUTTONS_OK,

"Serial correct");

Altrimenti visualizza il messaggio “Serial wrongâ€ﾝ:

else dialog = gtk_message_dialog_new( NULL,

GTK_DIALOG_DESTROY_WITH_PARENT,

GTK_MESSAGE_ERROR,

GTK_BUTTONS_OK,

"Serial wrong");

In tutte i due i casi, la dialog deve essere visualizzata e distrutta.

gtk_dialog_run(GTK_DIALOG(dialog));

gtk_widget_destroy(dialog);

Se il seriale e' corretto, dopo la visualizzazione della dialog, viene chiuso il programma, altrimenti viene riproposta la finestra di inserimento, azzerando l'entry.

if(istrue) gtk_main_quit();

else gtk_entry_set_text(GTK_ENTRY(seriale),"");

}

4) Dopo che abbiamo terminato il nostro crackme, dobbiamo compilarlo con il commando:

gcc codice_in.c `pkg-config --cflags --libs gtk+-2.0` -o binario_out

Pkg-Config si occupera' di passare al compilatore le cartelle degli include e le librerie necessarie per compilare l'applicativo gtk. Ora che avete generato il vostro primo crackme, potrete personalizzarlo con altri widget, immagini e tutto cio' che vi eccita :D Per il codice completo lo trovate nel download in basso di questa pagina.

Per la documentazione questo e' il link: http://library.gnome.org/devel/gtk/stable/index.html

Eventuali domande o segnalazioni, sono gradite al mio indirizzo mail.
Happy coding ;)