No sistema operacional da Microsoft uma aplicação pode ter acesso privilegiado ao sistema sem a permissão do usuário, e a conclusão disso são vírus, spywares, worms wtc.

Esse artigo tem como objetivo ensinar a criar uma System Call simples para um sistema 32 bits e 64bits. Pode parecer algo muito complicado a ser fazer, mas você verá o quão simples é. Infelizmente não é possível implementar uma System Call no sistema operacional da Microsoft. O motivo? O código dele é fechado.

1. Você precisará do fonte do Kernel. Normalmente o sistema salva o código do Kernal mais novo instalado em seu sistema no diretório “/usr/src/”, contudo você também poderá baixá-lo do site abaixo::
   http://www.kernel.org/
2. Vamos implementar uma System Call que imprime quantas vezes ela foi chamada no sistema. Vá até o diretório principal do código fonte do Kernel escolhido. Irei supor que o diretório é o: /usr/src/linux/
3. Abra o arquivo “/usr/src/linux/kernel/sys.c”. Lembre-se que você está em um diretório que exige o modo ROOT para editar arquivos. Adicione ao final do arquivo:

   asmlinkage int sys_minhaSys() {
   int static contador_minhaSys = 0;
   printk(KERN_EMERG "A minha SysCall foi chamada %d vez(es)!\n", contador_minhaSys++);
   return 0; /* estou retornando zero apenas para depois verificar qual o retorno da syscall, pois se o printk der erro, ele retornará -1 */
   }

4. Agora vem ao caso explicar o “printk”. Equivalente ao “printf”, mas para a camada do Kernel. A mensagem será impressa no final do seguinte log: /var/log/syslog. Outro modo de visualizar é digitando “dmesg” no terminal. O “KERNEL_EMERG” é para identificar os tipos de mensagem no Kernel. Não importa no nosso caso qual deles usar. Não informá-lo implicará no uso de um level padrão de mensagem, determinado no código do Kernel.
5. Ainda no mesmo arquivo, insira a seguinte include junto às outras includes:

   #include <linux/linkage.h>

6. Agora abra o seguinte arquivo: /usr/src/linux/arch/x86/include/asm/unistd_32.h
   Dica: Se você estiver compilando para 64 bits, será o arquivo unistd_64.h
7. Procure pela última SystemCall (estarão todas em sequência com um número denotando a sequência). Procure pelo maior número. Logo abaixo dessa última System Call adicione o seguinte código para 32 ou 64 bits:

   #define __NR_minhaSys         número_da_anterior_+_1

8. No caso do 32 bits, mais uma alteração será necessária, no mesmo arquivo. Note a existência da linha “#define NR_syscalls algum_número” logo abaixo de todas as SystemCalls. Ela diz quantas SystemCall existem no código. Basta somar 1 ao “algum_número”, afinal você criou uma SystemCall extra no sistema.
9. Agora abra o arquivo: /usr/src/linux/arch/x86/include/asm/syscalls.h
   Importante: Existem os arquivos “syscalls.h” e “syscall.h”; Abra o que possui a letra “s”.
10. No caso de sistema 32 bits, procure pela linha que contém “/* X86_32 only */” e abaixo dela insira o seguinte código:

    asmlinkage int sys_minhaSys();

    No caso de sistema 64 bits, procure pela linha que contém “/* X86_64 only */” e aplique o mesmo procedimento do caso do 32bits.

11. Agora abra o seguinte arquivo para 32 0u 64 bits: /usr/src/linux/arch/x86/kernel/syscall_table_32.h
    Insira no final do arquivo:

    .long sys_minhaSys

12. Pronto, agora basta compilar o seu Kernel. Você pode encontrar um tutorial atualizado e de fácil entendimento aqui mesmo, no siste do gerencievocemesmo.com.br.

Depois de compilado e instalado o Kernel, você deverá reiniciar a máquina para carregar o Kernel que você modificou. Agora irei criar uma aplicação simples para que você possa testar se a sua SystemCall está funcionando.

