Aircrack-ng finalmente 1.0!

Aircrack-ng è un programma che ci consente di crackare la password WEP o WPA-PSK di una rete wireless, dopo che sono stati intercettati un numero sufficiente di pacchetti. Devo confessare che in passato non sono MAI riuscito a beccarne una di password, nemmeno quella della mia rete wireless domestica, ma sono fiducioso... :)
Il programma è disponibile sia per linux che per windows.

Con la release 1.0 innaugurano anche il nuovo sito web a questo indirizzo:

http://aircrack-ng.org/

Read more...

Dimenticata la password di Windows?

Potrà esserci di aiuto Ophcrack, un simpaticissimo programma che ho provato oggi e in meno di 4 minuti mi ha restituito l'elenco degli utenti e delle relative password di un'installazione di windows xp.
Per comodità ho installato il programma sulla Slax che ho su una pendrive usb, dove ha funzionato senza particolari problemi, l'unica è stata la necessità di installate il modulo per slax delle librerie Qt almeno versione 4.3.

Iniziamo con lo scaricare i sorgenti da questo indirizzo (anche se per onor di cronaca vi dico che è disponibile anche la versione già compilata per windows, ma noi preferiamo sicuramente quella per il nostro amico pinguino...):

http://downloads.sourceforge.net/ophcrack/ophcrack-3.3.1.tar.bz2

scompattiamo l'archivio in una directory a piacere e dopo esserci entrati compiliamo ed installiamo in modo classico:

./configure

make

make install

come al solito vi ricordo che per il make install dovremo avere i diritti di root, quindi nel caso di ubuntu ci basterà "sudo make install", mentre nel caso specifico di slax siamo già utenti root e quindi possiamo procedere senza intoppi.

Prima di lanciare il programma dovremo scaricare le rainbow tables utilizzate per decodificare le password da questa pagina:

http://ophcrack.sourceforge.net/tables.php

io personalmente vi consiglio il pacchetto XP free small (380 MB) che da una percentuale di successi del 99,9% (credeteci...) con dimensioni sensibilmente inferiori rispetto agli altri, ovviamente in questo caso i tempi di computazione si allungheranno, per usi particolari è possibile scegliere uno degli alti archivi presenti nella pagina.

Dopo aver scaricato l'archivio scompattiamolo in una directory a piacere, e ricordiamoci dove perchè dopo evidentemente ci serviranno le tabelle... :)

Ora potremo lanciare il programma digitando nella shell il comando

ophcrack

Ora dalla finestra principale clicchiamo sul pulsante Tables della toolbar, si aprirà questa finestra dove dovremo selezionare XP free small o la voce relativa all'archivio che avremo scaricato e poi sul bottone Install nella finestra di dialogo che si aprirà selezioneremo la directory in cui abbiamo scompattato l'archivio delle tebelle precedentemene scaricato. Fatto ciò ci basterà cliccare suOk. 

Tornati nella finestra principale dovremo cliccare sul pulsante Load della toolbar e poi su Encrypted SAM, si aprirà una nuova finestra di dialogo in cui dovremo specificare il disco in cui si trova l'installazione di Windows interessata e poi scorrere fino alla cartella

WINDOWS\system32\config

e selezionare Ok. Ora nella finestra principale di Ophcrack dovrebbe già apparire la lista di tutti gli utenti del sistema. Notate a destra la colonna NT Pwd è li che verranno segnalate le password trovate, se già nella riga di qualche utente appare la parola empty, vuol dire che quell'utente non ha password.

Giunti a questo punto cliccate sul pulsante Crack e attendete fiduciosi...

Read more...

Input multipiattaforma con OIS - 3a parte

Nella precedente parte abbiamo trattato la crezione dei dispositivi necessari per la lettura degli input, compresa la tastiera, ora vedremo come leggere lo stato di quest'ultima.

Nell'update dell'applicazione dovremo eseguire questo comando:

oisKeyboard->capture();

fatto ciò potremo controllare lo stato di ogni singolo tasto con:

oisKeyboard->isKeyDown(OIS::KC_F1)   // ritorna true se F1 è premuto

ovviamente potremo anche sfruttare un listener per ottenere l'input bufferizzato della tastiera, per fare ciò ci basterà derivare la classe OIS::KeyListener così:

class MyKeyListener : public OIS::KeyListener
    {
    public:
    bool keyPressed(const KeyEvent &arg)
        {
        printf("premuto tasto %i\n", arg.key);
        }
    bool keyReleased(const KeyEvent &arg)
        {
        printf("rilasciato tasto %i\n", arg.key);
        }
    };

dopo potremo impostare il nostro listener con il seguente comando:

oisKeyboard->setEventCallback(new MyKeyListener);

Read more...

Input multipiattaforma con OIS - 2a parte

Nella seconda parte di questo tutorial vedremo come creare i dispositivi necessari alla lettura dei vari input e come appunto ottenere queste informazioni. L'ultimo passaggio della parte precedente è stata la creazione dell'istanza dell'InputManager, ora con quest'ultimo potremo procedere alla crezione dei devices:

