Archive for the ‘Linux’ Category

BackBox 3.13

The-Ultimate-Hacking-Tools-Added-in-BackBox-Linux-3-09-Features-EFI-Support

Já está disponível para Download a nova versão da distribuição Linux BackBox 3.13, orientada para a realização de testes de penetração e segurança informática, vulgo, hacking.

A distribuição BackBox 3.13 é baseada em Ubuntu e inclui inúmeras aplicações / ferramentas para realização de testes de penetração de dados e segurança informática.

Algumas das ferramentas incluidas são: Bokke, Dissy, flasm, GHex, nasm, ndisasm, arping, ar-scan, knock, Zenmap, Aircrack, e reaver.

Esta nova versão trás as principais novidades:

– Kernel 3.13
– Suporte para modo EFI
– Suporte para modo anónimo
– Melhorias a1o nível do performance
– Componentes Upstream

Poderá obter mais informações Aqui:

Poderá efectuar o Download Aqui:

Share

Já falei aqui anteriormente sobre o projecto de Computação Distribuída [email protected] , e venho agora explicar de uma forma simples como é possível instalar o FAHClient 64-bit via terminal no Debian, Ubuntu e Mint Linux.

Primeiramente vamos efectuar o Download dos pacotes necessários recorrendo aos seguintes comandos:

wget –no-check-certificate https://fah.stanford.edu/file-releases/public/release/fahclient/debian-testing-64bit/v7.3/fahclient_7.3.6_amd64.deb

wget –no-check-certificate https://fah.stanford.edu/file-releases/public/release/fahcontrol/debian-testing-64bit/v7.3/fahcontrol_7.3.6-1_all.deb

wget –no-check-certificate https://fah.stanford.edu/file-releases/public/release/fahviewer/debian-testing-64bit/v7.3/fahviewer_7.3.6_amd64.deb

Seguidamente vamos proceder à sua instalação:

sudo dpkg -i –force-depends fahclient_7.3.6_amd64.deb

Insira as suas definições de instalação e clique OK.

Para instalar a aplicação de controlo FAHControl é necessário privilégios de Root:

sudo dpkg -i –force-depends fahcontrol_7.3.6-1_all.deb

A instalação do FAHViewer é feita da seguinte forma:

sudo dpkg -i –force-depends fahviewer_7.3.6_amd64.deb

Se tudo correu sem problemas terá agora todo o processo de instalação concluído.

Share

Wine 1.7.9

 06-02-2013_winehq_logo_glass

Já está disponível a nova versão do Wine, o conhecido emulador de software Windows para Linux.

A nova versão 1.7.9 apresenta varias novidades e a correcção de 47 bugs.

Poderá efectuar o download do código fonte Aqui e Aqui:

O Download dos ficheiros já compilados pode ser feito Aqui:

Share

Como qualquer aplicação escrita numa linguagem de programação compilada, necessita de ser compilada para ser executada, e o C++ é uma dessas linguagens.

Compilar:

g++ -o nome_ficheiro_executavel nome_ficheiro_codigo.cpp -lSDL

Executar:

./nome_ficheiro_executavel

O processo de compilação de uma aplicação escrita em SDL / C++ é muito semelhante ao processo de compilação de uma aplicação escrita em C++, necessitando apenas de usar uma flag indicando o uso da biblioteca SDL.

Share

sdl

A linguagem de programação C++ é muito poderosa, sendo um importante recurso na programação seja do que for. A programação de jogos não é exceção, e em conjunto com SDL (Simple DirectMedia Layer) é possível criar umas coisas engraçadas.

Como sou curioso e com demasiada vontade de experimentar tudo menos o que tenho realmente de fazer, aqui fica uma pequena experiência com C++ e SDL que mais não é que desenhar um pequeno quadrado no ecrã e a possibilidade de o movimentar usando as teclas do teclado.