Programa:

#include <sys/syscall.h>
#include <unistd.h>
#include <stdio.h>
#define __NR_minhaSys        338    /* troque 338 pelo número de sua SystemCall */
 
int meuTeste() {
return (int) syscall(__NR_minhaSys);
};
main () {
printf("\nSe a minha SystemCall falhar, o resultado será -1. Se retornar corretamente, o resultado será 0.\n O Resultado foi: %d\n", meuTeste())
printf("\n Se o resultado deu zero, agora você pode verificar se a sua SystemCall imprime quantas vezes ela foi chamada.\nDigite "dmesg | tail" ou "tail /var/log/syslog" para verificar!\n");
}

Basta agora compilá-lo e executá-lo.

Esse artigo descreve como criar sua partição swap, seja com uma partição de sua HD, com um pendrive USB ou mesmo criando um arquivo de swap (o chamado swapfile).

1. Primeiro, entre como root no seu sistema. No Debian, digite “su”. No Ubuntu, “sudo su”.
2. Os comandos abaixo criam uma swap para cada caso:
   1. Para criar um arquivo swap (swapfile):

      dd if=/dev/zero of=/swapfile1 bs=1024 count=524288
      mkswap /swapfile1

      Dicas: O arquivo será criado em “/”. Para alterar, basta trocar o endereço absoluto depois de “of=”; O comando acima está criando um arquivo de 512MB (1024*512=524288), portanto você pode alterar esse valor; Os outros valores não devem ser alterados.

   2. Para tornar uma partição qualquer (HD, pendrive etc) em uma partição para swap:

      mkswap /dev/sdc

      Dica: Esse comando formata a partição informada para o formato swap, portanto basta alterar o endereço da unidade que você quiser.

3. Agora que temos criado um local para a swap, devemos torná-la disponível ao sistema; Para isso usamos esse comando:
   1. No caso do swapfile:

      swapon /swapfile1

   2. No caso da partição swap:

      swapon /dev/sdc

4. Pronto, o sistema está agora com mais swap disponível. Para ver quanto de memória swap existe no sistema e quanto está livre ou usada, use o seguinte comando para ver na unidade de megabytes:

   free -m

5. Importante: Os passos acima tornam a swap extra disponível ao sistema, mas quando ele for reiniciado, essa swap não será carregada automaticamente. Para que isso ocorra, execute os seguintes passos:

   1. nano /etc/fstab

      1. No caso do swapfile, adicione a seguinte linha:

         /swapfile1    swap    swap   defaults 0 0

      2. No caso da partição swap, adicione a seguinte linha:

         /dev/sdc    swap    swap   defaults 0 0

6. Pronto, agora o sistema carregará automaticamente sua nova swap.
   Eu usei um swapfile com o nome de “swapfile1″ e no caso de partição, supus que ela estava em “/dev/sdc”. Foram apenas exemplos, você deverá alterar corretamente esses nomes ou endereços.

• Sempre tente, antes de qualquer outro comando, essa linha:

  yum clean all

  Se não resolver, siga em diante.

• Algumas vezes ocorre de algum pacote ter tido a instalação interrompida por algum evento, seja ele do servidor ou não. Para resolver, use o seguinte comando:

  yum complete-transaction

• Se o seu Yum simplesmente parou de funcionar, está dando timeout ou dá erro no uso do plugin “fastestmirror”, use os seguintes comandos:

  rm -f /var/lib/rpm/__db*; rpm -vv --rebuilddb;

Muitas pessoas acham Linux complicado e muito menos pensariam em compilar o seu próprio Kernel, mas eu mostrarei o quanto isso é simples e não necessita de um vasto conhecimento na área.

Esse artigo foi testado no Debian unstable (sid), mas deverá funcionar em qualquer distribuição baseada no Debian (Debian like, Ubuntu like etc).