OIS::Keyboard *oisKeyboard = static_cast(oisInputManager->createInputObject(OIS::OISKeyboard, false));
OIS::Mouse *oisMouse = static_cast(oisInputManager->createInputObject(OIS::OISMouse, false));
OIS::JoyStick *oisJoystick = NULL;
try
{
    oisJoystick = static_cast  (oisInputManager->createInputObject(OIS::OISJoyStick, false));
}
catch(...)
{
    oisJoystick = NULL;
}

La creazione del device del joystick è stata inserita in un blocco try&catch perchè altimenti la libreria solleverebbe un eccezione nel caso in cui non vi fosse collegato un joystick alla macchina. In realtà noi diamo per scontato che tastiera e mouse lo siano... altrimenti sarebbe necessario inserire anche le due precedenti righe in altrettanti blocchi try&catch.

Il passo successivo è definire l'area di clipping iniziale delle coordinate del mouse, larghezza e altezza di solito saranno quelle relative alla finestra della nostra applicazione. Quest'operazione dovrà essere ripetuta anche in caso di resize della finestra.

if(oisMouse != NULL)
{
    const OIS::MouseState &ms = oisMouse->getMouseState();
    ms.width = width;
    ms.height = height;
}

Ora che abbiamo completato l'inizializzazione di OIS, vediamo come leggere i devices nel ciclo di update dell'applicazione, iniziamo dal mouse:

const OIS::MouseState &ms = this->oisMouse->getMouseState();

Nella variabile ms potremo leggere le coordinate del mouse assolute e relative rispettivamente con ms.X.abs e ms.X.rel, questo vale anche per Y e Z. Per leggere lo stato dei pulsanti invece useremo ms.buttons con un and con la costante del tasto che ci interessa verificare (es. ms.buttons & OIS::MB_Right), ecco una tabella riassuntiva:

OIS::MB_Left      // tasti sinistro, centrale e destro

OIS::MB_Middle

OIS::MB_Right

OIS::MB_Button3   // eventuali bottoni aggiuntivi da 3 a 7

[...]

OIS::MB_Button7

To be continued...

Read more...

Input multipiattaforma con OIS - 1a parte

Oggi parliamo di OIS una libreria per l'input multipiattaforma (più precisamente Linux, Window e MacOS anche se quest'ultimo solo parzialmente supportato), gestisce svariate periferiche (tastiera, mouse, joystick, wiimote, etc.) e dispositivi dotati di forcefeedback, è scritta in c++ ed è orientata ad oggetti.

Nota: negli esempi tratto la compilazione e/o utilizzo per Linux, ma non ci sono sostanziali differenze dall'utilizzo su Windows, in ogni caso nel pacchetto dei sorgenti di OIS è presente il file "readme.txt" con tutte le informazioni necessarie.

L'utilizzo neanche a dirlo è semplicissimo, iniziamo con lo scaricare i sorgenti da qui:

http://sourceforge.net/projects/wgois/files/

una volta scompattato l'archivio in una directory a scelta, eseguiremo la compilazione con:

./bootstrap
./configure
./make && make install

ovviamente, per eseguire il make install dovremo avere il privilegi di root.

Per utilizzare OIS nel nostro programma dovremo includere il suo header:

#include "OIS/OIS.h"

Creare una lista di parametri con le nostre preferenze da utilizzare per la creazione dell'inputManahger, e cosa molto importante dovremo passare ad OIS l'id di una finestra già aperta su cui agganciare l'input (nel caso di Window un HWND):

char windowIdStr[40];
sprintf(windowIdStr, "%u", windowId);

OIS::ParamList pl;
pl.insert(std::make_pair(std::string("WINDOW"), std::string(windowIdStr)));

#if defined OIS_WIN32_PLATFORM    
pl.insert(std::make_pair(std::string("w32_mouse"), std::string("DISCL_FOREGROUND" )));
pl.insert(std::make_pair(std::string("w32_mouse"), std::string( hideMouse ? "DISCL_EXCLUSIVE" : "DISCL_NONEXCLUSIVE" )));
pl.insert(std::make_pair(std::string("w32_keyboard"), std::string("DISCL_FOREGROUND")));
pl.insert(std::make_pair(std::string("w32_keyboard"), std::string("DISCL_NONEXCLUSIVE")));
#elif defined OIS_LINUX_PLATFORM
pl.insert(std::make_pair(std::string("x11_mouse_grab"), std::string( grabInput ? "true" : "false" )));
pl.insert(std::make_pair(std::string("x11_mouse_hide"), std::string( hideMouse ? "true" : "false" )));
pl.insert(std::make_pair(std::string("x11_keyboard_grab"), std::string( grabInput ? "true" : "false" )));
pl.insert(std::make_pair(std::string("XAutoRepeatOn"), std::string("true")));
#endif
 

OIS::InputManager* oisInputManager = OIS::InputManager::createInputSystem( pl );

In sostanza i vari paramentri sono sia per la versione Win32 che per linux e servono per specificare se effettuare il grab della tastiera e del mouse e se nascondere il puntatore del mouse.


To be continued...

Read more...