Aqui fica o todo o código fonte:

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
//Include da Biblioteca SDL, Funcoes e tipos de dasdos
#include <sdl /SDL.h>
 
 
int main(int argc, char** argv)
{
        //Inicializacao do SDL
        SDL_Init(SDL_INIT_EVERYTHING);
 
        //Definição do Ecra
        SDL_Surface *screen;
        screen = SDL_SetVideoMode(640, 480, 32, SDL_SWSURFACE);
 
//        screen = SDL_SetVideoMode(640, 480, 32, SDL_SWSURFACE|SDL_FULLSCREEN);
 
        //Boleano para o teste de execucao
        bool running = true;
 
        //4 direcções
        bool b[4] = {0, 0, 0, 0};
 
        //Definicao dos controladores de FPS
        const int FPS = 30;
        Uint32 start;
 
        //Definicao dos pontos e da recta para desenho do quadrado no ecra
        SDL_Rect rect;
        rect.x = 10;
        rect.y = 10;
        rect.w = 20;
        rect.h = 20;
 
        //Definicao das cores a usar quer em background quer no quadrado desenhado
        Uint32 color = SDL_MapRGB(screen->format, 0xff,0xff,0xff); // cor branca background
        Uint32 color2 = SDL_MapRGB(screen->format, 0,0,0); //cor preta do quadrado
 
        //teste de verificacao da execução
        while(running) 
        {
                start = SDL_GetTicks();
                SDL_Event event;
 
                while(SDL_PollEvent(&event)) 
                {
                        switch(event.type) 
                        {
                                //caso escolha sair (x) termina a execuçao
                                case SDL_QUIT:
                                        running = false;
                                        break;
 
                                //caso Tecla Esteja pressionada
                                case SDL_KEYDOWN:
                                        switch(event.key.keysym.sym) 
                                        {
                                                case SDLK_UP: //Cima
                                                        b[0] = 1;
                                                        break;
                                                case SDLK_LEFT: //Esquerda
                                                        b[1] = 1;
                                                        break;
                                                case SDLK_DOWN: //Baixo
                                                        b[2] = 1;
                                                        break;
                                                case SDLK_RIGHT: //Direita
                                                        b[3] = 1;
                                                        break;
 
                                        }
                                        break;
 
                                //caso Tecla Não Esteja pressionada
                                case SDL_KEYUP:
                                        switch(event.key.keysym.sym) 
                                        {
                                                case SDLK_UP: //Cima
                                                        b[0] = 0;
                                                        break;
                                                case SDLK_LEFT: //Esquerda
                                                        b[1] = 0;
                                                        break; 
                                                case SDLK_DOWN: //Baixo
                                                        b[2] = 0;
                                                        break;
                                                case SDLK_RIGHT: //Direita
                                                        b[3] = 0;
                                                        break;
 
                                        }
                                        break;
                        }
                }
 
                //case UP pressionado decrementa 1 a Y
                if(b[0])
                        rect.y--;
                //Caso LEFT pressionado decremetna 1 a X
                if(b[1])
                        rect.x--;
                //case Down pressionado incrementa 1 a Y
                if(b[2])
                        rect.y++;
                //Caso RIGHT pressionado incremetna 1 a X
                if(b[3])
                        rect.x++;
 
                //Desenhar o background
                SDL_FillRect(screen, &screen->clip_rect, color);
                //desenhar o quadrado a preto
                SDL_FillRect(screen, &rect, color2);
 
                //Update Screen
                SDL_Flip(screen);
 
                if(1000/FPS > SDL_GetTicks()-start) 
                {
                        SDL_Delay(1000/FPS-(SDL_GetTicks()-start));
                }
        }
 
        //Quit SDL
        SDL_Quit();
 
        return 0;
}
</sdl>

 
Isto não passa de uma mera experiência sendo que existe um potencial muito grande para se extrair do C++ e do SDL capaz de fazer alguns do mais “brilhantes” jogos de computador.

Share