A idéia é a mesma em distros não baseadas no Debian, mas comandos ou diretórios podem ser diferentes.

Não se assuste com o tamanho desse artigo. A idéia foi explicar todos os ítens para quem é leigo no mundo Linux, mas o essencial se resume em menos de dez linhas.

Siga cada ítem, na ordem numérica, e compile o seu próprio Kernel, mesmo que você mal tenha mexido com o Linux.

1. Toda a compilação não precisa ser feita como root (modo administrador), mas a instalação do Kernel no sistema sim. Portanto recomendo fazer tudo como root para evitar problemas. Alguns comandos anteriores à compilação precisarão do modo root.Para entrar no modo root do Debian, digite no terminal:

   su

   Para entrar no modo root do Ubuntu, digite no terminal:

   sudo su

   Ambos os comandos pedirão uma senha. É a senha do root da máquina (o Debian, quando instalado, cria uma conta root e uma conta de usuário; Já o Ubuntu, durante a sua instalação, cria apenas uma conta; A senha do root será a mesma fornecida durante a instalação do Ubuntu).

2. Escolha o Kernel que você quer baixar no site Kernel.org ou onde você quiser. O importante é ter em mãos o link para download do kernel a ser compilado. Usarei, como exemplo, o seguinte Kernel: http://www.kernel.org/pub/linux/kernel/v2.6/testing/linux-2.6.34.tar.bz2
3. Com o link de download em mãos, abra o terminal e digite:

   cd /tmp
   wget http://www.kernel.org/pub/linux/kernel/v2.6/testing/linux-2.6.34.tar.bz2

4. Após o download ter completado, vamos extrair os arquivos com o seguinte comando:

   tar xjvf linux-2.6.34.tar.bz2 -C /usr/src/
   cd /usr/src/linux-x

   Substitua “x” pelo nome do arquivo extraído. No meu exemplo ficou:

   cd /usr/src/linux-linux-2.6.34

5. Embora a maioria das distros venha com o GCC, programa utilizado para compilar arquivos da linguagem C, como os fontes do Kernel, tenha certeza de que ele está instalado e atualizado com os seguintes comandos:

   apt-get update
   apt-get install gcc build-essential

6. Você deve criar o arquivo de configuração (.conf) para o Kernel ser compilado.Para criar esse menu, basta escolher uma das opções abaixo.

   Dicas: Leia antes o comentário de cada opção; Escolha apenas uma opção.

   • make localmodconfig

     Desabilita os módulos não utilizados pelo seu sistema atual. Ele fará pouquíssimas perguntas. Opção recomendada para novatos em Linux.

   • make allyesconfig

     Resposta sim para todas as perguntas. Substituir o “yes” por “no” faz o contrário.

   • make config

     Faz perguntas no terminal sobre alguns módulos, drivers etc. Serão feitas dezenas de perguntas.

   • make menuconfig

     (menu* no terminal) Recomendado para quando as opções acima dão problema. Apenas abra o menu, salve o arquivo de configuração e saia. Se você quiser, você pode adicionar o remover os módulos la listados, desde que você saiba o que está fazendo.

     Dica: Você pode copiar o seu “config” atual que está em “/boot/config*”, para o diretório do Makefile com o seguinte nome: “.conf”; Você poderá carregá-lo através desse menu.

   • make xconfig

     (menu* modo janela baseado em X Windows QT, ideal para quem usa KDE)

   • make gconfig

     (menu* modo janela baseado em X Windows GTK, ideal para quem usa GNOME)

     *Importante: Para que o menu funcione, será necessário instalar a biblioteca ncurses:

     apt-get install libncurses5 libncurses5-dev

7. Agora iremos compilar o Kernel. Observe que atualmente estamos no diretório onde estão os arquivos fonte do Kernel (no meu exemplo, /usr/src/linux-2.6.34/).Os comandos são simples:

   make
   make modules

8. Estamos quase terminando. Agora iremos instalar o Kernel e os módulos compilados com os comandos abaixo:

   make modules_install
   make install

9. Agora temos que criar o “initrd” para o Kernel instalado. Você não precisa saber, mas o “initrd” significa “Initial RAM disk”, ele contém uma pequena imagem do sistema que será carregada no boot.

   cd /boot/
   mkinitramfs -o initrd-x.img /lib/modules/x/

   Substitua o “x” pela versão do seu kernel. Seguindo o nosso exemplo, o comando seria:

   mkinitramfs -o initrd.img-2.6.34 /lib/modules/2.6.34/

10. Por fim, basta configurar no seu gerenciador de boot o novo Kernel com o novo “initrd”.Como root, digite o seguinte comando:

    update-grub

    Ele localizará o novo Kernel e instalará para você.

Pronto, você viu como adicionar ou remover módulos do Kernel (menus), compilar o kernel e os seus módulos e, por fim, instalá-lo no sistema e no gerenciador de boot.

Detalhei várias partes do artigo para não deixar dúvidas, mas, como avisei antes, esse artigo pode assustar pelo tamanho dele, contudo a compilação e instalação do Kernel é super simples e pode ser resumida em pouquíssimas linhas.

Em um artigo posterior irei falar sobre como adicionar ou remover módulos e patches de terceiros no Kernel.

Nesse artigo falarei sobre o IRSSI, um excelente aplicativo que roda no terminal e acessa qualquer rede IRC.

Para instalá-lo no Ubuntu, é simples:

sudo apt-get install irssi

Para executá-lo, abra um terminal e digite:

irssi

O programa será aberto dentro do terminal. A partir desse momento, você poderá usar os mesmos comandos usados em qualquer cliente IRC.

Por exemplo:

• /server irc.freenode.net 6667
  Conecta no servidor da freenode
• /join #brasil
  Entra na sala brasil
• /msg nickserv identify meunickname minhasenha
  Efetua login no seu nickname

Existem alguns atalhos interessantes no Irssi que podem ser utilizados:

• ctrl + n
  Vai para a próxima tela (você pode ter vários canais e privative messages)
• /win c (ou /window close)
  Fecha a janela atual
• /layout save
  Salva a configuração das janelas e restaura-as no próximo login
• /c (ou /clear)
  Limpa a janela atual
• /c -all (ou /clear -all)
  Limpa toda as janelas
• /wi nickname (ou /whois nickname)
  Mostra informações de um nickname

Por fim, três comandos legais para fazer o IRSSI se auto-conectar a um servidor, a um canal e fazer auto-login do seu nickname.

Importante: Cada configuração exige que seja configurado um Perfil, por exemplo: Quando você instalar um auto-join de canal e quiser que sempre que um servidor X for aberto ele seja executado, você deverá associar esse auto-join a esse servidor. Você verá abaixo que isso é super simples.

O Irssi já vem com diversos servidores pré-configurados, mas vou partir do princípio que você quer adicionar um novo, assim já aproveito para ensinar um comando extra. Você pode digitar os comandos abaixo em qualquer uma das telas do seu Irssi.

• Adicionando um servidor para abrir automaticamente:
  /server add -auto -network freenode irc.freenode.net 6667
  Lembra que eu disse sobre um perfil para cada servidor? Pois bem, dei o nome “freenode” para o servidor acima (logo após a opção “-network”).
• Identificando o seu nickname automaticamente após abrir o servidor cujo perfil chama-se “freenode”:
  /network add -autosendcmd “/^nick MEUNICK; /^msg nickserv identify MINHASENHA;wait 2000″ freenode
  Observe que no final do comando, coloquei o nome do perfil que ele será associado. Isso faz com que sempre quando o servidor cujo perfil tem nome “freenode” for aberto, esse comando também seja executado.
• Adicionando auto-join aos canais:
  /channel add -auto #meucanal freenode
  Esse comando será executado sempre que o servidor cujo perfil tem nome “freenode” é aberto.
  Caso o canal possua uma senha para acesse, use a seguinte sintaxe:
  /channel add -auto #meucanal freenode senhadocanal

Para ter certeza de que nenhuma versão do flash está instalada, execute o seguinte comando:

sudo apt-get purge flashplugin-nonfree flashplugin-installer gnash gnash-common mozilla-plugin-gnash swfdec-mozilla

Dica: A primeira linha desse artigo, a de cima, deve ser executada para ambos os casos abaixo citados.

Para Ubuntu 9.10 ou superior, iremos instalar o repositório e o flash com essas linhas:

sudo add-apt-repository ppa:sevenmachines/flash
sudo apt-get update
sudo apt-get install flashplugin64-installer

Em sistemas anteriores ao Ubuntu 9.10 (9.04, 8.10 etc) será necessário utilizar um pacote que é um pouco antigo. Agora execute:

sudo wget http://www.medibuntu.org/sources.list.d/`lsb_release -cs`.list \--output-document=/etc/apt/sources.list.d/medibuntu.list
sudo apt-get -q update
sudo apt-get --yes -q --allow-unauthenticated install medibuntu-keyring
sudo apt-get install flashplugin-nonfree

Muitas pessoas se assustam com essas linhas de comandos e acham que Linux é difícil. Tudo o que eu apresento em linha de comando está na “central de software do Ubuntu” (Ubuntu Software Center). Tudo disponível graficamente. A idéia de usar linha de comandos é não depender de janelas ou aplicativos e ir direto a solução via terminal. Você não precisa entender o que está ocorrendo, apenas copiar e colar em seu terminal.

Realmente recomendo a todos que usam o Ubuntu testá-lo. Pequeno, leve e muito esperto.

Embora tudo possa ser feito manualmente (todos os seus tweaks), você economiza tempo fazendo via gráfico essas alterações (mas também ficará limitado às opções disponíveis nele). Esse é uma das grandes vantagens do Linux: aberto, livre. Você usa o melhor do aplicativo gráfico, mas não fica limitado às opções dele.

Primeiro, instale o repositório do programa no terminal:
Para Ubuntu 9.10 ou superior, 32 ou 64 bits:

sudo add-apt-repositoryppa:tualatrix/ppa && sudo apt-get update

Para Ubuntu 9.04 ou inferior, 32 ou 64 bits:

sudo echo -e "\ndeb-src http://ppa.launchpad.net/tualatrix/ppa/ubuntu `lsb_release --short --codename` main" | sudo tee -a /etc/apt/sources.list > /dev/null 
sudo gpg --keyserver hkp://keyserver.ubuntu.com:11371 --recv-key 0624A220
sudo gpg -a --export 0624A220 | sudo apt-key add -

Segundo, instale o aplicativo:

sudo apt-get install ubuntu-tweak

Se o problema ocorre com você, execute a linha abaixo que corrigirá o problema:

echo "Acquire::http::Pipeline-Depth "0";" | sudo tee -a /etc/apt/apt.conf.d/90localsettings

Para resolver o problema, que tal voltar à configuração de “fábrica” da sua distro? Com apenas três linhas no terminal, isso é possível:

gconftool-2 --shutdown
rm -rf ~/.gconf/apps/panel ~/.gnome ~/.gnome2 ~/.gconf ~/.gconfd ~/.metacity
pkill gnome-panel

• ssh -D porta usuario@servidor
  Exemplo: ssh -D 2222 gvm@gerencievocemesmo.com.br

Pronto, o tunelamento está aberto. Configure agora os seus programas para usarem  “localhost” como host e a porta usada no comando (no exemplo, a 2222).

Todos os seus dados passarão criptografados pelo túnel e serão requisitados pelo servidor usado à internet e não pela sua máquina, isto é, para a rede mundial de computadores quem acessa é o servidor, mas na verdade é você que está utilizando esses os dados recebidos e enviados pelo servidor.