Unix Toolbox
Esse documento é uma coleção de comandos Unix/Linux/BSD e de tarefas que são uteis para trabalho em TI ou usuários avançados. Esse é um guia prático com explicações concisas, embora o leitor deve saber o que está fazendo.

Unix Toolbox revisão 14.4
A ultima versão desse documento pode ser encontrado em http://cb.vu/unixtoolbox.xhtml. Substitua .xhtml no link com .pdf para a versão PDF e com .book.pdf para a versão folheto. Em uma impressora duplex o folheto criará um pequeno livro pronto para encadernar. Essa página XHTML pode ser convertida para um bom documento PDF com uma aplicação complacente CSS3 (veja o script exemplo). Veja também a página sobre.
Reportes de erros e comentários são muito bem vindos - c@cb.vu Colin Barschel.

Sistema

Hardware | Estatísticas | Usuários | Limites | Runlevels | Senha de root | Compilar o kernel | Concertar o grub | Outros

Rodando o kernel e informações do sistema
    # uname -a                           # Obter versão do kernel (e versão do BSD também)
    # lsb_release -a                     # Informação completa de lançamento de qualquer distribuição LSB
    # cat /etc/SuSE-release              # Obter versão do SuSE
    # cat /etc/debian_version            # Obter versão do Debian
    
Utilize /etc/DISTR-release com DISTR= lsb (Ubuntu), redhat, gentoo, mandrake, sun (Solaris), e assim por diante. veja também /etc/issue.
    # uptime                             # Exibir a quanto tempo o sistema está rodando + carga
    # hostname                           # host name do sistema
    # hostname -i                        # Exibir o endereço de IP do host. (somente para Linux)
    # man hier                           # Descrição da hierarquia do sistema de arquivo
    # last reboot                        # Exibir histórico de reboot do sistema
    

Informações de Hardware

Hardware detectado pelo kernel
# dmesg                              # Hardware detectado e mensagens de boot
    # lsdev                              # informação a respeito do hardware instalado
    # dd if=/dev/mem bs=1k skip=768 count=256 2>/dev/null | strings -n 8 # Lê BIOS
    

Linux

    # cat /proc/cpuinfo                  # Modelo do CPU
    # cat /proc/meminfo                  # Memória do Hardware
    # grep MemTotal /proc/meminfo        # Exibir a memória física
    # watch -n1 'cat /proc/interrupts'   # Observar interrupções alteráveis continuadamente
    # free -m                            # Memória utilizada e livre (-m para MB)
    # cat /proc/devices                  # dispositivos configurados
    # lspci -tv                          # Exibir dispositivos PCI
    # lsusb -tv                          # Exibir dispositivos USB
    # lshal                              # Exibir uma lista de todos os dispositivos com suas propriedades
    # dmidecode                          # Exibir DMI/SMBIOS: hw info da BIOS
    

FreeBSD

    # sysctl hw.model                    # Modelo do CPU
    # sysctl hw                          # Dá um monte de informações de hardware
    # sysctl hw.ncpu                     # número de CPUs ativos instalados
    # sysctl vm                          # Uso de memória
    # sysctl hw.realmem                  # Memória do hardware
    # sysctl -a | grep mem               # Configurações de memória do kernel e informações
    # sysctl dev                         # Dispositivos Configurados
    # pciconf -l -cv                     # Exibir dispositivos PCI
    # usbdevs -v                         # Exibir dispositivos USB
    # atacontrol list                    # Exibir dispositivos ATA
    # camcontrol devlist -v              # Exibir dispositivos SCSI
    

Carga, estatísticas e mensagens

Os comandos a seguir são uteis para descobrir o que está acontecendo no sistema.
    # top                                # exibe e atualiza o top dos processos do cpu
    # mpstat 1                           # Exibe estatísticas relacionadas ao processador
    # vmstat 2                           # Exibe estatísticas da memória virtual
    # iostat 2                           # Exibe estatísticas de I/O (intervalos de 2 s)
    # systat -vmstat 1                   # Resumo estatísticas de sistema BSD (intervalos de 1 segundo)
    # systat -tcp 1                      # Conexões TCP BSD (tente também -ip)
    # systat -netstat 1                  # Conexões de rede de ativa BSD
    # systat -ifstat 1                   # Tráfego de rede BSD pelas interfaces ativas
    # systat -iostat 1                   # CPU BSD e rendimento de disco
    # ipcs -a                            # Informação de interprocessos no System
    # tail -n 500 /var/log/messages      # Ultimas 500 mensagens kernel/syslog
    # tail /var/log/warn                 # Mensagens de aviso do sistema; veja syslog.conf
    

Usuários

    # id                                 # Exibe id do usuário ativo com login e group
    # last                               # Exibe os últimos logins no sistema
    # who                                # Exibe quem está logado no sistema
    # groupadd admin                     # Adiciona grupo "admin" e usuário colin (Linux/Solaris)
    # useradd -c "Colin Barschel" -g admin -m colin
    # usermod -a -G <group> <user>       # Adiciona usuário existente ao grupo (Debian)
    # groupmod -A <user> <group>         # Adiciona usuário existente ao grupo (SuSE)
    # userdel colin                      # Remove o usuário colin (Linux/Solaris)
    # adduser joe                        # FreeBSD adicionar usuário joe (interativo)
    # rmuser joe                         # FreeBSD remove usuário joe (interativo)
    # pw groupadd admin                  # Utilize pw no FreeBSD
    # pw groupmod admin -m newmember     # Adicione um novo menbro ao grupo
    # pw useradd colin -c "Colin Barschel" -g admin -m -s /bin/tcsh 
    # pw userdel colin; pw groupdel admin
    
Senhas criptografadas ficam armazenadas em /etc/shadow no Linux e Solaris e /etc/master.passwd no FreeBSD. Se o master.passwd for modificado manualmente (dizê-lo para remover uma senha), execute o # pwd_mkdb -p master.passwd para reconstruir a base de dados.

Para impedir logins temporariamente no sistema (para todos os usuários, menos para o root) utilize o nologin. A mensagem em nologin será exibida (pode não funcionar com as chaves pré-compartilhadas do ssh).
# echo "Desculpe, sem login no momento" > /etc/nologin       # (Linux)
    # echo "Desculpe, sem login no momento" > /var/run/nologin   # (FreeBSD)
    

Limites

Algumas aplicações requerem limites mais altos em arquivos e sockets abertos (como um servidor proxy , banco de dados). Os limites padrões são normalmente muito baixos.

Linux

Por shell/script

Os limites do shell são governados pelo ulimit. O status é verificado com o ulimit -a. Por exemplo, para alterar o limite dos arquivos de 1024 para 10240, faça:
# ulimit -n 10240                    # Isso é válido somente dentro do shell
    
O comando ulimit pode ser utilizado em um script para alterar os limites para o script somente.

Por usuário/processo

Login, usuários e aplicações podem ser configurados em /etc/security/limits.conf. por exemplo:
# cat /etc/security/limits.conf
    *   hard    nproc   250              # Limite de processos por usuário
    asterisk hard nofile 409600          # Limite de arquivos abertos por aplicação
    

Sistema

Limites do kernel são configurados com o sysctl. Limites permanentes são configurados em /etc/sysctl.conf.
    # sysctl -a                          # Visualiza todos os limites do sistema
    # sysctl fs.file-max                 # Visualiza limite máximo de arquivos abertos
    # sysctl fs.file-max=102400          # Altera o limite de máximo de arquivos abertos
    # echo "1024 50000" > /proc/sys/net/ipv4/ip_local_port_range  # alcance de porta
    # cat /etc/sysctl.conf
    fs.file-max=102400                   # Entrada permanente em sysctl.conf
    # cat /proc/sys/fs/file-nr           # Quantos descritores de arquivo estão em uso
    

FreeBSD

Por shell/script

Utilize o comando limits no csh ou no tcsh ou como no Linux, utilize ulimit em um sh ou bash shell.

Por user/processo

Os limites padrões no login são configurados em /etc/login.conf. Um valor ilimitador é ainda assim limitado pelo valor máximo do sistema.

Sistema

Limites do kernel também são configurados com o sysctl. Limites permanentes são configurados em /etc/sysctl.conf ou /boot/loader.conf. A syntax é a mesma como em Linux, mas as chaves são diferentes.
    # sysctl -a                          # Visualizar todos os limites do sistema
    # sysctl kern.maxfiles=XXXX          # Número máximo de descrições de arquivo
    kern.ipc.nmbclusters=32768           # Entrada permanente em /etc/sysctl.conf
    kern.maxfiles=65536                  # Valores típicos para Squid
    kern.maxfilesperproc=32768
    kern.ipc.somaxconn=8192              # Fila de TCP. Melhor para apache/sendmail
    # sysctl kern.openfiles              # Quantas descrições de arquivo estão em uso
    # sysctl kern.ipc.numopensockets     # Quantos sockets abertos estão em uso
    # sysctl net.inet.ip.portrange.last=50000 # O padrão é 1024-5000
    # netstat -m                         # Estatísticas de buffers de memória de rede
    
Veja o Capítulo 11 do FreeBSD handbookhttp://www.freebsd.org/handbook/configtuning-kernel-limits.html para mais detalhes. E também FreeBSD performance tuninghttp://serverfault.com/questions/64356/freebsd-performance-tuning-sysctls-loader-conf-kernel

Solaris

Os valores a seguir em /etc/system aumentarão o descritores máximo de arquivo por proc:
set rlim_fd_max = 4096               # Limite rígido nos descritores de arquivo para um single single proc
    set rlim_fd_cur = 1024               # Limite leve nos descritores de arquivo para um single proc
    

Runlevels (níveis de execução)

Linux

Uma vez inicializado, o kernel inicia o init o qual então inicia rc o qual inicia todos os scripts pertencentes á um runlevel. Os scripts são armazenados em /etc/init.d e são linkados dentro de /etc/rc.d/rcN.d com N número do runlevel.
O runlevel padrão está configurado em /etc/inittab. É normalmente o 3 ou o 5:
# grep default: /etc/inittab
    id:3:initdefault:
    
O The runlevel atual pode ser alterado com o init. Por exemplo, para ir do 3 para o 5:
# init 5                             # Entra o runlevel 5
(Nota do tradutor: Não foi mencionado o valor de número 4, porém não é aconselhado utilizá-lo, pois esse valor não tem definição por se tratar de uso somente para propósitos especiais.) Use chkconfig para configurar os programas que serão inicializados ao boot em um runlevel.
    # chkconfig --list                   # Listar todos os scripts init
    # chkconfig --list sshd              # Reportar o status do sshd
    # chkconfig sshd --level 35 on       # Configura o e sshd para os nívies 3 e 5
    # chkconfig sshd off                 # Desabilitar o sshd para todos os runlevels
    
Debian e distribuições basadas em Debian como o Ubuntu ou o Knoppix utilizam o comando update-rc.d para gerenciar os scripts de runlevels. O padrão é iniciar em 2,3,4 e 5 e encerrar em 0,1 e 6.
    # update-rc.d sshd defaults          # Ativar o sshd com os runlevels padrões
    # update-rc.d sshd start 20 2 3 4 5 . stop 20 0 1 6 .  # Com argumentos explícitos
    # update-rc.d -f sshd remove         # Desabilita o sshd para todos os runlevels
    # shutdown -h now (or # poweroff)    # Encerra e desliga o sistema
    

FreeBSD

A aproximação da inicialização do BSD é diferente do SysV, não há runlevels. O estado final do boot (single user, com ou sem X) é configurado em /etc/ttys. Todos os scripts do sistema operacional ficam localizados em /etc/rc.d/ e em /usr/local/etc/rc.d/ para aplicações de terceiros (third-party). A ativação do serviço é configurada em /etc/rc.conf e /etc/rc.conf.local. O comportamento padrão é configurado em /etc/defaults/rc.conf. O scripts respondem ao menos a start|stop|status.
# /etc/rc.d/sshd status
    sshd is running as pid 552.
    # shutdown now                       # Vá para o modo single-user
    # exit                               # Volta ao modo multi-user
    # shutdown -p now                    # Encerre e desligue o sistema
    # shutdown -r now                    # Reiniciar
    
O processo init pode também ser usado para alcançar um dos níveis estados de seguintes. Por exemplo # init 6 para reboot.

Windows

Inicia e para um serviço ou com o service name ou com "service description" (exibe o Painel de Controle de Serviços) como se segue:
net stop WSearch
    net start WSearch                    # inicia serviço de busca
    net stop "Windows Search"
    net start "Windows Search"           # mesmo que acima utilizando o descr.
    

Reconfigurar a senha de root

Método Linux 1

Ao carregamento de boot [boot loader (lilo or grub)], entre a opção de boot a seguir:
init=/bin/sh
O kernel montará a partição root e init iniciará o bourne shell ao inves de rc e então um runlevel. Utilize o comando passwd no prompt e altere a senha e então reinicie. Esqueça o modo single user como se precisasse da senha para isso.
Se, depois de inicializar, a partição root estiver montada em somente leitura (read only), remonte em rw:
    # mount -o remount,rw /
    # passwd                             # ou exclua a senha do root (/etc/shadow)
    # sync; mount -o remount,ro /        # sincroniza antes para remontar em somente leitura (read only)
    # reboot
    

Método FreeBSD 1

No FreeBSD, inicialize em modo single user, remonte / rw e utilize passwd. Você pode secionar o modo single user no menu de boot (opção 4) que é exibido por 10 segundos ao inicio. o modo single user lhe dará um shell root na partição /.
    # mount -u /; mount -a               # montará / rw
    # passwd
    # reboot
    

Método 2: Unixes e FreeBSD e Linux

Outros Unixes podem não deixar você ir embora com um simples truque init. A solução é montar a partição root de um outro OS (como um CD de recuperação) e alterar a senha no disco.
    # mount -o rw /dev/ad4s3a /mnt
    # chroot /mnt                        # chroot no /mnt
    # passwd
    # reboot
    

módulos do kernel

Linux

    # lsmod                              # Listar todos os módulos carregados no kernel
    # modprobe isdn                      # Para carregar um módulo (aqui no exemplo, isdn)
    

FreeBSD

# kldstat                            # Listar todos os módulos carregados no kernel
    # kldload crypto                     # Para carregar um módulo (aqui no caso, crypto)
    

Compilar o Kernel

Linux

    # cd /usr/src/linux
    # make mrproper                      # Limpe tudo, incluindo arquivos de configuração
    # make oldconfig                     # Reutilize o antigo .config se existente
    # make menuconfig                    # ou xconfig (Qt) ou gconfig (GTK)
    # make                               # Crie uma imagem do kernel  comprimido
    # make modules                       # Compile os módulos
    # make modules_install               # Instale os módulos
    # make install                       # Instale o kernel
    # reboot
    

FreeBSD

Opcionalmente atualize a árvore fonte (source tree) (no /usr/src) com o csup (como do FreeBSD 6.2 ou mais recentes):
# csup <supfile>
Eu utilizo o seguinte supfile:
*default host=cvsup5.FreeBSD.org  # www.freebsd.org/handbook/cvsup.html#CVSUP-MIRRORS
    *default prefix=/usr 
    *default base=/var/db
    *default release=cvs delete tag=RELENG_7
    src-all
    
Para modificar e reconstruir o kernel, copie o arquivo de configuração genérica para um novo nome e edite-o como necessário (você pode também editar o arquivo GENERIC diretamente). Para reiniciar a construção depois da interrupção, adicione a opção NO_CLEAN=YES para fazer o comando evitar que limpe os objetos já construídos.
 
    # cd /usr/src/sys/i386/conf/
    # cp GENERIC MYKERNEL
    # cd /usr/src
    # make buildkernel KERNCONF=MYKERNEL
    # make installkernel KERNCONF=MYKERNEL
    
Para reconstruir o sistema operacional por completo:
# make buildworld                    # Construa o sistema operacional por completo, mas não o kernel
    # make buildkernel                   # Utilize KERNCONF como acima se apropriado
    # make installkernel
    # reboot
    # mergemaster -p                     # Compare somente arquivos conhecidos por serem essenciais
    # make installworld
    # mergemaster -i -U                  # Atualiza todas as configurações e outros arquivos
    # reboot
    
Para pequenas mudanças na fonte você pode utilizar NO_CLEAN=yes para evitar reconstruir toda a arvore (tree).
# make buildworld NO_CLEAN=yes       # Não exclua os objetos antigos
    # make buildkernel KERNCONF=MYKERNEL NO_CLEAN=yes
    

Reparar (concertar) o grub

Então você quebrou o grub? Inicie (boot) a partir de um live cd, [encontre sua partição Linux sob /dev e utilize fdisk para encontrara partição Linux] monte a partição linux, adicione /proc e /dev e utilize grub-install /dev/xyz. Suponha que o Linux repousa no /dev/sda6:
# mount /dev/sda6 /mnt               # monte a partição Linux em /mnt
    # mount --bind /proc /mnt/proc       # monte o subsistema dentro de /mnt
    # mount --bind /dev /mnt/dev         # monte os dispositivos dentro de /mnt
    # chroot /mnt                        # altere o root para a partição linux
    # grub-install /dev/sda              # reinstale o grub com suas configurações antigas
    

Misc

Desabilitar a memória virtual do OSX (repita com o load para reabilitar). Sistema mais rápido, mas um pouco arriscado.
 
    # sudo launchctl unload -w /System/Library/LaunchDaemons/com.apple.dynamic_pager.plist
    # sleep 3600; pmset sleepnow           # vá para o modo standby dentro de uma hora (OSX)
    # defaults write -g com.apple.mouse.scaling -float 8
                                         # aceleração de mouse do OSX (utilize p -1 para reverter)
    

Processos

Listing | Priority | Background/Foreground | Top | Kill

Listar e PIDs

Cada processo possui número único, o chamado PID. Uma lista de todos os processos em execução é exibido com o ps.
# ps -auxefw                         # Lista extensiva de todos os processos em execução
Contudo o uso mais típico é com um pipe ou com pgrep (para o OS X instale proctools a partir do MacPorts):
# ps axww | grep cron
      586  ??  Is     0:01.48 /usr/sbin/cron -s
    # ps axjf                            # Todos os processos em um formato de arvore (Linux)
    # ps aux | grep 'ss[h]'              # Encontre todos os PIDs ssh sem o PID do grep
    # pgrep -l sshd                      # Encontre os PIDs dos processos por (parte do) nome
    # echo $$                            # O PID do seu shell
    # fuser -va 22/tcp                   # Lista de processos utilizando a porta 22 (Linux)
    # pmap PID                           # Mapa de memória do processo (cace o vazamento de memória) (Linux)
    # fuser -va /home                    # Listar processos acessando a partição /home
    # strace df                          # Traçar chamadas e sinais do sistema
    # truss df                           # O mesmo acima no FreeBSD/Solaris/Unixware
    

Prioridade

Altere a prioridade de um processo em execução com o renice. Números negativos tem uma prioridade mais alta, o mais baixo é -20 e "nice" tem um valor positivo.
# renice -5 586                      # prioridade mais forte
    586: old priority 0, new priority -5
    
Inicie o processo com uma prioridade definida com nice. Positivo é "nice" ou fraco, negativo é prioridade de agendamento forte. certifique-se de que você sabe se /usr/bin/nice ou o shell built-in é utilizado (verifique com o # which nice).
# nice -n -5 top                     # prioridade mais forte (/usr/bin/nice)
    # nice -n 5 top                      # Prioridade mais fraca(/usr/bin/nice)
    # nice +5 top                        # tcsh builtin nice (o mesmo que acima!)
    
Enquanto nice altera o agendador do CPU (scheduler), um outro comando util ionice agendará o IO de disco. Isso é muto útil para aplicações intensivas de IO (entrada e saída)(exemplo: compilar). Você pode selecionar uma classe [inativo (idle) - melhor esforço (best effort) - tempo real (real time)], a página de manual (man page) é curta e bem explicada.
# ionice c3 -p123                    # configura a classe inativa (idle class) para o pid 123 (somente em Linux)
    # ionice -c2 -n0 firefox             # Roda o firefox com melhor empenho (best effort) e alta prioridade
    # ionice -c3 -p$$                    # Configura a sheel atual para prioridade inativa
    
O ultimo comando é muito útil para compilar (ou debugar) um grande projeto. Todo comando carregado a partir do shell terá uma prioridade lover. $$ é o seu pid shell (tente echo $$).
Os FreeBSD utilizam idprio/rtprio (0 = max priority, 31 = most idle):
# idprio 31 make                     # compila em baixa prioridade
    # idprio 31 -1234                    # configura o PID 1234 com baixa prioridade
    # idprio -t -1234                    # -t remove qualquer real time/idle priority
    

Plano de fundo ou plano frontal (Background/Foreground)

Quando iniciado a partir de um shell, processos podem ser trazidos em plano de fundo (background) e de volta para o plano frontal (foreground) com [Ctrl]-[Z] (^Z), bg e fg. Listar os processos com o jobs. Quando necessário destaca a partir de um terminal com o disown.
# ping cb.vu > ping.log
    ^Z                                   # ping está suspense (parado) com o [Ctrl]-[Z] 
    # bg                                 # Coloca em plano de fundo e continua rodando
    # jobs -l                            # Lista processos em plano de fundo
    [1]  - 36232 Running                       ping cb.vu > ping.log
    [2]  + 36233 Suspended (tty output)        top
    # fg %2                              # Traz processo  2 de volta para plano frontal
    
# make                               # Inicia um serviço longo de compilação mas necessita deixar o terminal
    ^Z                                   # suspenso (stopped) com [Ctrl]-[Z] 
    # bg                                 # Coloca em plano de fundo e continua rodando
    # disown -h %1                       # destaca processo a partir do terminal, não será morto no logout
    
Sem caminho a frente para reanexar o processo para um novo terminal, tente reptyr (Linux).
Utilize nohup para iniciar um processo na qual tem que continuar executando quando o shell for fechado (imune a hangups).
# nohup ping -i 60 > ping.log &
    

Top

O programa top exibe informações de processos em execução. Veja também o programa htop a partir de htop.sourceforge.net (uma versão mais poderosa do top) que roda em Linux e em FreeBSD (ports/sysutils/htop/). Enquanto o top estiver rodando pressione a tecla h para uam visão global de ajuda (help). Teclas uteis são:

Sigais/Kill

Termina ou envia um sinal com kill ou killall.
# ping -i 60 cb.vu > ping.log &
    [1] 4712
    # kill -s TERM 4712                  # O mesmo que kill -15 4712
    # killall -1 httpd                   # Kill HUP nos processos por nome exato
    # pkill -9 http                      # Kill TERM nos processos por (parte do) nome
    # pkill -TERM -u www                 # Kill TERM nos processos possuídos por www
    # fuser -k -TERM -m /home            # mata todos os processos acessando /home (para desmontar)
    
Sinais importantes são:

Sistema de arquivos

Informação de disco | Boot | Uso de disco | Arquivos abertos | Montar/remontar | Montar o SMB | Montar imagem | Queimar ISO | Criar imagem | Disco de memória | Desempenho de disco

Permissões

Altere permissão e proprietário com o chmod e chown. O umask padrão pode ser alterado para todos os usuários em /etc/profile para Linux ou /etc/login.conf para FreeBSD. O umask padrão é normalmente 022. O umask é subtraído a partir do 777, assim o umask 022 resulta em uma permissão de 755.
1 --x execute                        # Mode 764 = exec/read/write | read/write | read
    2 -w- write                          # For:       |--  Owner  --|   |- Group-|   |Oth|
    4 r-- read
      ugo=a                              u=user, g=group, o=others, a=everyone
    
# chmod [OPTION] MODE[,MODE] FILE    # MODE é da forma [ugoa]*([-+=]([rwxXst]))
    # chmod 640 /var/log/maillog         # Restrito ao log -rw-r-----
    # chmod u=rw,g=r,o= /var/log/maillog # O mesmo que acima
    # chmod -R o-r /home/*               # Remove recursivamente outros legíveis para todos os usuários
    # chmod u+s /path/to/prog            # Configura o SUID bit no executável (Saiba o que fazer!)
    # find / -perm -u+s -print           # Encontra todos os programas com o SUID bit
    # chown user:group /path/to/file     # Altera o usuário e proprietário do grupo de um arquivo
    # chgrp group /path/to/file          # Altera o proprietário de um grupo de um arquivo
    # chmod 640 `find ./ -type f -print` # Altera as permissões para 640 para todos os arquivos
    # chmod 751 `find ./ -type d -print` # Altera as permissões para 751 para todos os diretórios
    

Informações de disco

# diskinfo -v /dev/ad2               # informações a respeito do disco (sector/size) FreeBSD
    # hdparm -I /dev/sda                 # informação a respeito do disco IDE/ATA (Linux)
    # fdisk /dev/ad2                     # Exibe e manipula a tabela de partição
    # smartctl -a /dev/ad2               # Exibe a informação disk SMART
    

Boot

FreeBSD

Para iniciar (boot) um kernel antigo se o novo não iniciar, pare o boot durante a contagem regressiva.
# unload
    # load kernel.old
    # boot
    

Pontos de montagem do sistema/Uso de disco

# mount | column -t                  # Mostra o sistemas de arquivos montados no sistema
    # df                                 # Exibe espaço livre de disco e dispositivos montados
    # cat /proc/partitions               # Mostra todas as partições registradas (Linux)
    

Uso de disco

# du -sh *                           # Tamanhos de diretórios como listado
    # du -csh                            # Tamanho total do diretório atual
    # du -ks * | sort -n -r              # Classifica tudo por tamanho em kilobytes
    # ls -lSr                            # Mostra arquivos, maiores por ultimo
    

Quem tem quais arquivos abertos

Isso é útil para descobrir qual arquivo está bloqueando uma partição que tem que ser desmontada e dá um típico erro de:
# umount /home/
    umount: unmount of /home             # umount impossible because a file is locking home (impossível desmontar por que um arquivo está travando o home)
       failed: Device busy (falhou: dispositivo ocupado)
    

FreeBSD e muitos Unixes

# fstat -f /home                     # para um ponto de montagem
    # fstat -p PID                       # para uma aplicação com o PID
    # fstat -u user                      # para um name
    
Encontre arquivo de log aberto (ou outros arquivos abertos), diga para o Xorg:
# ps ax | grep Xorg | awk '{print $1}'
    1252
    # fstat -p 1252
    USER     CMD          PID   FD MOUNT      INUM MODE         SZ|DV R/W
    root     Xorg        1252 root /             2 drwxr-xr-x     512  r
    root     Xorg        1252 text /usr     216016 -rws--x--x  1679848 r
    root     Xorg        1252    0 /var     212042 -rw-r--r--   56987  w
    
O arquivo com o inum 212042 é o único arquivo em /var:
# find -x /var -inum 212042
    /var/log/Xorg.0.log
    

Linux

Encontre arquivos abertos em um ponto de montagem com fuser ou lsof:
# fuser -m /home                     # Lista processos acessando /home
    # lsof /home
    COMMAND   PID    USER   FD   TYPE DEVICE    SIZE     NODE NAME
    tcsh    29029 eedcoba  cwd    DIR   0,18   12288  1048587 /home/eedcoba (guam:/home)
    lsof    29140 eedcoba  cwd    DIR   0,18   12288  1048587 /home/eedcoba (guam:/home)
    
Sobre uma aplicação:
ps ax | grep Xorg | awk '{print $1}'
    3324
    # lsof -p 3324
    COMMAND   PID    USER   FD   TYPE DEVICE    SIZE    NODE NAME
    Xorg    3324 root    0w   REG        8,6   56296      12492 /var/log/Xorg.0.log
    
Sobre um único arquivo:
# lsof /var/log/Xorg.0.log
    COMMAND  PID USER   FD   TYPE DEVICE  SIZE  NODE NAME
    Xorg    3324 root    0w   REG    8,6 56296 12492 /var/log/Xorg.0.log
    

Monta/remonta um sistema de arquivo

Por exemplo o cdrom. Se listado em /etc/fstab:
# mount /cdrom
Ou encontre o dispositivo em /dev/ ou com o dmesg

FreeBSD

# mount -v -t cd9660 /dev/cd0c /mnt  # cdrom
    # mount_cd9660 /dev/wcd0c /cdrom     # outro método
    # mount -v -t msdos /dev/fd0c /mnt   # floppy
    
Entrada em /etc/fstab:
# Device                Mountpoint      FStype  Options         Dump    Pass#
    /dev/acd0               /cdrom          cd9660  ro,noauto       0       0
    
Para deixar os usuários fazerem isso:
# sysctl vfs.usermount=1  # Ou insira a linha "vfs.usermount=1" in /etc/sysctl.conf
    

Linux

# mount -t auto /dev/cdrom /mnt/cdrom   # comando mount típico do para cdrom
    # mount /dev/hdc -t iso9660 -r /cdrom   # IDE típico
    # mount /dev/scd0 -t iso9660 -r /cdrom  # cdrom SCSI típico
    # mount /dev/sdc0 -t ntfs-3g /windows   # SCSI típico
    
Entrada em /etc/fstab:
/dev/cdrom   /media/cdrom  subfs noauto,fs=cdfss,ro,procuid,nosuid,nodev,exec 0 0

Montar uma partição FreeBSD com o Linux

Encontre o número da partição com o fdisk, essa é normalmente a partição root, mas pode ser uma outra outra fatia de BSD também. Se o FreeBSD tiver muitas fatias, elas são as não listadas na tabela do fdisk, mas visíveis em /dev/sda* ou /dev/hda*.
# fdisk /dev/sda                     # Encontre a partição FreeBSD
    /dev/sda3   *        5357        7905    20474842+  a5  FreeBSD
    # mount -t ufs -o ufstype=ufs2,ro /dev/sda3 /mnt
    /dev/sda10 = /tmp; /dev/sda11 /usr   # As outras fatias
    

Remontar

Remontar um dispositivo sem remontá-lo. Necessário para o fsck
# mount -o remount,ro /              # Linux
    # mount -o ro -u /                   # FreeBSD
    
Copiar o arquivo bruto a partir de um cdrom dentro de uma imagem ISO (tamanho de blocos padrão de 512 podem causar problemas):
# dd if=/dev/cd0c of=file.iso bs=2048

Virtualbox

Permite um compartilhamento no host:
# VBoxManage sharedfolder add "GuestName" --name "share" --hostpath "C:\hostshare"
Montar compartilhamento no guest (convidado) (linux, FreeBSD)
# sudo mount -t vboxsf share /home/vboxshare # -o uid=1000,gid=1000 (as appropriate)
    share /home/colin/share vboxsf defaults,uid=colin 0 0 # fstab entry
    

OSX

# diskutil list                      # Lista as partições de um disco
    # diskutil unmountDisk /dev/disk1    # Desmonta um disco inteiro (todos os volumes)
    # chflags hidden ~/Documents/folder  # Enconde pastas (diretórios) (reverta com o unhidden)
    

Adicionar swap com o sistema em pleno uso (on-the-fly)

Suponhamos que você precise de mais swap (agora mesmo), diga um arquivo de 2GB /swap2gb (somente em Linux).
# dd if=/dev/zero of=/swap2gb bs=1024k count=2000
    # mkswap /swap2gb                    # cria a área de swap
    # swapon /swap2gb                    # ativa a SWAP. Isso agora em uso
    # swapoff /swap2gb                   # Quando feito desative a swap
    # rm /swap2gb
    

Montar um compartilhamento SMB

Suponhamos que queremos acessar compartilhamento SMB myshare no computador smbserver, o endereço como digitado em um PC Windows PC é \\smbserver\myshare\. Nós montamos no /mnt/smbshare. Warning> cifs wants an IP or DNS name, not a Windows name.

Linux/OSX

# smbclient -U user -I 192.168.16.229 -L //smbshare/    # Lista os compartilhamentos
    # mount -t smbfs -o username=winuser //smbserver/myshare /mnt/smbshare
    # mount -t cifs -o username=winuser,password=winpwd //192.168.16.229/myshare /mnt/share
    
Montar o compartilhamento Samba através de um túnel sshl
# ssh -C -f -N -p 20022 -L 445:127.0.0.1:445 me@server  # connect on 20022, tunnel 445
    # mount -t smbfs //colin@localhost/colin ~/mnt
    # mount_smbfs //colin:mypassword@127.0.0.1/private /Volumes/private # I use this on OSX + ssh
    
Adicionalmente com o pacote mount.cifs é possível armazenar as credenciais em um arquivo, por exemplo /home/user/.smb:
username=winuser
    password=winpwd
    
E monte como a seguir:
# mount -t cifs -o credentials=/home/user/.smb //192.168.16.229/myshare /mnt/smbshare

FreeBSD

Utilize -I para dar o IP (ou DNS name); smbserver é o nome Windows.
# smbutil view -I 192.168.16.229 //winuser@smbserver    # Liste os compartilhamentos
    # mount_smbfs -I 192.168.16.229 //winuser@smbserver/myshare /mnt/smbshare
    

Montar uma imagem

# hdiutil mount image.iso                               # OS X

Linux loop-back

# mount -t iso9660 -o loop file.iso /mnt                # Monte uma imagem de CD
    # mount -t ext3 -o loop file.img /mnt                   # Monte uma imagem com o sistema de arquivos ext3
    

FreeBSD

Com dispositivo de memória (faça # kldload md.ko se necessário):
# mdconfig -a -t vnode -f file.iso -u 0
    # mount -t cd9660 /dev/md0 /mnt
    # umount /mnt; mdconfig -d -u 0                         # Limpa o dispositivo md
    
Ou como node virtual:
# vnconfig /dev/vn0c file.iso; mount -t cd9660 /dev/vn0c /mnt
    # umount /mnt; vnconfig -u /dev/vn0c                    # Limpa o dispositivo vn
    

Solaris e FreeBSD

Com interface de arquivo loop-back ou lofi:
# lofiadm -a file.iso
    # mount -F hsfs -o ro /dev/lofi/1 /mnt
    # umount /mnt; lofiadm -d /dev/lofi/1                   # Limpa o dispositivo lofi
    

Criar e queimar uma imagem ISO

Isso copiar o cd ou DVD setor por setor. Sem conv=notrunc, a imagem será pequena se há menos conteúdo no cd. Veja abaixo os exemplos dd.
# dd if=/dev/hdc of=/tmp/mycd.iso bs=2048 conv=notrunc
Utilize mkisofs para criar uma imagem de CD/DVD image a partir de um diretório. Para superar as restrições de nomes de arquivos: -r habilita as extensões comuns Rock Ridge para sistemas UNIX, -J abilita extenções Joliet utilizada pelos sistemas Microsoft. -L permite nomes de arquivos ISO9660 iniciar com um período.
# mkisofs -J -L -r -V TITLE -o imagefile.iso /path/to/dir
    # hdiutil makehybrid -iso -joliet -o dir.iso dir/       # OS X
No FreeBSD, mkisofs é encontrato no ports em sysutils/cdrtools.

Queimar uma imagem de CD/DVD ISO

FreeBSD

FreeBSD não abilita a DMA nos drivers ATAPI por padrão. A DMA é habilitada com o comando sysctl e os argumentos abaixo, ou com /boot/loader.conf com as seguintes entradas:
hw.ata.ata_dma="1"
    hw.ata.atapi_dma="1"
    
Utilize burncd com um dispositivo ATAPI (burncd é parte do base system) e cdrecord (em sysutils/cdrtools) com um drive SCSI.
# burncd -f /dev/acd0 data imagefile.iso fixate      #Para drive ATAPI
    # cdrecord -scanbus                  # Para encontrar o dispositivo gravador (como 1,0,0)
    # cdrecord dev=1,0,0 imagefile.iso
    

Linux

Também utiliza cdrecord com Linux como descrito acima. Adicionalmente é possível utilizar a interface ATAPI nativa que é encontrada com:
# cdrecord dev=ATAPI -scanbus
e queime o CD/DVD como acima.

dvd+rw-tools

O pacote dvd+rw-tools (FreeBSD: ports/sysutils/dvd+rw-tools) pode fazer tudo isso e inclui growisofs para queimar CDs ou DVDs. Os exemplos referem-se ao dispositivo de dvd como /dev/dvd que podia ser um symlink para /dev/scd0 (scsi típico no Linux) ou /dev/cd0 (FreeBSD típico) ou /dev/rcd0c (SCSI de carácter típico do NetBSD/OpenBSD) ou /dev/rdsk/c0t1d0s2 (exemplo de uma dispositivo de caracter CD-ROM SCSI/ATAPI do Solaris). Há uma documentação boa com exemplos no FreeBSD handbook capítulo 18.7http://www.freebsd.org/handbook/creating-dvds.html.
                       # -dvd-compat closes the disk
    # growisofs -dvd-compat -Z /dev/dvd=imagefile.iso     # Queima imagem ISO existente
    # growisofs -dvd-compat -Z /dev/dvd -J -R /p/to/data  # Queima diretamente
    

Converter um arquivo Nero .nrg para .iso

O Nero simplesmente adicionas um cabeçalho de 300 Kb em uma imagem ISO normal. Isso pode ser aparado com o dd.
# dd bs=1k if=imagefile.nrg of=imagefile.iso skip=300

Converter uma imagem bin/cue para .iso

O título bchunk programhttp://freshmeat.net/projects/bchunk/ pode fazer isso. Ele está no ports do FreeBSD em sysutils/bchunk.
# bchunk imagefile.bin imagefile.cue imagefile.iso
    

Criar uma imagem basada em arquivo

Por exemplo uma partição de 1 GB utilizando o arquivo /usr/vdisk.img. Aqui no utilizamos o vnode 0, mas podia ser também 1.

FreeBSD

# dd if=/dev/random of=/usr/vdisk.img bs=1K count=1M
    # mdconfig -a -t vnode -f /usr/vdisk.img -u 0         # Cria o dispositivo /dev/md1
    # bsdlabel -w /dev/md0
    # newfs /dev/md0c
    # mount /dev/md0c /mnt
    # umount /mnt; mdconfig -d -u 0; rm /usr/vdisk.img    # Limpa o dispositivo md
    
A imagem baseada em arquivo pode ser automaticamente montada durante o boot com uma entrada em /etc/rc.conf e /etc/fstab. Teste sua configuração com o # /etc/rc.d/mdconfig start (primeiro exclua o dispositivo md0 com o # mdconfig -d -u 0).
Note no entanto que essa configuração automática só funcionará se a imagem de arquivo não estiver na partição root. A rasão é o script /etc/rc.d/mdconfig é executado durante o boot e a partição root ainda está em somente leitura (read-only). Imagens localizadas fora da partição root serão montadas mounted mais tarde com o script /etc/rc.d/mdconfig2.
/boot/loader.conf:
md_load="YES"
/etc/rc.conf:
# mdconfig_md0="-t vnode -f /usr/vdisk.img"          # /usr não está na partição root
/etc/fstab: (O 0 0 no final é importante, Isso diz ao fsck que ignore esse dispositivo, como ainda não exite)
/dev/md0                /usr/vdisk      ufs     rw              0       0
Também é possível aumentar o tamanho da imagem depois, digamos por exemplo 300 MB maior.
# umount /mnt; mdconfig -d -u 0
    # dd if=/dev/zero bs=1m count=300 >> /usr/vdisk.img
    # mdconfig -a -t vnode -f /usr/vdisk.img -u 0
    # growfs /dev/md0
    # mount /dev/md0c /mnt                                # Partição do arqiuvo é agora 300 MB maior
    

Linux

# dd if=/dev/zero of=/usr/vdisk.img bs=1024k count=1024
    # mkfs.ext3 /usr/vdisk.img
    # mount -o loop /usr/vdisk.img /mnt
    # umount /mnt; rm /usr/vdisk.img                      # Limpa
    

Linux com o losetup

/dev/zero é muito mais rapido do que o urandom, mas menos seguro para criptografia.
# dd if=/dev/urandom of=/usr/vdisk.img bs=1024k count=1024
    # losetup /dev/loop0 /usr/vdisk.img                   # Cria e associa /dev/loop0
    # mkfs.ext3 /dev/loop0
    # mount /dev/loop0 /mnt
    # losetup -a                                          # Verificar loops utilizados
    # umount /mnt
    # losetup -d /dev/loop0                               # Destaca
    # rm /usr/vdisk.img
    

Criar um sistema de arquivo de memória

Um sistema de arquivo baseado em memória é muito rápido para aplicações de entrada e saída (IO). Como criar uma partição de 64 MB montada em /memdisk:

FreeBSD

# mount_mfs -o rw -s 64M md /memdisk
    # umount /memdisk; mdconfig -d -u 0                   # Limpa o dispositivo md
    md     /memdisk     mfs     rw,-s64M    0   0         # /etc/fstab entrada
    

Linux

# mount -t tmpfs -osize=64m tmpfs /memdisk
    

Desempenho de disco

Lê e escreve um arquivo de 1 GB na partição (/home)
# time dd if=/dev/ad4s3c of=/dev/null bs=1024k count=1000
    # time dd if=/dev/zero bs=1024k count=1000 of=/home/1Gb.file
    # hdparm -tT /dev/hda      # Somente em Linux
    

Rede

Rotear | IP adicional | Alterar MAC | Portas | Firewall | IP Forward | NAT | DNS | DHCP | Traffic | QoS | NIS | Netcat

Debugging (Veja também Análise de tráfego)

Linux

# ethtool eth0              # Exibe o status da  ethernet (subsitui mii-diag)
    # ethtool -s eth0 speed 100 duplex full # Força o Full duplex de 100Mbit
    # ethtool -s eth0 autoneg off # Desabilita negociação automática ( auto negotiation)
    # ethtool -p eth1           # Pisca o led de ethernet - muito útil quando suportado
    # ip link show              # Exibe todas as interfaces no Linux (similar ao ifconfig)
    # ip link set eth0 up       # Traz o dispositivo ao funcionamento (ou derruba-o). O mesmo que "ifconfig eth0 up"
    # ip addr show              # Exibe todos os endereços de IP no Linux (similar ao ifconfig)
    # ip neigh show             # Similar ao arp -a
    

Outros OSes

# ifconfig fxp0             # Verifica o campo "media" no FreeBSD
    # arp -a                    # Verifica a entrada ARP do roteador (ou host) (todos os OS)
    # ping cb.vu                # A primeira coisa a testar...
    # traceroute cb.vu          # Imprime o caminho do roteador para o destino
    # ifconfig fxp0 media 100baseTX mediaopt full-duplex # 100 Mbit full duplex (FreeBSD)
    # netstat -s                # Estatisticas do System-wide para cada protocolo de rede
    
Comandos adicionais que não são sempre instalados por padrão, mas fáceis de encontrar:
# arping 192.168.16.254     # Ping na camada Ethernet
    # tcptraceroute -f 5 cb.vu  # utiliza o TCP ao invés do icmp para traçar pelos firewalls
    

Rotear

Imprimir tabela de roteamento

# route -n                  # Linux ou utilize o "ip route"
    # netstat -rn               # Linux, BSD e UNIX
    # route print               # Windows
    

Adicionar e excluir uma rota

FreeBSD

# route add 212.117.0.0/16 192.168.1.1
    # route delete 212.117.0.0/16
    # route add default 192.168.1.1
    
Adiciona rota permanentemente em in /etc/rc.conf
static_routes="myroute"
    route_myroute="-net 212.117.0.0/16 192.168.1.1"
    

Linux

# route add -net 192.168.20.0 netmask 255.255.255.0 gw 192.168.16.254
    # ip route add 192.168.20.0/24 via 192.168.16.254       # o mesmo que acima com o ip route
    # route add -net 192.168.20.0 netmask 255.255.255.0 dev eth0
    # route add default gw 192.168.51.254
    # ip route add default via 192.168.51.254 dev eth0      # o mesmo que acima com o ip route
    # route delete -net 192.168.20.0 netmask 255.255.255.0
    

Solaris

# route add -net 192.168.20.0 -netmask 255.255.255.0 192.168.16.254
    # route add default 192.168.51.254 1                    # 1 = salta para o próximo gateway
    # route change default 192.168.50.254 1
    
Entradas permanentes são configuradas na entrada em /etc/defaultrouter.

Windows

# Route add 192.168.50.0 mask 255.255.255.0 192.168.51.253
    # Route add 0.0.0.0 mask 0.0.0.0 192.168.51.254
Utilize add -p para tornar a rota persistente.

Configurar endereços de IP adicionais

Linux

# ifconfig eth0 192.168.50.254 netmask 255.255.255.0       # Primeiro IP
    # ifconfig eth0:0 192.168.51.254 netmask 255.255.255.0     # Segundo IP
    # ip addr add 192.168.50.254/24 dev eth0                   # Comandos de ip equivalentes
    # ip addr add 192.168.51.254/24 dev eth0 label eth0:1
    

FreeBSD

# ifconfig fxp0 inet 192.168.50.254/24                     # Primeiro IP
    # ifconfig fxp0 alias 192.168.51.254 netmask 255.255.255.0 # Segundo IP
    # ifconfig fxp0 -alias 192.168.51.254                      # Remove o apelido do segundo IP
    
Entradas permanentes em /etc/rc.conf
ifconfig_fxp0="inet 192.168.50.254  netmask 255.255.255.0"
    ifconfig_fxp0_alias0="192.168.51.254 netmask 255.255.255.0"
    

Solaris

Verifica as configurações com o ifconfig -a
# ifconfig hme0 plumb                                      # Habilita a placa de rede
    # ifconfig hme0 192.168.50.254 netmask 255.255.255.0 up    # Primeiro IP
    # ifconfig hme0:1 192.168.51.254 netmask 255.255.255.0 up  # Segundo IP
    

Altera o MAC address

Normalmente tem se que derrubar a interface antes da alteração. Não me diga o por que você quer deseja alterar o endereço de máquina (MAC address)...
# ifconfig eth0 down
    # ifconfig eth0 hw ether 00:01:02:03:04:05      # Linux
    # ifconfig fxp0 link 00:01:02:03:04:05          # FreeBSD
    # ifconfig hme0 ether 00:01:02:03:04:05         # Solaris
    # sudo ifconfig en0 ether 00:01:02:03:04:05     # OS X Tiger, Snow Leopard LAN*
    # sudo ifconfig en0 lladdr 00:01:02:03:04:05    # OS X Leopard
    
*Interface de rede sem fio típica é en1 e precisa desassociar do qualquer rede primeiro (osxdaily howto).
# echo "alias airport='/System/Library/PrivateFrameworks/Apple80211.framework/Versions/Current/Resources/airport'"\
    >> ~/.bash_profile         # ou symlink para /usr/sbin
    # airport -z               # Desassocia das redes sem fio
    # airport -I               # Obter informação da rede sem fio
Muitas ferramentas existem para Windows. Por exemplo etherchangehttp://ntsecurity.nu/toolbox/etherchange. Ou procure por "Mac Makeup", "smac".

Portas em uso

Escutar portas abertas:
# netstat -an | grep LISTEN
    # lsof -i                  # Lista todas as conexões com a internet no Linux
    # socklist                 # Exibe lista de sockets abertos no Linux
    # sockstat -4              # Lista aplicações no FreeBSD
    # netstat -anp --udp --tcp | grep LISTEN        # Linux
    # netstat -tup             # Lista conexões activas para/a partir do sistema (Linux)
    # netstat -tupl            # Lista portas que estão sendo escutadas a artir do sistema (Linux)
    # netstat -ano             # Windows
    

Firewall

Verificar se um firewall está rodando (somente a configuração típica):

Linux

# iptables -L -n -v                  # Para status
    Open the iptables firewall
    # iptables -P INPUT       ACCEPT     # Abre tudo
    # iptables -P FORWARD     ACCEPT
    # iptables -P OUTPUT      ACCEPT
    # iptables -Z                        # Zera o pacote e os contadores de byte em todas as conrrentes
    # iptables -F                        # Nivelar todas as correntes
    # iptables -X                        # Exclui todas as correntes
    

FreeBSD

# ipfw show                          # para status
    # ipfw list 65535 # se a resposta for "65535 deny ip from any to any" o fw está desabilitado
    # sysctl net.inet.ip.fw.enable=0     # Desabilita
    # sysctl net.inet.ip.fw.enable=1     # habilita
    

Direcionamento de IP para roteamento

Linux

Verificar e então habilitar o direcionamento de IP com:
# cat /proc/sys/net/ipv4/ip_forward  # Verifica o direcionamento de IP 0=off, 1=on
    # echo 1 > /proc/sys/net/ipv4/ip_forward
    
ou editar /etc/sysctl.conf com:
net.ipv4.ip_forward = 1

FreeBSD

Verifique e habilite com:
# sysctl net.inet.ip.forwarding      # Verifica o direcionamento de IP 0=off, 1=on
    # sysctl net.inet.ip.forwarding=1
    # sysctl net.inet.ip.fastforwarding=1	# Para roteador ou firewall dedicado
    Permanent with entry in /etc/rc.conf:
    gateway_enable="YES"                 # Define para YES se esse host vai ser um gateway.
    

Solaris

# ndd -set /dev/ip ip_forwarding 1   # Define o direcionamento do IP 0=off, 1=on
    

NAT Network Address Translation (Tradução de Endereço de Rede)

Linux

# iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE	# para ativar o NAT
    # iptables -t nat -A PREROUTING -p tcp -d 78.31.70.238 --dport 20022 -j DNAT \
    --to 192.168.16.44:22           # Direcionamento de porta 20022 para porta ssh de IP interno
    # iptables -t nat -A PREROUTING -p tcp -d 78.31.70.238 --dport 993:995 -j DNAT \
    --to 192.168.16.254:993-995     # Direcionamento de porta com alcance (range) entre 993-995
    # ip route flush cache
    # iptables -L -t nat            # Verifica status do NAT
    
Exclui o direcionamento de porta com o -D ao invés do -A. O programa netstat-nathttp://tweegy.nl/projects/netstat-nat é muito útil para rastrear conexões (ele utiliza /proc/net/ip_conntrack ou /proc/net/nf_conntrack).
# netstat-nat -n                # Exibe todas as conexões com IPs

FreeBSD

# natd -s -m -u -dynamic -f /etc/natd.conf -n fxp0
    Or edit /etc/rc.conf with:
    firewall_enable="YES"           # Define para YES para habilitar a funcionalidade do firewall
    firewall_type="open"            # Tipo de Firewall (veja /etc/rc.firewall)
    natd_enable="YES"               # Habilita natd (se firewall_enable == YES).
    natd_interface="tun0"           # Interface pública ou endereço de IP para utilizar.
    natd_flags="-s -m -u -dynamic -f /etc/natd.conf"
    
Port forward with:
# cat /etc/natd.conf
    same_ports yes
    use_sockets yes
    unregistered_only
    # redirect_port tcp insideIP:2300-2399 3300-3399  # rangde de porta
    redirect_port udp 192.168.51.103:7777 7777
    

DNS

Em Unix as entradas de DNS são válidas para todas as interfaces e são armazenadas em /etc/resolv.conf. O domínio para a qual o host pertence também está armazenado nesse arquivo. Uma configuração mínima é:
nameserver 78.31.70.238
    search sleepyowl.net intern.lab
    domain sleepyowl.net
    
Verificar o nome do domínio com:
# hostname -d                        # O mesmo que dnsdomainname

Windows

No Windows os DNS estão configurados por interface. Para exibir os DNS configurados e para limpar (flush) o cache de DNS utilize:
# ipconfig /?                        # Exibir ajuda
    # ipconfig /all                      # Veja todas as informações incluindo DNS
    

Flush DNS

Limpar (flush) o cache de DNS do sistema operacional, algumas aplicações utilizando seu próprio cache (ex. Firefox) e não serão afetados.
# /etc/init.d/nscd restart           # Reiniciar nscd se utilizado - Linux/BSD/Solaris
    # lookupd -flushcache                # OS X Tiger
    # dscacheutil -flushcache            # OS X Leopard e mais recentes
    # ipconfig /flushdns                 # Windows
    

Consulta de direcionamento

Dig é seu amigo nos testest de configurações de DNS. Por exemplo o servidor de DNS público 213.133.105.2 ns.second-ns.de pode ser utilizado para teste. Veja de qual servidor o cliente recebe a resposta (resposta simplificada).
# dig sleepyowl.net
    sleepyowl.net.          600     IN      A       78.31.70.238
    ;; SERVER: 192.168.51.254#53(192.168.51.254)
    
O roteadr 192.168.51.254 respondeu e a resposta é a entrada A. Qualquer entrada pode ser consultada e o servidor DNS pode ser selecionado com @:
# dig MX google.com
    # dig @127.0.0.1 NS sun.com          # Para testar o servidor local
    # dig @204.97.212.10 NS MX heise.de  # Consulta um servidor externo
    # dig AXFR @ns1.xname.org cb.vu      # Obtém a zona completa (zone transfer)
    
O programa host também é poderoso.
# host -t MX cb.vu                   # obtém a entrada do mail MX
    # host -t NS -T sun.com              # Obtém registro de NS sobre uma conexão TCP
    # host -a sleepyowl.net              # Obter tudo
    

Reverter consultas

Encontre um nome pertencente á um endereço de IP (in-addr.arpa.). Isso pode ser feito com dig, host e nslookup:
# dig -x 78.31.70.238
    # host 78.31.70.238
    # nslookup 78.31.70.238
    

/etc/hosts

Hosts únicos pode ser configurados no arquivo /etc/hosts ao invés de rodar named localmente para resolver as consultas de hostname. o formato é simples, por exemplo:
78.31.70.238   sleepyowl.net   sleepyowl
A prioridade entre hosts e uma consulta de dns, que é a ordem de resolução de nome, pode ser configurada em /etc/nsswitch.conf AND /etc/host.conf. O arquvo também existe no Windows, normalmente está em:
C:\WINDOWS\SYSTEM32\DRIVERS\ETC

DHCP

Linux

Algumas distribuições (SuSE) utilizam dhcpcd como cliente. a interface padrão é eth0.
# dhcpcd -n eth0           # Renova (nem sempre funciona)
    # dhcpcd -k eth0           # libera e derruba
    
O lease com a informação completa está armazenada em:
/var/lib/dhcpcd/dhcpcd-eth0.info

FreeBSD

FreeBSD (e Debian) utiliza o dhclient. Para configurar uma interface (por exemplo bge0) rode:
# dhclient bge0
O lease com a informação completa está armazenada em:
/var/db/dhclient.leases.bge0
Utilize
/etc/dhclient.conf
to preceder opções ou forçar opções diferentes:
# cat /etc/dhclient.conf
    interface "rl0" {
        prepend domain-name-servers 127.0.0.1;
        default domain-name "sleepyowl.net";
        supersede domain-name "sleepyowl.net";
    }
    

Windows

O dhcp lease pode ser renovado com ipconfig:
# ipconfig /renew          # renova todos os adaptadores
    # ipconfig /renew LAN      # renova o adaptador nomeado "LAN"
    # ipconfig /release WLAN   # libera o adaptador nomeado "WLAN"
    
Sim é uma boa idea nomear seus adaptadores com nomes simples!

Análise de tráfego

Bmonhttp://people.suug.ch/~tgr/bmon/ é um pequeno console monitor de largura de banda e pode exibir o fluxo nas diferentes interfaces.

Sniff com tcpdump

# tcpdump -nl -i bge0 not port ssh and src \(192.168.16.121 or 192.168.16.54\)
    # tcpdump -n -i eth1 net 192.168.16.121           # seleciona para/de um único IP
    # tcpdump -n -i eth1 net 192.168.16.0/24          # seleciona tráfego para/de uma rede
    # tcpdump -l > dump && tail -f dump               # Saída em Buffer
    # tcpdump -i rl0 -w traffic.rl0                   # Escreve cabeçalho tráfego em arquivo binário
    # tcpdump -i rl0 -s 0 -w traffic.rl0              # Escrever tráfego + payload em arquivo binário
    # tcpdump -r traffic.rl0                          # Lê a partir do arquivo (também para ethereal
    # tcpdump port 80                                 # Os dois comandos clássicos
    # tcpdump host google.com
    # tcpdump -i eth0 -X port \(110 or 143\)          # Verifica se pop ou imap é seguro
    # tcpdump -n -i eth0 icmp                         # Somente captura pings
    # tcpdump -i eth0 -s 0 -A port 80 | grep GET      # -s 0 para total de pacotes -A para ASCII
    
Opções adicionais importação: No Windows usa windump a partir www.winpcap.org. Use o windump -D para listar as interfaces.

Scan com nmap

Nmaphttp://insecure.org/nmap/ é scanner de portas com detecção do OS, é normalmente instalado em muitas distribuições e também está disponível para. Se você não scanear seu servidor, hackers (nota do tradutor: black hats no caso, e não white hats) fazem isso por você...
# nmap cb.vu               # scanea todas as portas TCP reservadas no host
    # nmap -sP 192.168.16.0/24 # Descobre quais IP são utilizados e por qual host no 0/24
    # nmap -sS -sV -O cb.vu    # Faz um stealth SYN scan com versão e detecção de OS
    PORT      STATE  SERVICE             VERSION
    22/tcp    open   ssh                 OpenSSH 3.8.1p1 FreeBSD-20060930 (protocol 2.0)
    25/tcp    open   smtp                Sendmail smtpd 8.13.6/8.13.6
    80/tcp    open   http                Apache httpd 2.0.59 ((FreeBSD) DAV/2 PHP/4.
    [...]
    Running: FreeBSD 5.X
    Uptime 33.120 days (since Fri Aug 31 11:41:04 2007)
    
Outras não padrões, mas ferramentas utei são hping (www.hping.org) um analizador/assembler (juntador) de pacotes IP e fping (fping.sourceforge.net). fping pode verificar múltiplos hosts em um estilo round-robin.

Controle de Tráfego (QoS)

Controle de Tráfego gerencia a fila, policiamento, rotina, e outros parâmetros de tráfego para uma rede. Os exemplos a seguir são compatibilidades de usos práticos e simples do Linux e do FreeBSD para melhor uso da largura de banda disponível.

Limit upload

Modens DSL ou cabeados tem uma longa fila para melhorar o rendimento de upload. No entanto encher a fila com um dispositivo rápido (ex. ethernet) diminuirá dramaticamente a interatividade. É logo, util para limitar a taxa de upload do dispositivo para igualar a capacidade do modem, Isso deve melhorar grandemente a interatividade. Define em torno da máxima de 90% da velocidade do modem (cabo).

Linux

Para upload em um modem de 512 Kbit.
# tc qdisc add dev eth0 root tbf rate 480kbit latency 50ms burst 1540
    # tc -s qdisc ls dev eth0                         # Status
    # tc qdisc del dev eth0 root                      # Exclui a fila
    # tc qdisc change dev eth0 root tbf rate 220kbit latency 50ms burst 1540
    

FreeBSD

FreeBSD utiliza o dummynet modelador de tráfego que é configurado com o ipfw. Pipes são utilizados para definir os limites da largura de banda em unidades de [K|M]{bit/s|Byte/s}, 0 significa largura de banda ilimitada. Utilizando o mesmo número pipe configurá-lo. Por exemplo, limitar a largura de banda de upload para 500 Kbit.
    # kldload dummynet                                # carrega o módulo se necessário
    # ipfw pipe 1 config bw 500Kbit/s                 # cria um pipe com a largura de banda limitada
    # ipfw add pipe 1 ip from me to any               # desvia o upload total para dentro do pipe
    

Qualidade de serviço

Linux

Fila de prioridade com o tc para otimizar o VoIP. Veja o exemplo todo em voip-info.org ou www.howtoforge.com. Suponhamos que o VoIP utiliza udp nas portas 10000:11024 e o dispositivo eth0 (poderia ser também ppp0 ou outro). Os comandos a seguir definem o QoS para três filas e força o VoIP a trafegar para a fila 1com o QoS 0x1e (todos os bits definidos). A configuração padrão flui dentro da fila 3 e o QoS Minimize-Delay flui na fila 2.
# tc qdisc add dev eth0 root handle 1: prio priomap 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 0
    # tc qdisc add dev eth0 parent 1:1 handle 10: sfq
    # tc qdisc add dev eth0 parent 1:2 handle 20: sfq
    # tc qdisc add dev eth0 parent 1:3 handle 30: sfq
    # tc filter add dev eth0 protocol ip parent 1: prio 1 u32 \
      match ip dport 10000 0x3C00 flowid 1:1          # utiliza o range de porta do servidor
      match ip dst 123.23.0.1 flowid 1:1              # ou/e utiliza o IP do servidor
    
Status e remover com
# tc -s qdisc ls dev eth0                         # status de fila
    # tc qdisc del dev eth0 root                      # exclui todo o QoS
    

Calcular range de porta e mascara

O tc filter define o range da porta com porta e mascara que você tem que calcular. Encontre o 2^N ending do range da porta, deduza o range e converta para HEX. Essa é a sua máscara. Exemplo para for 10000 -> 11024, o range é 1024.
# 2^13 (8192) < 10000 < 2^14 (16384)              # Final é 2^14 = 16384
    # echo "obase=16;(2^14)-1024" | bc                # mascara é 0x3C00
    

FreeBSD

O link máximo de largura de banda é de 500 Kbit/s e definimos 3 filas com prioridade 100:10:1 para VoIP:ssh:all the rest.
# ipfw pipe 1 config bw 500Kbit/s
    # ipfw queue 1 config pipe 1 weight 100
    # ipfw queue 2 config pipe 1 weight 10
    # ipfw queue 3 config pipe 1 weight 1
    # ipfw add 10 queue 1 proto udp dst-port 10000-11024
    # ipfw add 11 queue 1 proto udp dst-ip 123.23.0.1 # ou/e utiliza IP do seridor
    # ipfw add 20 queue 2 dsp-port ssh
    # ipfw add 30 queue 3 from me to any              # todo o resto
    
Status e remover com
# ipfw list                                       # status de regras
    # ipfw pipe list                                  # status do pipe
    # ipfw flush                                      # exclui todas as regras, menos a padrão
    

Debugar o NIS

Algums comando que dever funcionar em um cliente NIS bem configurado:
# ypwhich                  # obtém o nome do servidor NIS conectado
    # domainname               # O nome do domínio NIS como está configurado
    # ypcat group              # deve exibir o grupo a partir do servidor NIS
    # cd /var/yp && make       # Reconstrói a base de dados do yp
    # rpcinfo -p servername    # Reporta os serviços RPC do servidor
    
O ypbind está rodando?
# ps auxww | grep ypbind
    /usr/sbin/ypbind -s -m -S servername1,servername2	# FreeBSD
    /usr/sbin/ypbind           # Linux
    # yppoll passwd.byname
    Map passwd.byname has order number 1190635041. Mon Sep 24 13:57:21 2007
    The master server is servername.domain.net.
    

Linux

# cat /etc/yp.conf
    ypserver servername
    domain domain.net broadcast
    

Netcat

Netcathttp://netcat.sourceforge.net (nc) é melhor conhecido como o "Canivete Suíço de Rede", ele pode manipular, criar ou ler/escrever conexões TCP/IP. Aqui alguns exemplos uteis, há muitos mais na net, por exemplo g-loaded.eu[...]http://www.g-loaded.eu/2006/11/06/netcat-a-couple-of-useful-examples e aquihttp://www.terminally-incoherent.com/blog/2007/08/07/few-useful-netcat-tricks.
Você pode precisar usar o comando netcat ao inves do nc. Veja também o comando similar socat.

Transferência de arquivo

Copia um diretório grande através de uma conexão tcp bruta. A transferência é bem rápida (sem sobrecarga de protocolo) e você não precisa bagunçar com NFS ou SMB ou FTP ou outros, simplesmente torne o arquivo disponível no servidor, e ser obtido a partir do cliente. Aqui 192.168.1.1 é o endereço de Ip do servidor.
server# tar -cf - -C VIDEO_TS . | nc -l -p 4444         # Serve o arquivo tar na porta 4444
    client# nc 192.168.1.1 4444 | tar xpf - -C VIDEO_TS     # Puxa o arquivo na porta 4444
    server# cat largefile | nc -l 5678                      # Serve um único arquivo
    client# nc 192.168.1.1 5678 > largefile                 # Puxa um único arquivo
    server# dd if=/dev/da0 | nc -l 4444                     # Imagem da partição do servidor
    client# nc 192.168.1.1 4444 | dd of=/dev/da0            # Puxa partição para clonagem
    client# nc 192.168.1.1 4444 | dd of=da0.img             # Puxa partição para o arquivo
    

Outras hacks

Especialmente aqui, você deve saber o que está fazendo.

Shell Remoto

Opção -e somente na versão do Windows? Ou utilize nc 1.10.
# nc -lp 4444 -e /bin/bash                        # Provê um shell remoto (backdoor de servidor)
    # nc -lp 4444 -e cmd.exe                          # shell remoto para Windows
    

Servidor web de emergência

Serve um único arquivo na 80 em um laço (loop).
# while true; do nc -l -p 80 < unixtoolbox.xhtml; done
    

Chat

Alice e Bob podem bater-papo (chat) sobre um simples socket TCP. O texto é transferido com a tecla enter.
alice# nc -lp 4444
    bob  # nc 192.168.1.1 4444
    

SSH SCP

Chave pública | Fingerprint | SCP | Tunelamento

Veja outros truques 25 ssh cmdhttp://blog.urfix.com/25-ssh-commands-tricks/

Autenticação de chave pública

Connecte com um host sem senha utilizando autenticação com chave pública. A ideia é anexar sua chave pública ao arquivo authorized_keys2 no host remoto. Para esse exemplo vamos conectar o host-client ao host-server, a chave é gerada no cliente. Com o cygwin você pode ter que criar seu diretório home e o diretório .ssh com# mkdir -p /home/USER/.ssh
# ssh-keygen -t dsa -N ''
    # cat ~/.ssh/id_dsa.pub | ssh you@host-server "cat - >> ~/.ssh/authorized_keys2"
    

Utilizando o cliente Windows a partir do ssh.com

A versão não comercial do cliente ssh.com pode ser baixado do ftp principal: ftp.ssh.com/pub/ssh/. As chaves geradas pelo cliente ssh.com precisam ser convertidas pelo servidor OpenSSH. Isso pode ser feito com o comando ssh-keygen. Nota: Utilizamos uam chave DSA, RSA também é possível. A chave não é protegida por uma senha.

Utilizar o putty para o Windows

Puttyhttp://www.chiark.greenend.org.uk/~sgtatham/putty/download.html é um cliente ssh simples e livre para Windows.

Verificar fingerprint

No primeiro login, ssh perguntará se o host desconhecido com a impressão digital (fingerprint) tem que ser armazenado nos hosts conhecidos. Para evitar um ataque man-in-the-middle, o administrador do servidor pode te enviar o fingerprint do servidor que é então comparado no primeiro login. Utilize ssh-keygen -l para obter a fingerprint (no servidor):
# ssh-keygen -l -f /etc/ssh/ssh_host_rsa_key.pub      # Para chave RSA
    2048 61:33:be:9b:ae:6c:36:31:fd:83:98:b7:99:2d:9f:cd /etc/ssh/ssh_host_rsa_key.pub
    # ssh-keygen -l -f /etc/ssh/ssh_host_dsa_key.pub      # Para chave DSA (padrão)
    2048 14:4a:aa:d9:73:25:46:6d:0a:48:35:c7:f4:16:d4:ee /etc/ssh/ssh_host_dsa_key.pub
    
Agora o cliente que estiver conectando á esse servidor pode verificar que está conectando ao servidor correto:
# ssh linda
    A authenticity of host 'linda (192.168.16.54)' can't be established.
    DSA key fingerprint is 14:4a:aa:d9:73:25:46:6d:0a:48:35:c7:f4:16:d4:ee.
    Are you sure you want to continue connecting (yes/no)? yes
    

Transferência segura de arquivo

Some simple commands:
# scp file.txt host-two:/tmp
    # scp joe@host-two:/www/*.html /www/tmp
    # scp -r joe@host-two:/www /www/tmp
    
No Konqueror ou Midnight Commander é possível acessar um sistema de arquivo remoto com o endereço fish://user@gate. No entanto a implementação é muito lenta.
Além disso é possível montar uma pasta (um diretório) remoto com sshfs, um cliente sistema de arquivo (file system client) baseado no SCP. Veja fuse sshfshttp://fuse.sourceforge.net/sshfs.html.
ssh_exchange_identification: Connection closed by remote host
Com esse erro tente o seguinte no servidor:
echo 'SSHD: ALL' >> /etc/hosts.allow
    /etc/init.d/sshd restart

Tunelamento

Tunelamento SSH lhe permite direcionar ou reverter a porta na conexão SSH, assim garantindo o tráfego e acessar portas que caso contrario estariam bloqueada. Isso só funciona com TCP. A nomenclatura geral para direcionamento e reverso é (veja também exemplo de ssh e NAT):
# ssh -L localport:desthost:destport user@gate  # desthost como visto a partir do gate
    # ssh -R destport:desthost:localport user@gate  # direciona a sua porta local para o destino
        # desthost:localport como visto a partir do cliente iniciando o túnel
    # ssh -X user@gate   # Forçar o X direcionar
    
Isso vai conectar ao gate e direcionar a porta local ao host desthost:destport. Note que desthost é o host de destino como visto pelo gate, então se a conexão é para o gate, então desthost é o localhost. Mais do que o direcionamento de uma porta é possível.

Direcionamento direto no gate

Digamos que queremos acessar CVS (porta 2401) e http (porta 80) que estão executando no gate. Isso é o exemplo mais simples, desthost é assim o localhost, e nós usamos a porta 8080 localmente ao invés da 80 então não precisamos ser o root. uma vez que a sessão ssh está aberta, ambos os serviços estão acessíveis nas portas local.
# ssh -L 2401:localhost:2401 -L 8080:localhost:80 user@gate

Direcionamento de Netbios e de área de trabalho remota para um segundo servidor

Diagmos que um servidor smb Windows está porta trás do gate e não está rodando ssh. Precisamos de acesso para o compartilhamento smb e também para a área de trabalho no servidor.
# ssh -L 139:smbserver:139 -L 3388:smbserver:3389 user@gate
O compartilhamento smb pode agora ser acessado com o \\127.0.0.1\, mas somente se o compartilhamento local for desabilitado, por que to compartilhamento local está escutando na porta 139.
É possível manter o compartilhamento local habilitado, para isso precisamos criar um novo dispositivo virtual com um novo endereço de IP para o túnel, o compartilhamento smb será conectado nesse endereço. Além disso o RPD local já está escutando na 3389, então nós escolhemos a 3388. Para esse exemplo vamos utilizar o IP virtual de 10.1.1.1.
Agora crie a interface de loopback com o IP 10.1.1.1: Eu TIVE que reiniciar para que isso funcionasse. Agora conecte ao compartilhamento smb com \\10.1.1.1 e o remote desktop para 10.1.1.1:3388.

Debug

Se isso não estiver funcionando:

Conecte dois clientes atrás do NAT

Suponhamos que dois clientes por trás de um gateway NAT e o cliente cliadmin tem que conectar ao cliente cliuser (o destino), ambos pode logar ao gate com o ssh e estão rodando linux com o sshd. Você não precisa acessar de qualquer lugar desde que as portas no gate estejam acima do 1024. Nós usamos 2022 no gate. Também desde que o gate seja utilizado localmente, a opção GatewayPorts não é necessaria.
No cliente cliuser (a partir do destino para o gate):
# ssh -R 2022:localhost:22 user@gate            # direciona o cliente 22 para o gate:2022
No cliente cliadmin (a partir do host para o gate):
# ssh -L 3022:localhost:2022 admin@gate         # direciona o cliente 3022 para o gate:2022
Agora o admin pode conectar diretamente ao cliente cliuser com:
# ssh -p 3022 admin@localhost                   # local:3022 -> gate:2022 -> client:22

Conect ao VNC atrás do NAT

Suponhamos que um cliente Windows com VNC escutando na porta 5900 tem que ser acessado a partir do NAT. No cliente cliwin para o gate:
# ssh -R 15900:localhost:5900 user@gate
No cliente cliadmin (a partir do host para o gate):
# ssh -L 5900:localhost:15900 admin@gate
Agora o admin pode conectar diretamente ao cliente VNC com:
# vncconnect -display :0 localhost

Cave (Dig) um túnel ssh multi-hop

Suponhamos que você não consiga alcançar um servidor diretamente com o ssh, mas somente via múltiplos hosts intermediários (por questões de roteamento por exemplo). Algumas vezes é necessário obter uma conexão direta cliente - servidor, por exemplo para compilar arquivos com o scp, ou direcionar outras portas como smb ou vnc. Um jeito de fazer isso é acorrentar túneis (chain tunnels together) para direcionar uma porta para o servidor ao longo dos saltos. Essa porta "carrier" somente alcança seu destino final na ultima conexão para o servidor.
Suponhamos que queremos direcionar a porta ssh de um cliente para um servidor em dois saltos (hops). Um vez que o túnel é construído, é possível conectar ao servidor diretamente do cliente (e também adicionar um outra porta de direcionamento).

Cria túnel em um shell

cliente -> host1 -> host2 -> servidor e cave (dig) o túnel 5678
client># ssh -L5678:localhost:5678 host1        # 5678 é uma porta arbitraria para o túnel
    host_1># ssh -L5678:localhost:5678 host2        # acorrenta 5678 do host1 para o host2
    host_2># ssh -L5678:localhost:22 server         # termina o túnel na porta 22 no server
    

Use o túnel com um outro shell

cliente -> servidor utilizando o túnel 5678
# ssh -p 5678 localhost                         # conecta diretamente do cliente para o servidor
    # scp -P 5678 myfile localhost:/tmp/            # ou copie um arquivo diretamente utilizando o túnel
    # rsync -e 'ssh -p 5678' myfile localhost:/tmp/ # ou utilizando rsync em um arquivo diretamente ao servidor
    

Script de autoconectar e manter vivo (keep alive)

Eu utilizo variações do seguinte script para manter a máquina alcançável no túnel ssh reverso. A conexão é automaticamente reconstruída e fechada. Você pode adicionar múltiplos túneis -L ou -R em uma linha.
#!/bin/sh
    COMMAND="ssh -N -f -g -R 3022:localhost:22 colin@cb.vu"
    pgrep -f -x "$COMMAND" > /dev/null 2>&1 || $COMMAND
    exit 0
    
1 * * * * colin /home/colin/port_forward.sh     # entrada crontab (aqui de hora em hora)

VPN com SSH

Como na verão 4.3, o OpenSSH pode usar o dispositivo tun/tap para criptografar um túnel. Ele é bem similar as outras soluções TLS baseado em VPN como o OpenVPN. Uma vantagem do SSH é que não há necessidade de instalar e configurar software adicional. Adicionalmente o túnel utiliza a autenticação SSH como chaves pré-compartilhadas. A desvantagem é que o encapsulamento é feito em TCP que pode resultar em desempenho pobre em um link lento. O túnel também conta com uma única conexão TPC (frágil). Essa técnica é muito útil para uma rápida configuração VPN baseada em IP. Não há limitação como com um único direcionamento de porta TCP, todos os protocolos de camada 3/4 como ICMP, TCP/UDP, etc. são direcionadas no VPN. Em todo caso, as seguintes opções são necessárias no arquivo sshd_conf:
PermitRootLogin yes
    PermitTunnel yes
    

Conexão única P2P

Aqui vamos conectar dois hosts, hclient e hserver com o túnel ponto a ponto (peer to peer tunnel). A conexão é iniciada do hclient para o hserver e é feita como root. Os pontos finais do túnel estão em 10.0.1.1 (servidor) e 10.0.1.2 (cliente) e nós críamos um dispositivo tun5 (Esse poderia também ter sido um outro número). O procedimento é muito simples:

Conect ao servidor

A conexão iniciada no cliente e os comandos são executados no servidor.

No servidor Linux

cli># ssh -w5:5 root@hserver
    srv># ifconfig tun5 10.0.1.1 netmask 255.255.255.252   # Executado no shell do servidor
    

No srevidor FreeBSD

cli># ssh -w5:5 root@hserver
    srv># ifconfig tun5 10.0.1.1 10.0.1.2                  # Executado no shell do servidor
    

Configure o cliente

Comandos executados no cliente:
cli># ifconfig tun5 10.0.1.2 netmask 255.255.255.252   # Cliente no Linux
    cli># ifconfig tun5 10.0.1.2 10.0.1.1                  # Cliente no FreeBSD
    
Os dois hosts estão agora conectados e podem transparentemente comunicar com qualquer protocolo de camada 3/4 utilizando o endereço de IP do túnel.

Conectar duas redes

Em adição a configuração p2p acima, é mais útil conectar duas redes privadas com uma VPN SSH utilizando dois gates. Suponhamos por exemplo, netA seja 192.168.51.0/24 e netB 192.168.16.0/24. O procedimento é similar ao acima, precisamos somente adicionar o reteamento. O NAT deve ser ativado na interface privada somente se os gates não forem os mesmos que o gateway padrão de sua rede.
192.168.51.0/24 (netA)|gateA <-> gateB|192.168.16.0/24 (netB)
A configuração é iniciada a partir do gateA no netA.

Conecte do gateA ao gateB

Conexão é iniciada do gateA e os comandos são executador no gateB.

gateB está no Linux

gateA># ssh -w5:5 root@gateB
    gateB># ifconfig tun5 10.0.1.1 netmask 255.255.255.252 # Executado no shell do gateB
    gateB># route add -net 192.168.51.0 netmask 255.255.255.0 dev tun5
    gateB># echo 1 > /proc/sys/net/ipv4/ip_forward        # Somente necessário se não for padrão (default gw)
    gateB># iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
    

gateB está no FreeBSD

gateA># ssh -w5:5 root@gateB                          # Cria os dispositivos do tun5
    gateB># ifconfig tun5 10.0.1.1 10.0.1.2               # Executado no shell do gateB
    gateB># route add 192.168.51.0/24 10.0.1.2
    gateB># sysctl net.inet.ip.forwarding=1               # Somente necessário se não for padrão (default) gw
    gateB># natd -s -m -u -dynamic -n fxp0                # veja se NAT
    gateA># sysctl net.inet.ip.fw.enable=1
    

Configure o gateA

Comandos executados no gateA:

gateA está no Linux

gateA># ifconfig tun5 10.0.1.2 netmask 255.255.255.252
    gateA># route add -net 192.168.16.0 netmask 255.255.255.0 dev tun5
    gateA># echo 1 > /proc/sys/net/ipv4/ip_forward
    gateA># iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE
    

gateA está no FreeBSD

gateA># ifconfig tun5 10.0.1.2 10.0.1.1
    gateA># route add 192.168.16.0/24 10.0.1.2
    gateA># sysctl net.inet.ip.forwarding=1
    gateA># natd -s -m -u -dynamic -n fxp0                # veja NAT
    gateA># sysctl net.inet.ip.fw.enable=1
    
As duas redes privadas agora estão transparentemente conectadas via VPN SSH. O direcionamento de IP e as configurações NAT são necessárias somente se os gates não forem os gateways padrões. Nesse caso os cliente não saberiam para aonde direcionar a resposta, e o NAT deve ser ativado.

RSYNC

Rsync pode quase substituir completamente o cp e o scp, além disso transferências interruptas são reiniciadas eficientemente. Uma barra invertida (e mesmo a ausência) tem sentidos diferentes, a man page é boa... aqui alguns exemplos:
Copia os diretórios com conteúdo completot:
# rsync -a /home/colin/ /backup/colin/                # "archive" mode. ex. mantem o mesmo
    # rsync -a /var/ /var_bak/
    # rsync -aR --delete-during /home/user/ /backup/      # usa relativo (veja abaixo)
    # /opt/local/bin/rsync -azv --iconv=UTF-8-MAC,UTF-8 ~/Music/flac/ me@server:/dst/
                               # converte nomes de arquivos (filenames) UTF8 do OSX para UTF8 do Windows
    
O meso que o anterior, mas na rede e com compressão. Rsync utiliza SSH para o transporte por padrão e utilizará a chave ssh se elas forem definidas. Utilize ":" da mesma forma que no SCP. Uma copia remota típica:
# rsync -axSRzv /home/user/ user@server:/backup/user/ # Copia para um lugar remoto
    # rsync -a 'user@server:My\ Documents' My\ Documents  # Quote AND escape spaces para o shell remoto
Exclui qualquer diretório tmp dentro de /home/user/ e mantem a hierarquia de pastas (diretórios) relativa, que é o diretório remoto terá a estrutura /backup/home/user/. Isso é tipicamente utilizado para backups.
# rsync -azR --exclude=tmp/ /home/user/ user@server:/backup/
Utilize a porta 20022 para a conexão ssh:
# rsync -az -e 'ssh -p 20022' /home/colin/ user@server:/backup/colin/
Utilizando a daemon rsync (utilizado com "::") é muito mais rápido, mas não criptografado no ssh. O local do /backup é definido pela configuração em /etc/rsyncd.conf. A variável RSYNC_PASSWORD pode ser definida para evitar a necessidade de entrar com a senha manualmente.
# rsync -axSRz /home/ ruser@hostname::rmodule/backup/
    # rsync -axSRz ruser@hostname::rmodule/backup/ /home/    # To copy back
    
Algumas opções importantes:

Rsync no Windows

Rsync está disponível para Windows através do cygwin ou como um pacote stand-alone em cwrsynchttp://sourceforge.net/projects/sereds. Isso é muito conveniente para backups automatizados. Instale um deles (não ambos) e adicione o path (caminho) ao sistema de variáveis do Windows (Windows system variables): # Control Panel -> System -> tab Advanced, button Environment Variables. Edite o sistema de variável "Path" e adicione o caminho completo (full path) ao rsync instalado, ex. C:\Program Files\cwRsync\bin or C:\cygwin\bin. Dessa forma os comandos rsync e ssh ficam disponíveis em um shell de comandos do Windows.

Autenticaçaõ de chave pública

Rsync é automaticamente tunelado no SSH e assim utiliza a autenticação SSH no servidor. Backups automáticos tem que evitar a interação de um usuário, para isso a autenticação de chave pública do SSH podem ser usadas e o comando rsync rodará sem uma senha.
Todos os comandos a seguir são executados dentro de um console Windows. Em um console (Start -> Run -> cmd) crie e faça upload da chave como descrito em SSH, altere "user" e "server" como apropriado. Se o arquivo authorized_keys2 não exista ainda, simplesmente copie id_dsa.pub para authorized_keys2 e suba-a.
# ssh-keygen -t dsa -N ''                   # Crie uma chave pública e uma privada
    # rsync user@server:.ssh/authorized_keys2 . # Copie o arquivo localmente a partir do servidor
    # cat id_dsa.pub >> authorized_keys2        # Ou utilize um editor para adicionar a chave
    # rsync authorized_keys2 user@server:.ssh/  # Copie o arquivo de volta para o servidor
    # del authorized_keys2                      # Remova a copia local
    
Agora teste com (em uma linha):
rsync -rv "/cygdrive/c/Documents and Settings/%USERNAME%/My Documents/" \
    'user@server:My\ Documents/'
    

Backup automático

Use um arquivo batch automatizar o backup e adicione o arquivo nas tarefas agendadas (scheduled tasks) (Programs -> Accessories -> System Tools -> Scheduled Tasks). Por exemplo crie o arquivo backup.bat e substitua user@server.
@ECHO OFF
    REM rsync the directory My Documents
    SETLOCAL
    SET CWRSYNCHOME=C:\PROGRAM FILES\CWRSYNC
    SET CYGWIN=nontsec
    SET CWOLDPATH=%PATH%
    REM uncomment the next line when using cygwin
    SET PATH=%CWRSYNCHOME%\BIN;%PATH%
    echo Press Control-C to abort
    rsync -av "/cygdrive/c/Documents and Settings/%USERNAME%/My Documents/" \
    'user@server:My\ Documents/'
    pause
    

SUDO

Sudo é um modo padrão para conceder aos usuários alguns direitos administrativos sem fornecer a senha de root. Sudo é muito util em um ambiente multiusuário com um mescla de servidores e workstations. Simplesmente chame o comando com o sudo:
# sudo /etc/init.d/dhcpd restart            # Rode o script rc como root
    # sudo -u sysadmin whoami                   # Rode o cmd como um outro usuário
    

Configuração

Sudo é configurado em /etc/sudoers e deve ser editado comente com o visudo. A syntax básica é (as listas são separadas por virgula):
user hosts = (runas) commands          # Em /etc/sudoers
Adicionalmente aquelas palavras chave pode ser definidas como alias, ela são chamadas User_Alias, Host_Alias, Runas_Alias e Cmnd_Alias. Isso é útil para instalações maiores. Aqui um exemplo sudoers:
# cat /etc/sudoers
    # Host aliases são subnets ou hostnames.
    Host_Alias   DMZ     = 212.118.81.40/28
    Host_Alias   DESKTOP = work1, work2

    # User aliases é uma lista de usuários que podem ter os mesmos direitos
    User_Alias   ADMINS  = colin, luca, admin
    User_Alias   DEVEL   = joe, jack, julia
    Runas_Alias  DBA     = oracle,pgsql

    # Comando aliases define o caminho completo de uma lista de comandos
    Cmnd_Alias   SYSTEM  = /sbin/reboot,/usr/bin/kill,/sbin/halt,/sbin/shutdown,/etc/init.d/
    Cmnd_Alias   PW      = /usr/bin/passwd [A-z]*, !/usr/bin/passwd root # Não pwd do root!
    Cmnd_Alias   DEBUG   = /usr/sbin/tcpdump,/usr/bin/wireshark,/usr/bin/nmap
    
# As reais regras
    root,ADMINS  ALL     = (ALL) NOPASSWD: ALL    # ADMINS podem fazer qualquer coisa com/ou um senha.
    DEVEL        DESKTOP = (ALL) NOPASSWD: ALL    # Desenvolvedores tem total direito nos desktops
    DEVEL        DMZ     = (ALL) NOPASSWD: DEBUG  # Desenvolvedores podem debugar os servidores DMZ.

    # Usuário sysadmin pode mexer por aí nos servidores DMZ com alguns comandos.
    sysadmin     DMZ     = (ALL) NOPASSWD: SYSTEM,PW,DEBUG
    sysadmin     ALL,!DMZ = (ALL) NOPASSWD: ALL   # Pode fazer qualquer coisa fora do DMZ.
    %dba         ALL     = (DBA) ALL              # Grupo dba pode rodar como usuário database.

    # qualquer um pode montar/desmontar um cd-rom nas máquinas desktop
    ALL          DESKTOP = NOPASSWD: /sbin/mount /cdrom,/sbin/umount /cdrom
    

Arquivos criptografados

OpenSSL

Um único arquivo

Criptograr e descriptografar:
# openssl aes-128-cbc -salt -in file -out file.aes
    # openssl aes-128-cbc -d -salt -in file.aes -out file
    
Note que o arquivo pode é claro ser um arquivo tar (tar archive).

tar e criptografar um diretório completo

# tar -cf - directory | openssl aes-128-cbc -salt -out directory.tar.aes      # Criptografado
    # openssl aes-128-cbc -d -salt -in directory.tar.aes | tar -x -f -            # Descriptografado
    

tar zip e criptografar um diretório completo

# tar -zcf - directory | openssl aes-128-cbc -salt -out directory.tar.gz.aes  # Criptografado
    # openssl aes-128-cbc -d -salt -in directory.tar.gz.aes | tar -xz -f -        # Descriptografado
    

GPG

GnuPG é bem conhecido para criptografar e assinalar e-mails ou qualquer dado. Além do mais gpg também provê um sistema avançado de gerenciamento chaves. Essa seçã cobre somente criptografia de arquivos, não uso de e-mail, assinalar ou o Web-Of-Trust.
A criptografia mais simples é com uma symmetric cipher. Nesse cado o arquivo é criptografado com uma senha e qualquer um que saiba a senha pode descriptografá-lo, assim as chaves não são necessárias. Gpg adiciona uma extensão ".gpg" para os nomes do arquivos criptografados.
# gpg -c file                        # Criptografa arquivo com senha
    # gpg file.gpg                       # Desciptografa arquivo (opcionalmente -o otherfile)
    

Utizando chaves (keys)

Para mais detalhess veja GPG Quick Starthttp://www.madboa.com/geek/gpg-quickstart e GPG/PGP Basicshttp://aplawrence.com/Basics/gpg.html e o gnupg documentationhttp://gnupg.org/documentation entre outros.
As chaves privadas e públicas são o coração da criptografia assimétrica. O que é importante lembrar: Primeiro gere o pare de chaves. As padrões são boas, no entanto você terá que inserir ao menos seu nome completo e e-mail e opcionalmente um comentário. O comentário é útil para criar mais do que uma chave com o mesmo e-mail. Você deve também utilizar uma "passphrase", não uma senha simples.
# gpg --gen-key                      # Isso pode levar um tempo
As chaves são armazenadas em ~/.gnupg/ no Unix, no Windows elas são tipicamente armazenadas em
C:/Documents and Settings/%USERNAME%/Application Data/gnupg/.
~/.gnupg/pubring.gpg                 # Contem suas chaves públicas e todas as outras importadas
    ~/.gnupg/secring.gpg                 # Pode conter mais de uma chave privada
    
Curto lembrete nas opções mais utilizadas: O exemplo utiliza 'Your Name' e 'Alice' já que as chaves são referidas pelo e-mail ou nome completo ou nome parcial. Por exemplo eu posso utilizar 'Colin' ou 'c@cb.vu' para a minha have [Colin Barschel (cb.vu) <c@cb.vu>].

Criptografa somente para uso pessoal

Não necesita exportar/importar qualquer chave para isso. Você já possui ambas.
# gpg -e -r 'Your Name' file                  # Criptografa com a sua chave pública
    # gpg -o file -d file.gpg                     # Descriptografa. Utiliza -o ou vai para a saída
    

Criptografar - Descriptografar com chaves

Primeiro você precisa exportar sua chave pública para que mais alguém a utilize. E você precisa importar a pública, digamos a partir da Alice para criptografar um arquivo para ela. Você pode tanto manusear as chaves em simples arquivos ASCII ou utilizar um servidor de chave pública.
Por exemplo, Alice exportou sua chave pública e você a importou, você oide criptografar um arquivo para ela. Isso é, somente Alice será capaz de descriptogrfá-lo.
# gpg -a -o alicekey.asc --export 'Alice'     # Alice exportou sua chave em arquivo ASCII.
    # gpg --send-keys --keyserver subkeys.pgp.net KEYID   # Alice colocou sua chave em um servidor.
    # gpg --import alicekey.asc                   # Você importa a chave da Alice para dentro do seu pubring.
    # gpg --search-keys --keyserver subkeys.pgp.net 'Alice' # ou obtenha a chave a Alice a partir do servidor.
    
Uma vez as chaves importadas, é muito fácil criptografar ou descriptografar um arquivo:
# gpg -e -r 'Alice' file                      # Criptografa o arquivo para a Alice.
    # gpg -d file.gpg -o file                     # Descriptografa um arquivo (criptografado pela Alice) para você.
    

Administração de chave

# gpg --list-keys                             # lista chaves públicas e vê o KEYIDS
        The KEYID follows the '/' e.g. for: pub   1024D/D12B77CE the KEYID is D12B77CE
    # gpg --gen-revoke 'Your Name'                # gera certificado de revocação
    # gpg --list-secret-keys                      # lista chaves privadas
    # gpg --delete-keys NAME                      # exclui uma chave pública a partir do chaveiro local (key ring)
    # gpg --delete-secret-key NAME                # exclui uma chave secreta a partir do chaveiro local
    # gpg --fingerprint KEYID                     # Exibe a impressão digital (fingerprint) da chave
    # gpg --edit-key KEYID                        # Edita a chave (ex. assina ou adiciona/exclui email)
    

Criptografar Partições

Linux com LUKS | Linux dm-crypt (somente) | FreeBSD GELI | FBSD pwd (somente) | Imanegm OS X

Há (muitos) outros métodos de alternativa para criptografar discos, eu mostro aqui somente os métodos que conheço e utilizo. Tenha em mente que segurança só é boa desde que o OS não foi s no been tempered with. Um intruso poderia facilmente gravar a senha a partir de eventos teclado. Além do mais o dado é livremente acessível quando a partição for attached e não evitará que um intruso tenha acesso á isso nesse estado.

Linux

Essas intrunções utilizam o Linux dm-crypt (device-mapper ou mapeador de dispositivo) facilidade disponível no kernel 2.6. Nesse exemplo, vamos criptografar a partição /dev/sdc1, poderia no entando ser qualquer outra partição ou disco, ou USB ou uma partição baseada em arquivo criada com losetup. Nesse caso poderias usar /dev/loop0. Veja file image partition. O mapeador de dispositivo utiliza etiquetas (labels) para identificar uma partição. Nós utilizamos sdc1 nesse exemplo, mas poderia ser qualquer string.

dm-crypt com o LUKS

LUKS com dm-crypt tem melhor criptografia e torna possível ter múltiplas passphrase para a mesma partição ou alterar a senha facilmente. para testar se o LUKS está disponível, simplesmente digite # cryptsetup --help, se nada a respeito do LUKS for exibido, use as instruções abaixo Without LUKS. Primeiro crie uma partição se necessário: fdisk /dev/sdc.

Criar partição criptografada

# dd if=/dev/urandom of=/dev/sdc1          # Opcional. For paranoids only (leva dias)
    # cryptsetup -y luksFormat /dev/sdc1       # Isso destrói qualquer dado no sdc1
    # cryptsetup luksOpen /dev/sdc1 sdc1
    # mkfs.ext3 /dev/mapper/sdc1               # cria sistema de arquivo ext3
    # mount -t ext3 /dev/mapper/sdc1 /mnt
    # umount /mnt
    # cryptsetup luksClose sdc1                # Desanexar a partição criptografada

Anexar

# cryptsetup luksOpen /dev/sdc1 sdc1
    # mount -t ext3 /dev/mapper/sdc1 /mnt

Desanexar

# umount /mnt
    # cryptsetup luksClose sdc1
    

dm-crypt sem LUKS

# cryptsetup -y create sdc1 /dev/sdc1      # ou qualquer outra partição como /dev/loop0
    # dmsetup ls                               # verifica, exibirá: sdc1 (254, 0)
    # mkfs.ext3 /dev/mapper/sdc1               # Isso é feito somente a primeira vez!
    # mount -t ext3 /dev/mapper/sdc1 /mnt
    # umount /mnt/
    # cryptsetup remove sdc1                   # Desanexar a partição criptografada
    
Faz exatamente o mesmo (sem a parte do mkfs!) para reanexar a partição. Se a senha não estiver correta, o comando mount falhará. Nesse caso simplesmente remova o map sdc1 (cryptsetup remove sdc1) e crie-a novamente.

FreeBSD

Os dois modulos de criptografia de disco populares do FreeBSD são o gbde e geli. Agora eu utilizo o geli por que ele é mais rápido e também utiliza o crypto device para aceleração de hardware. Veja o FreeBSD handbook Chapter 18.6http://www.freebsd.org/handbook/disks-encrypting.html para todos os detalhes. o módulo geli deve ser carregado ou compilado dentro do kernel:
options GEOM_ELI
    device crypto                                       # ou como modulo:
    # echo 'geom_eli_load="YES"' >> /boot/loader.conf   # ou faça: kldload geom_eli
    

Utilizar senha e chave

Eu utilizo essas configurações para uma criptografia de disco tipica, ela utiliza uma passphrase AND uma chave para criptografar a chave mestre (master). Isso é, você precisa tanto da senha e quando da chave gerada /root/ad1.key para anexar a partição. A chave mestre fica armazenada dentro da partição e não fica visivel. Veja abaixo para USB tipico ou imagem baseada em arquivo.

Criar partição criptografada

    # dd if=/dev/random of=/root/ad1.key bs=64 count=1  # Essa chave criptografa a chave mestre
    # geli init -s 4096 -K /root/ad1.key /dev/ad1       # -s 8192 também é bom para discos
    # geli attach -k /root/ad1.key /dev/ad1             # FAÇA um backup de /root/ad1.key
    # dd if=/dev/random of=/dev/ad1.eli bs=1m           # Opcional e leva um bom tempo
    # newfs /dev/ad1.eli                                # Cria sistema de arquivo
    # mount /dev/ad1.eli /mnt
    

Anexar

# geli attach -k /root/ad1.key /dev/ad1
    # fsck -ny -t ffs /dev/ad1.eli                      # na dúvida verifique o sistema de arquivo
    # mount /dev/ad1.eli /mnt
    

Desanexar

o procedimento de desanexação é feito automaticamente no shutdown.
# umount /mnt
    # geli detach /dev/ad1.eli
    

/etc/fstab

A partição criptografada pode ser configurada para ser montada com /etc/fstab. A senha será solicitada quando botar. As seguintes configurações são exigidas para esse exemplo:
# grep geli /etc/rc.conf
    geli_devices="ad1"
    geli_ad1_flags="-k /root/ad1.key"
    # grep geli /etc/fstab
    /dev/ad1.eli         /home/private              ufs             rw      0       0
    

Usar somente a senha

É mais conveniente criptografar um pendrive ou imagem baseada em arquivo com somente uma passphrase e sem chave. Nesse caso não é necessário carregar o arquivo de chave adicional por aí. O procedimento é o bem como o acima, simplesmente sem o arquivo chave. Vamos criptografar uma imagem baseada em arquivo /cryptedfile de 1 GB.
# dd if=/dev/zero of=/cryptedfile bs=1M count=1000  # Arquivo de 1 GB
    # mdconfig -at vnode -f /cryptedfile
    # geli init /dev/md0                                # criptografa somente com senha
    # geli attach /dev/md0
    # newfs -U -m 0 /dev/md0.eli
    # mount /dev/md0.eli /mnt
    # umount /dev/md0.eli
    # geli detach md0.eli
    
Agora é possível montar essa imagem em outro sistema somente com a senha.
# mdconfig -at vnode -f /cryptedfile
    # geli attach /dev/md0
    # mount /dev/md0.eli /mnt
    

imagem de disco criptografa do OS X

Não sabe somente por linha de comando. Veja Imagem de disco criptografada do OS Xhttps://wiki.thayer.dartmouth.edu/display/computing/Creating+a+Mac+OS+X+Encrypted+Disk+Image e Apple supporthttp://support.apple.com/kb/ht1578

Certificado SSL

Chamados de certificados SSL/TLS são certificados de chaves públicas criptografadas e são compostas de uma chave pública e uma privada. O certificados são utilizados para autenticar os endpoints e criptografar os dados. Elas são utilizadas por exemplo em um servidor server (https) ou servidor de e-mail (imaps).

Procedimento

Configurar OpenSSL

Nós usamos /usr/local/certs como diretório para esse exemplo; verifique ou edite /etc/ssl/openssl.cnf de acordo com as suas configurações, assim você sabe aonde os arquivos serão criados. Aqui estão as partes do openssl.cnf:
[ CA_default ]
    dir             = /usr/local/certs/CA       # Aonde tudo é mantido
    certs           = $dir/certs                # Aonde os certificados emitidos são mantidos
    crl_dir         = $dir/crl                  # Aonde os crl emitidos são mantidos
    database        = $dir/index.txt            # arquivos index database (base de dados).
    
Certifique-se de que os diretórios existem ou crie-os
# mkdir -p /usr/local/certs/CA
    # cd /usr/local/certs/CA
    # mkdir certs crl newcerts private
    # echo "01" > serial                        # Somente se o serial não existe
    # touch index.txt
    
Se você pretende obter um certificado de assinado vindo de um fornecedor, você só precisa uma solicitação de assinatura de certificado (certificate signing request) (CSR). Esse CSR será então assinado pelo fornecedor (vendor) por um tempo limitado (ex. 1 ano).

Criar uma autoridade de certificado

Se você não tem uma autoridade de certificado de um fornecedor, Você terá que criar uma própria. Esse passo não é necessário se alguém pretendia utilizar um fornecedor para assinar a solicitação. Para gerar uma autoridade de certificado (certificate authority) (CA):
# openssl req -new -x509 -days 730 -config /etc/ssl/openssl.cnf \
    -keyout CA/private/cakey.pem -out CA/cacert.pem
    

Gerar uma solicitação de assinatura de certificado

Para gerar um novo certificado (para servidor de mensagens ou servidor web por exemplo), primeiro gere um certificado de solicitação com sua chave privada. Se sua aplicação não suporta chave privada criptografada(por exemplo UW-IMAP does not), então desabilite a criptografia com -nodes.
# openssl req -new -keyout newkey.pem -out newreq.pem \
    -config /etc/ssl/openssl.cnf
    # openssl req -nodes -new -keyout newkey.pem -out newreq.pem \
    -config /etc/ssl/openssl.cnf                # Sem criptografia para a chave
    
Guarde essa CSR gerada (newreq.pem) desde que ela pode ser assinada novamente na próxima vez que for renovar a página, a assinatura onlt limitará a validade do certificado. Esse processo também gerou a chave privada newkey.pem.

Assinar o certificado

A solicitação de certificado tem que ser assinado pela CA para ser validada, esse passo é normalmente feito pelo fornecedor. Nota: substitua "servername" pelo nome do seu servidor nos próximos comandos.
# cat newreq.pem newkey.pem > new.pem
    # openssl ca -policy policy_anything -out servernamecert.pem \
    -config /etc/ssl/openssl.cnf -infiles new.pem
    # mv newkey.pem servernamekey.pem
    
Agora servernamekey.pem é a chave privada e servernamecert.pem é o certificate servidor.

Gerar certificado unido (united certificate)

O servidor IMAP que ter ambos (chave privada e certificado do servidor) no mesmo arquivo. De modo geral, Isso também é mais fácil de manusear, mas o arquivo deve ser mantido seguro!. O Apache também pode lidar com isso bem. Gere um arquivo servername.pem contendo o certificado e a chave. O final do arquivo servername.pem deve parecer com isso:

-----BEGIN RSA PRIVATE KEY-----
    MIICXQIBAAKBgQDutWy+o/XZ/[...]qK5LqQgT3c9dU6fcR+WuSs6aejdEDDqBRQ
    -----END RSA PRIVATE KEY-----
    -----BEGIN CERTIFICATE-----
    MIIERzCCA7CgAwIBAgIBBDANB[...]iG9w0BAQQFADCBxTELMAkGA1UEBhMCREUx
    -----END CERTIFICATE-----
    
O que temos agora no diretório /usr/local/certs/: Guarde a chave privada em lugar seguro!

Visualizar informações do certificado

Para visualizar as informações do certificado simplesmente faça:
# openssl x509 -text -in servernamecert.pem      # Visualiza a info do certificado
    # openssl req -noout -text -in server.csr        # Visualiza a info da solicitação
    # openssl s_client -connect cb.vu:443            # Verifica um certificado do servidor web
    

CVS

Configuração do servidor | teste do CVS | tunelamento do SSH | uso do CVS

Configuração do servidor

Iniciar o CVS

Decida aonde o repositório principal will permanecer e gerar uma cvs root. Por exemplo /usr/local/cvs (como root):
# mkdir -p /usr/local/cvs
    # setenv CVSROOT /usr/local/cvs      # Define o CVSROOT para o novo local (local)
    # cvs init                           # Gera todos os arquivos internos de configuração do CVS
    # cd /root
    # cvs checkout CVSROOT               # verifica os arquivos de configuração para modificá-los
    # cd CVSROOT
    edit config ( fine as it is)
    # cvs commit config
    cat >> writers                       # Gera um arquivo writers (também o readers opcionalmente)
    colin
    ^D                                   # Utiliza [Control][D] para sair da edição
    # cvs add writers                    # Adiciona o arquivo writers dentro do repositório
    # cvs edit checkoutlist
    # cat >> checkoutlist
    writers
    ^D                                   # Utiliza [Control][D] para sair da edição
    # cvs commit                         # Envia todas as alterações de configuração
    
Adiciona um arquivo readers se você quiser diferenciar permissões de leitura e escrita (read and write). Nota: Não edite (nunca) os arquivos diretamente no cvs principal, mas verifique o arquivo, modifique-o e verifique. Fizemos isso com o arquivo writers para definir o acesso a escrita.
há três modos populares de acessar o CVS nesse ponto. Os dois primeiros não necessitam de grandes configurações. Veja os exemplos em CVSROOT abaixo para como utilizá-los:

Configuração de rede com o inetd

O CVS pode ser executado localmente somente se um acesso a rede não for necessário. Para um acesso remoto, a daemon inetd pode iniciar o pserver com o seguinte linha em /etc/inetd.conf (/etc/xinetd.d/cvs no SuSE):
cvspserver	stream  tcp  nowait  cvs  /usr/bin/cvs	cvs \
    --allow-root=/usr/local/cvs pserver
    
Não é uma boa ideia bloquear a porta do port da Internet com o firewall e utilizar um túnel ssh para acessar o repositório remotamente.

Separar a autenticação

É possível ter usuários cvs que não são parte do OS (sem usuários local). Na verdade isso é provavelmente requerido também do ponto de vista da segurança. Simplesmente adicione um arquivo nomeado passwd (no diretório CVSROOT) contendo o login de usuário e senha no formato criptografado. Isso pode ser feito com a ferramenta htpasswd do apache (apache htpasswd tool).
Nota: Esse arquivo passwd é o único arquivo que deve ser editado diretamente no diretório CVSROOT. Também não será verificado. Mais informações com o htpasswd --help
# htpasswd -cb passwd user1 password1  # -c gera o arquivo file
    # htpasswd -b passwd user2 password2
    
Agora adicione :cvs no final de cada linha para dizer ao servidor cvs que altere o usuário para cvs (ou seja o que for que o ser servidor cvs estiver executando). Parece com isso:
# cat passwd
    user1:xsFjhU22u8Fuo:cvs
    user2:vnefJOsnnvToM:cvs
    

Testá-lo

Teste o login como usuário normal (por exemplo)
# cvs -d :pserver:colin@192.168.50.254:/usr/local/cvs login
    Logging in to :pserver:colin@192.168.50.254:2401/usr/local/cvs
    CVS password:

    

Variavel CVSROOT

Essa é uma varável de ambiente utilizada para especificar o local do repositório que estamos realizando as operações. Para uso local, Pode ser definido apenas para o diretório do repositório. Para uso na rede, o protocolo de transporte deve ser especificado. Defina a variável CVSROOT com o setenv CVSROOT string em um shell csh, tcsh shell, ou com o export CVSROOT=string em um shell sh, bash.
# setenv CVSROOT :pserver:<username>@<host>:/cvsdirectory
    Por exemplo:
    # setenv CVSROOT /usr/local/cvs                               # Utilizado localmente (somente)
    # setenv CVSROOT :local:/usr/local/cvs                        # O mesmo que acima
    # setenv CVSROOT :ext:user@cvsserver:/usr/local/cvs           # Acesso direto com o SSH
    # setenv CVS_RSH ssh                                          # para o acesso ext
    # setenv CVSROOT :pserver:user@cvsserver.254:/usr/local/cvs   # rede com o pserver
    
Quando o login for bem sucedido, a pessoa pode importar um novo projeto para dentro do repositório: cd dentro do diretório root do seu projeto
cvs import <module name> <vendor tag> <initial tag>
    cvs -d :pserver:colin@192.168.50.254:/usr/local/cvs import MyProject MyCompany START
    
Aonde MyProject é o nome do novo projeto no repositório (utilizado mais tarde para verificar). Cvs importará o conteúdo do diretório atual para dentro do novo projeto.

Verificar:
# cvs -d :pserver:colin@192.168.50.254:/usr/local/cvs checkout MyProject
    ou
    # setenv CVSROOT :pserver:colin@192.168.50.254:/usr/local/cvs
    # cvs checkout MyProject
    

Tunelamento SSH para CVS

Precisamos de 2 shells para isso. No primeiro shell conectamos o servidor cvs com o ssh e direcionamos (port-forward) a conexão cvs. No segundo shell utilizamos o cvs normalmente como se estivesse sendo executado localmente.
no shell 1:
# ssh -L2401:localhost:2401 colin@cvs_server   # Conecte diretamente ao servidor CVS. Ou:
    # ssh -L2401:cvs_server:2401 colin@gateway     # Utilize um gateway para alcançar o CVS
no shell 2:
# setenv CVSROOT :pserver:colin@localhost:/usr/local/cvs
    # cvs login
    Logging in to :pserver:colin@localhost:2401/usr/local/cvs
    CVS password:
    # cvs checkout MyProject/src
    

Comandos CVS e uso

Import

O comando import é utilizado para adicionar um diretório inteiro, ele deve ser executado dentro do diretório para ser importado. Digamos que ao diretório /devel/ contem todos os arquivos e subdiretórios a serem importados. O nome do diretório no CVS (o módulo) será chamado "myapp".
# cvs import [options] directory-name vendor-tag release-tag
    # cd /devel                          # Deve estar dentro do projeto para importá-lo
    # cvs import myapp Company R1_0      # libera tag, pode ser qualquer coisa em uma palavra
    
Depois de algum tempo um novo diretório "/devel/tools/" foi adicionado e precisa ser importado também.
# cd /devel/tools
    # cvs import myapp/tools Company R1_0
    

Verificar adição da atualização

# cvs co myapp/tools                 # Verificará somente as ferramentas do diretório
    # cvs co -r R1_1 myapp               # Verifica myapp no release R1_1 (está colado)
    # cvs -q -d update -P                # Uma atualização típica do CVS
    # cvs update -A                      # Redefine qualquer etiqueta colada (sticky tag) (ou data, opção)
    # cvs add newfile                    # Adiciona um novo arquivo
    # cvs add -kb newfile                # Adiciona um novo arquivo binário
    # cvs commit file1 file2             # Envia somente os dois arquivos
    # cvs commit -m "message"            # Envia todas as alterações feitas com uma mensagem
    

Gerar um patch

É melhor gerar e aplicar um a partir do diretório de desenvolvimento de trabalho relacionado ao projeto, ou de dentro do diretório fonte.
# cd /devel/project
    # diff -Naur olddir newdir > patchfile # Gera um patch a partir de um diretório ou de um arquivo
    # diff -Naur oldfile newfile > patchfile
    

Aplicar um patch

As vezes é necessário espanar um nível de diretório do patch, dependendo de como ele foi gerado. Em caso de dificuldades, simplesmente nas primeiras linhas do patch e tente -p0, -p1 ou -p2.
# cd /devel/project
    # patch --dry-run -p0 < patchfile    # Teste o caminho (path) sem aplicá-lo
    # patch -p0 < patchfile
    # patch -p1 < patchfile              # espana o primeiro nível do path
    

SVN

Configuração do servidorp | SVN+SSH | SVN no http | Uso do SVN

Subversion (SVN)http://subversion.tigris.org/ é um sistema de controle de versão projetado para ser o sucessor do CVS (Concurrent Versions System). O conceito é similar ao CVS, mas muitas deficiências foram melhoradas. Veja também o SVN bookhttp://svnbook.red-bean.com/en/1.4/.

configuração do servidor setup

A iniciação do repositório é bastante simples (aqui por exemplo /home/svn/ deve existe):
# svnadmin create --fs-type fsfs /home/svn/project1
Agora o acesso ao repositório torna-se possível com: Utilizando o sistema de arquivo local, não é possível importar e então verificar um projeto existente. diferente do CVS, não é necessário dar cd dentro do diretório do projeto, simplesmente dê o path completo:
# svn import /project1/ file:///home/svn/project1/trunk -m 'Initial import'
    # svn checkout file:///home/svn/project1
    
O novo diretório "trunk" é somente uma convenção, isso não exigido.

Acesso remoto com ssh

Nenhuma configuração especial é exigida para acessar o repositório via ssh, simplesmente substitua file:// com svn+ssh/hostname. Por exemplo:
# svn checkout svn+ssh://hostname/home/svn/project1
Assim com o acesso ao arquivo local, todo usuário precisa de um acesso ssh para o servidor (com uma conta local) e também acesso a leitura/escrita. Esse método pode ser adequado para um grupo pequeno. Todos os usuários poderia pertencer a um grupo de subversão que pertence ao repositório, por exemplo:
# groupadd subversion
    # groupmod -A user1 subversion
    # chown -R root:subversion /home/svn
    # chmod -R 770 /home/svn
    

Acesso remoto com o http (apache)

Acesso remoto pelo http (https) é a única boa solução para um grupo de usuários grande. Esse método utiliza a autenticação apache, não as contas local. Essa é uma configuração típica do apache, porém pequena:
LoadModule dav_module         modules/mod_dav.so
    LoadModule dav_svn_module     modules/mod_dav_svn.so
    LoadModule authz_svn_module   modules/mod_authz_svn.so    # Somente para controle de acesso
    
<Location /svn>
      DAV svn
      # qualquer URL "/svn/foo" será mapeado para um repositório /home/svn/foo
      SVNParentPath /home/svn
      AuthType Basic
      AuthName "Subversion repository"
      AuthzSVNAccessFile /etc/apache2/svn.acl
      AuthUserFile /etc/apache2/svn-passwd
      Require valid-user
    </Location>
    
O servidor apache precisa de total acesso ao repositório:
# chown -R www:www /home/svn
Criar um usuário com o htpasswd2:
# htpasswd -c /etc/svn-passwd user1  # -c cria o arquivo

Exemplo de controle de acesso svn.acl

# Acesso padrão é somente leitura. "* =" seria sem acesso padrão
    [/]
    * = r
    [groups]
    project1-developers = joe, jack, jane
    # Da acesso de escrita aos desenvolvedore
    [project1:]
    @project1-developers = rw
    

Comandos SVN e uso

Veja também o Subversion Quick Reference Cardhttp://www.cs.put.poznan.pl/csobaniec/Papers/svn-refcard.pdf. Tortoise SVNhttp://tortoisesvn.tigris.org é uma interface de janela agradavel.

Importar

um novo projeto, que é um diretório com alguns arquivos, é importado para dentro do repositório com o comando import. Import também é utilizado para adicionar um diretório com seu conteúdo para um projeto existente.
# svn help import                                # obtém ajuda para qualquer comando
        # Adiciona um novo diretório (com conteudo) para dentro do diretório src no project1
    # svn import /project1/newdir http://host.url/svn/project1/trunk/src -m 'add newdir'
    

Typical SVN commands

# svn co http://host.url/svn/project1/trunk      # Verifica a versão mais recente
        # Etiquetas (Tags) e ramos (branches) são gerados ao copiar
    # svn mkdir http://host.url/svn/project1/tags/   # Cria o diretório tags
    # svn copy -m "Tag rc1 rel." http://host.url/svn/project1/trunk \
                                 http://host.url/svn/project1/tags/1.0rc1
    # svn status [--verbose]                         # Verifica status de arquivos dentro do diretório de trabalho
    # svn add src/file.h src/file.cpp                # Adiciona dois arquivos
    # svn commit -m 'Added new class file'           # Gera as alterações com uma mensagem
    # svn ls http://host.url/svn/project1/tags/      # Lista todas as tags
    # svn move foo.c bar.c                           # Move (renomeia) arquivos
    # svn delete some_old_file                       # Exclui arquivos
    

Comandos uteis

less | vi | mail | tar | zip | dd | screen | find | Miscellaneous

less

O comando less exibe um documento de texto no console. Ele é presente em muitas instalações.
# less unixtoolbox.xhtml
Alguns comandos importantes são (^N representa o [control]-[N]):

vi

Vi está presente em QUALQUER instalação Linux/Unix (não no gentoo?) e é logo útil saber alguns comandos básicos. Há dois modos: modo comando e modo inserção. O modo de comandos é acessado com [ESC], o modo de inserção com o i. Use : help se estiver perdido.
Os editores nano e pico estão geralmente disponíveis também e são mais fáceis (IMHO) de usar.

Sair (Quit)

Buscar e mover

Excluir, copiare colar text

mail

O comando mail é uma aplicação básica para ler e enviar e-mail, é normalmente instalado. para enviar um e-mail simplesmente digite "mail user@domain". A primeira linha é o assunto, depois o conteúdo da mensagem. Termine e envie o e-mail com um único ponto (.) em uma nova linha. Exemplo:
# mail c@cb.vu
    Subject: Seu texto está cheio de erros de digitação
    "Por um tempo, nada aconteceu. Depois de alguns segundos ou mais, 
    nada continua acontecendo."
    .
    EOT
    #
    
Também funciona com um cano (pipe):
# echo "Esse é o corpo da mensagem" | mail c@cb.vu
Essa é também uma forma simples de testar o servidor de e-mail.

tar

O comando tar (tape archive) gera e extrai arquivos e diretórios armazenados. O arquivo .tar descompactado, um arquivo compactado tem a extensão .tgz ou .tar.gz (zip) ou .tar.bz (bzip2). Não utilize caminho absoluto quando gerar um arquivo, você provavelmente quer desempacotá-lo em algum outro luar. Alguns comandos são:

Gerar

# cd /
    # tar -cf home.tar home/        # arquiva o diretório /home completo (c para criar)
    # tar -czf home.tgz home/       # o mesmo com compressão zip
    # tar -cjf home.tbz home/       # o mesmo com compressão bzip2
    
inclue somente um (ou dois) diretórios a partir de uma arvore, mas mantém a estrutura relativa. Por exemplo, arquivar /usr/local/etc e /usr/local/www e o primeiro diretório no arquivo deve ser local/.
# tar -C /usr -czf local.tgz local/etc local/www
    # tar -C /usr -xzf local.tgz    # Para desempacotar (untar) o diretório local dentro de /usr
    # cd /usr; tar -xzf local.tgz   # é o mesmo que acima
    

Extrair

# tar -tzf home.tgz             # Olha dentro do arquivo sem extraiir (lista)
    # tar -xf home.tar              # extrai o arquivo aqui (x para extrair)
    # tar -xzf home.tgz             # o mesmo que da compressão zip (-xjf para a compressão bzip2)
                                    # remove caminho guias gallery2 e extrai para dentro de gallery
    # tar --strip-components 1 -zxvf gallery2.tgz -C gallery/ 
    # tar -xjf home.tbz home/colin/file.txt    # Restaura um único arquivo
    # tar -xOf home.tbz home/colin/file.txt    # Imprime o arquivo na saída (stdout) (sem extração)
    

Mais avançado

# tar c dir/ | gzip | ssh user@remote 'dd of=dir.tgz' # arquiva o dir/ e armazena remotamente.
    # tar cvf - `find . -print` > backup.tar              # arquiva o diretório atual.
    # tar -cf - -C /etc . | tar xpf - -C /backup/etc      # Copia diretórios
    # tar -cf - -C /etc . | ssh user@remote tar xpf - -C /backup/etc      # Copia remota.
    # tar -czf home.tgz --exclude '*.o' --exclude 'tmp/' home/
    

zip/unzip

Arquivos zip pode ser faceis de compartilhar com o Windows.
# zip -r fileName.zip /path/to/dir                    # zipa o diretório para dentro do arquivo fileName.zip
    # unzip fileName.zip                                  # descompacta o arquivo zip
    # unzip -l fileName.zip                               # lista arquivos dentro do arquivo
    # unzip -c fileName.zip fileinside.txt                # imprime um arquivo na saída (sem extração)
    # unzip fileName.zip fileinside.txt                   # extrai somente um arquivo
    

dd

O programa dd (disk dump ou destroy disk ou veja (the meaning of dd) é utilizado para copiar partições e discos e para outros truques de cópias. Uso típico:
# dd if=<source> of=<target> bs=<byte size> conv=<conversion>
    # kill -INFO PID                                      # Visualiza p processo do dd (FreeBSD, OSX)
    
Opções importantes: O tamanho de byte padrão é de 512 (um bloco). O MBR, aonde a tabela de partição fica localizada, fica no primeiro bloco, os primeiros 63 blocos de um disco ficam vazios. Tamanhos maiores de byte são mais rápidos para copiar mas requer também mais memória.

Backup e restaurção

# dd if=/dev/hda of=/dev/hdc bs=16065b                # Copia de disco para disco (do mesmo tamanho)
    # dd if=/dev/sda7 of=/home/root.img bs=4096 conv=notrunc,noerror # Realiza backup do /
    # dd if=/home/root.img of=/dev/sda7 bs=4096 conv=notrunc,noerror # Restaura o /
    # dd bs=1M if=/dev/ad4s3e | gzip -c > ad4s3e.gz                  # Zipa o backup
    # gunzip -dc ad4s3e.gz | dd of=/dev/ad0s3e bs=1M                 # Restaura o zip
    # dd bs=1M if=/dev/ad4s3e | gzip | ssh eedcoba@fry 'dd of=ad4s3e.gz' # também remoto
    # gunzip -dc ad4s3e.gz | ssh eedcoba@host 'dd of=/dev/ad0s3e bs=1M'
    # dd if=/dev/ad0 of=/dev/ad2 skip=1 seek=1 bs=4k conv=noerror    # Pula o MBR
        # Isso é necessário se o destino (ad2) for menor.
    # dd if=/vm/FreeBSD-8.2-RELEASE-amd64-memstick.img of=/dev/disk1 bs=10240 conv=sync
        # Copia a imagem do FreeBSD para o pendrive (USB memory stick)
    

Recuperar

O comando dd lerá cada bloco da partição. Em caso de problemas é melhor usar a opção conv=sync,noerror então o dd pulará o bad block e escreverá zeros no destino. Consequentemente é importante definir o tamanho do bloco igual ou menor do que o tamanho dos blocos do disco. o tamanho de 1k parece seguro, defina-o com bs=1k. Se um disco tem setores ruins (bad sectors) e o dado deve ser restituído a partir de uma partição, Gere um arquivo de imagem com o dd, monte a imagem e copie o conteúdo para um novo disco. Com a opção noerror, dd pulará os setores ruins e escreverá zeros ao invés de ocupá-los, assim somente os dados contidos nos setores ruins serão perdidos.
# dd if=/dev/hda of=/dev/null bs=1m                   # verificar se há bad blocks
    # dd bs=1k if=/dev/hda1 conv=sync,noerror,notrunc | gzip | ssh \ # Envia para algum lugar remoto
    root@fry 'dd of=hda1.gz bs=1k'
    # dd bs=1k if=/dev/hda1 conv=sync,noerror,notrunc of=hda1.img    # Armazena dentro de uma imagem
    # mount -o loop /hda1.img /mnt                        # Monta a imagem
    # rsync -ax /mnt/ /newdisk/                           # Copia em um novo disco
    # dd if=/dev/hda of=/dev/hda                          # Atualizar o estado magnético (apagará todo o disco)
      # A opção acima é util para atualizar o disco. É perfeitamente seguro, mas deve ser desmontado.
    

Excluir

# dd if=/dev/zero of=/dev/hdc                         # Exclui (zera) todo o disco
    # dd if=/dev/urandom of=/dev/hdc                      # Exclui melhor todo o disco
    # kill -USR1 PID                                      # Visualiza o progresso do dd (Linux)
    # kill -INFO PID                                      # Visualiza o progresso do dd (FreeBSD)
    

MBR truques

O MBR contém o carregador de boot (boot loader) e a tabela de partição e é do tamanho de 512 bytes. Os primeiros 446 são para o carregador de boot, os bytes 446 á 512 são para a tabela de partição.
# dd if=/dev/sda of=/mbr_sda.bak bs=512 count=1       # Faz backup de todo o MBR
    # dd if=/dev/zero of=/dev/sda bs=512 count=1          # Exclui o MBR e a tabela de partições
    # dd if=/mbr_sda.bak of=/dev/sda bs=512 count=1       # Recupera todo o MBR
    # dd if=/mbr_sda.bak of=/dev/sda bs=446 count=1       # Recupera somente o carregador de boot
    # dd if=/mbr_sda.bak of=/dev/sda bs=1 count=64 skip=446 seek=446 # Recupera a tabela de partições
    

screen

Screen (a must have) tem duas funcionalidades principais:

Exemplo curto de exemplo

Iniciar a tela com:
# screen
Dentro da seção da tela nós podemos inciar um programa bem duradouro (como o top).
# top
Agora separe com o Ctrl-a Ctrl-d. Recoloque o terminal com:
# screen -R -D
Em detalhes, isso significa: Se uma seção estiver sendo executada, então recoloque. Se necessário separe o faça logout remotamente primeiro. Se não estiver sendo executado, gere-o e notifique ao usuário. Ou:
# screen -x
Anexe a tela em execução em um modo multi display. O console é assim compartilhado entre outros múltiplos usuários. Muito útil para a equipe de trabalho/debug!

Comandos de tela (dentro da tela)

Todos os comandos de tela iniciam com Ctrl-a. A sessão é terminada quando o programa dentro do terminal em execução for fechado e você fizer logout do terminal.

Find

Algumas opções importantes:
# find . -type f ! -perm -444        # Encontra arquivos não legíveis por todos
    # find . -type d ! -perm -111        # Encontra diretórios não acessíveis por todos
    # find /home/user/ -cmin 10 -print   # Arquivos gerados ou modificados nos últimos 10 minutos.
    # find . -name '*.[ch]' | xargs grep -E 'expr' # Busca 'expr' nesse diretório abaixo.
    # find / -name "*.core" | xargs rm   # Encontra core dumps e os exclui (também tenta core.*)
    # find / -name "*.core" -print -exec rm {} \;  # Outra syntax
          # Encontra imagens e gera um arquivo, iname não é case sensitive. -r para anexo (append)
    # find . \( -iname "*.png" -o -iname "*.jpg" \) -print -exec tar -rf imagens.tar {} \;
    # find . -type f -name "*.txt" ! -name README.txt -print  # Exclui arquivos README.txt
    # find /var/ -size +10M -exec ls -lh {} \;     # Encontra arquivos grandes > 10 MB
    # find /var/ -size +10M -ls           # Isso é mais simples
    # find . -size +10M -size -50M -print
    # find /usr/ports/ -name work -type d -print -exec rm -rf {} \;  # Limpa as portas
          # Find files with SUID; those file are vulnerable and must be kept secure
    # find / -type f -user root -perm -4000 -exec ls -l {} \;
    # find flac/ -iname *.flac -print -size +500k -exec /Applications/Fluke.app/Contents/MacOS/Fluke {} \;
                                          # Eu utilizo a opção acima para adicionar arquivos flac (formato de audio) ao iTunes no OSX
    
Seja cuidadoso com o xarg ou o exec já que pode ou não honrar quotings e pode retornar resultados errados quando os arquivos ou diretórios conterem espaçoes. Na dúvida, utilize "-print0 | xargs -0" instead of "| xargs". A opção -print0 deve ser a ultima no comando find. Veja esse bom mini tutorial para o find (em inglês)http://www.hccfl.edu/pollock/Unix/FindCmd.htm.
# find . -type f | xargs ls -l       # Não funcionará com espaços nos names
    # find . -type f -print0 | xargs -0 ls -l  # Não funcionará com espaços nos nomes
    # find . -type f -exec ls -l '{}' \; # Or use quotes '{}' with -exec
    
Duplicar arvore de diretório:
# find . -type d -exec mkdir -p /tmp/new_dest/{} \;

Miscelâneas

# which comando                      # Exibe nome completo do  caminho do comando
    # time comando                       # Veja quanto tempo p comando leva para  ser executado
    # time cat                           # Usa o time como o as cronômetro. Ctrl-c para parar
    # set | grep $USER                   # Lista o ambiente atual
    # cal -3                             # Exibe um calendário de três meses
    # date [-u|--utc|--universal] [MMDDhhmm[[CC]YY][.ss]]
    # date 10022155                      # Define data e hora
    # whatis grep                        # Exibe uma informação curta no comando
    # whereis java                       # Busca caminho (path) e diretórios padrões paar a palavra
    # setenv varname value               # Set env. variável varname para o valor (csh/tcsh)
    # export varname="value"             # set env. variável varname para o valor (sh/ksh/bash)
    # pwd                                # Imprime diretório de trabalho atual (sigla de Print Working Directory)
    # mkdir -p /path/to/dir              # sem erro se existir, gera diretórios pai caso necessário (parent dirs)
    # mkdir -p project/{bin,src,obj,doc/{html,man,pdf},debug/some/more/dirs}
    # rmdir /path/to/dir                 # Remove o diretório
    # rm -rf /path/to/dir                # Remove e diretório e o seu conteúdo (f= força)
    # rm -- -badchar.txt                 # Remove o arquivo que inicia com um traço (-)
    # cp -la /dir1 /dir2                 # Arquiva e gera arquivos hard link ao inves de copiá-los
    # cp -lpR /dir1 /dir2                # O mesmo para o FreeBSD
    # cp unixtoolbox.xhtml{,.bak}        # Jeito curto de copiar o arquivo com uma nova extenção
    # mv /dir1 /dir2                     # Renomeia um diretório
    # ls -1                              # lista um arquivo por linha
    # history | tail -50                 # Exibe us últimos 50 comandos utilizados
    # cd -                               # cd para o diretório anterior ($OLDPWD)
    # /bin/ls| grep -v .py | xargs rm -r # canaliza (pipe) nomes de arquivos para o rm com o xargs
    
Verificar hashs de arquivo com o openssl. Essa é uma boa alternativa para os comandos md5sum ou sha1sum (FreeBSD utiliza md5 e sha1) que não ven sempre instalados por padrão.
# openssl md5 file.tar.gz            # Gera um checksum md5 do arquivo
    # openssl sha1 file.tar.gz           # Gera um checksum sha1 do arquivo
    # openssl rmd160 file.tar.gz         # Gera um checksum RIPEMD-160 do arquivo
    

Instalar Software

Normalmente o gerenciados de pacote utiliza a variável do proxy para as requisições http/ftp requests. Dentro de .bashrc:
export http_proxy=http://proxy_server:3128
    export ftp_proxy=http://proxy_server:3128
    

Listar pacotes instalados

# rpm -qa                            # Lista pacotes instalados (RH, SuSE; baseados em RPM)
    # dpkg -l                            # Debian, Ubuntu
    # pkg_info                           # FreeBSD lista todos os pacotes instalados
    # pkg_info -W smbd                   # FreeBSD mostra a qual pacote o smbd pertence
    # pkginfo                            # Solaris
    

Adicionar/remover software

Front ends: yast2/yast para o SuSE, redhat-config-packages para o Red Hat.
# rpm -i pkgname.rpm                 # instala o pacote (RH, SuSE; baseados em RPM)
    # rpm -e pkgname                     # Remove pacote
    

SuSE zypper (veja doc e cheet sheet)http://en.opensuse.org/SDB:Zypper_usage

# zypper refresh                     # Atualiza o repositório
    # zypper install vim                 # Instala o pacote vim
    # zypper remove vim                  # Remove o pacote vim
    # zypper search vim                  # Busca por pacotes com vim
    # zypper update vim                  # Busca por pacotes com vim
    

Debian

# apt-get update                     # Primeiro, atualize as listas de pacotes
    # apt-get install emacs              # Instala p pacote emacs
    # dpkg --remove emacs                # Remove o pacote emacs
    # dpkg -S file                       # encontra a qual pacote um arquivo pertence
    

Gentoo

Gentoo utiliza o emerge como o coração do seu sistema de gerenciamento de pacote "Portage".
# emerge --sync                      # Primeiro sincronize a arvore local do portage
    # emerge -u packagename              # Instale ou atualize um pacote
    # emerge -C packagename              # Remove o pacote
    # revdep-rebuild                     # Corrige as dependências
    

Solaris

O caminho do <cdrom> normalmente é /cdrom/cdrom0.
# pkgadd -d <cdrom>/Solaris_9/Product SUNWgtar
    # pkgadd -d SUNWgtar                 # Adiciona pacote baixado (bunzip2 primeiro)
    # pkgrm SUNWgtar                     # Remove o pacote
    

FreeBSD

# pkg_add -r rsync                   # Busca e instala o rsync.
    # pkg_delete /var/db/pkg/rsync-xx    # Exclui o pacote rsync
    
Define de onde os pacotes são buscados com a variável PACKAGESITE. Por exemplo:
# export PACKAGESITE=ftp://ftp.freebsd.org/pub/FreeBSD/ports/i386/packages/Latest/ 
    # ou ftp://ftp.freebsd.org/pub/FreeBSD/ports/i386/packages-6-stable/Latest/
    

FreeBSD portshttp://www.freebsd.org/handbook/ports.html

O port tree /usr/ports/ é uma coleção de software pronto para compilar e instalar (veja man ports). Os ports são atualizados com o programa portsnap.
# portsnap fetch extract             # Gera a arvore quando for executado pela primeira vez
    # portsnap fetch update              # Atualiza o port tree
    # cd /usr/ports/net/rsync/           # Seleciona o pacote para instalá-lo
    # make install distclean             # Instala e limpa (veja também no man ports)
    # make package                       # Gera um pacote binário desse port
    # pkgdb -F                           # Corrige a base de dados de registro do pacote
    # portsclean -C -DD                  # Limpa o workdir e o distdir (parte do portupgrade)
    

OS X MacPortshttp://guide.macports.org/ (utilize sudo para todos so comandos)

# port selfupdate                    # Atualiza o port tree (seguro)
    # port installed                     # Lista os ports instalados
    # port deps apache2                  # Lista as dependências para esse port
    # port search pgrep                  # Busca por string
    # port install proctools             # Instala esse pacote
    # port variants ghostscript          # Lista variantes desse port
    # port -v install ghostscript +no_x11# -no_x11 para valor negativo
    # port clean --all ghostscript       # limpa o workdir of port
    # port upgrade ghostscript           # Atualiza esse port
    # port uninstall ghostscript         # Desinstala esse port
    # port -f uninstall installed        # Desinstala tudo
    

Caminho de bibliotéca (Library path)

Devido as dependências complexas e o runtime linking, os programas são difíceis de copiar para outro sistema ou distribuição. No entanto, para programas pequenos com poucas dependências, as bibliotecas que faltam podem ser copiadas. As bibliotecas de tempo de execução (runtime libraries) (e as que faltam) são verificadas com o ldd e gerenciadas com o ldconfig.
# ldd /usr/bin/rsync                 # Lista todas as bibliotecas runtime necessárias
    # otool -L /usr/bin/rsync            # Equivalente ao lss para o OS X
    # ldconfig -n /path/to/libs/         # Adiciona um path para od diretporios das bibliotecas compartilhadas
    # ldconfig -m /path/to/libs/         # FreeBSD
    # LD_LIBRARY_PATH                    # A variável que define a link library path
    

Converte Mídia

Algumas vezes alguém precisa simplesmente converter um arquivo de vídeo, de áudio ou documenta para outro formato.

Text encoding

Text encoding can get totally wrong, specially when the language requires special characters like àäç. The command iconv can convert from one encoding to an other.
# iconv -f <from_encoding> -t <to_encoding> <input_file>
    # iconv -f ISO8859-1 -t UTF-8 -o file.input > file_utf8
    # iconv -l                           # Lista configurações de caracter de coded conhecido
    
Sem a opção -f, iconv utilizará o char-set local, que é normalmente bom se o documento exibe bem.
Converte filenames de uma codificação para outra (não o conteúdo do arquivo). Funciona também se somente alguns arquivos já forem utf8
# convmv -r -f utf8 --nfd -t utf8 --nfc /dir/* --notest

Unix - DOS newlines

Converte newlines DOS (CR/LF) para Unix (LF) e colta para dentro de um shell Unix. Veja também dos2unix e unix2dos caso tiver.
# sed 's/.$//' dosfile.txt > unixfile.txt                  # DOS para UNIX
    # awk '{sub(/\r$/,"");print}' dosfile.txt > unixfile.txt   # DOS para UNIX
    # awk '{sub(/$/,"\r");print}' unixfile.txt > dosfile.txt   # UNIX para DOS
    
Converte newlines do Unix para newlines do DOS dentro de um ambiente Windows. Utilize sed ou awk do mingw ou do cygwin.
# sed -n p unixfile.txt > dosfile.txt
    # awk 1 unixfile.txt > dosfile.txt   # De UNIX para DOS (com o sheel cygwin)
    
Remove newline ^M do mac e substitui para unix new line. Para ebter um ^M utilize CTL-V e depois CTL-M
# tr '^M' '\n' < macfile.txt
    

PDF para Jpeg e concatena arquivos PDF

Converte um documento PDF com o gs (GhostScript) para imagens jpeg (ou png) para cada página. Também bem curto com o convert e o mogrify (do ImageMagick ou GraphicsMagick).
# gs -dBATCH -dNOPAUSE -sDEVICE=jpeg -r150 -dTextAlphaBits=4 -dGraphicsAlphaBits=4 \
     -dMaxStripSize=8192 -sOutputFile=unixtoolbox_%d.jpg unixtoolbox.pdf
    # convert unixtoolbox.pdf unixtoolbox-%03d.png
    # convert *.jpeg imagens.pdf          # Gera um PDF simples com todas as imagens
    # convert imagem000* -resample 120x120 -compress JPEG -quality 80 imagens.pdf
    # mogrify -format png *.ppm          # converte todas as imagens ppm para o formato png
    
Ghostscript pode também concatenar múltiplos arquivos pdf dentro de um único. Isso só funciona bem se os arquivos PDF forem "well behaved".
# gs -q -sPAPERSIZE=a4 -dNOPAUSE -dBATCH -sDEVICE=pdfwrite -sOutputFile=all.pdf \
    file1.pdf file2.pdf ...              # No Windows utilize '#' ao inves de '='
    
Extraia imagens do documento pdf utilizando o pdfimages a partir do poppler ou o xpdfhttp://foolabs.com/xpdf/download.html
# pdfimages document.pdf dst/        # extraia todas as imagens e coloque-as dentro do dst
    # yum install poppler-utils          # instala poppler-utils se necessário. ou:
    # apt-get install poppler-utils
    

Converter vídeo

Comprime o vídeo da digicam Canon com um codec mpeg4 e o som de baixa qualidade (crappy sound).
# mencoder -o videoout.avi -oac mp3lame -ovc lavc -srate 11025 \
    -channels 1 -af-adv force=1 -lameopts preset=medium -lavcopts \
    vcodec=msmpeg4v2:vbitrate=600 -mc 0 vidoein.AVI
    
Veja sox para processamento de som.

Copia um cd de áudio

o programa cdparanoiahttp://xiph.org/paranoia/ pode salvar as faixas de audio (FreeBSD port em audio/cdparanoia/), oggenc pode codificar em formato Ogg Vorbis format, lame converte para mp3.
# cdparanoia -B                      # Copia as faixas para arquivos wav no diretório atual
    # lame -b 256 in.wav out.mp3         # Codifica em mp3 256 kb/s
    # for i in *.wav; do lame -b 256 $i `basename $i .wav`.mp3; done
    # oggenc in.wav -b 256 out.ogg       # Codifica em Ogg Vorbis 256 kb/s
    

Impressão

Imprimir com o lpr

# lpr unixtoolbox.ps                 # Imprime na impressora padrão
    # export PRINTER=hp4600              # Altera a impressora padrão
    # lpr -Php4500 #2 unixtoolbox.ps     # Utiliza a impressora hp4500 e imprime 2 copias
    # lpr -o Duplex=DuplexNoTumble ...   # Imprime duplex em long side
    # lpr -o PageSize=A4,Duplex=DuplexNoTumble ...
    
# lpq                                # Verifica a fila na impressora padrão
    # lpq -l -Php4500                    # Fila na impressora hp4500 com verbose
    # lprm -                             # Remove todos os serviços de usuários da impressora padrão
    # lprm -Php4500 3186                 # Remove o serviço 3186. Encontra serviço nbr c om o lpq
    # lpc status                         # Lista todas as impressoras disponíveis
    # lpc status hp4500                  # Verifica se a impressora está online e o comprimento da fila
    
Alguns dispositivos não são pos script e imprimirão lixo quando alimentados com um arquivo pdf. Isso pode ser resolvido com:
# gs -dSAFER -dNOPAUSE -sDEVICE=deskjet -sOutputFile=\|lpr file.pdf
Imprime para um arquivo PDF mesmo se a aplicação não a suporta. Utilize gs no comando print command ao invés de lpr.
# gs -q -sPAPERSIZE=a4 -dNOPAUSE -dBATCH -sDEVICE=pdfwrite -sOutputFile=/path/file.pdf

Databases

PostgreSQL

Alterar senha do root ou de um usuário (ou username)

# psql -d template1 -U pgsql
    > alter user pgsql with password 'pgsql_password';  # Utilize username ao invés de "pgsql"
    

Cria usuário e database

Os comandos createuser, dropuser, createdb e dropdb são atalhos convenientes equivalentes aos comandos do SQL. O novo usuário é bob com base de dados bobdb ; utilize a base de dados do super usuário como root com o pgsql:
# createuser -U pgsql -P bob         # -P pedirá por senhar
    # createdb -U pgsql -O bob bobdb     # nova bobdb é propriedade de bob
    # dropdb bobdb                       # Exclui a base de dados bobdb
    # dropuser bob                       # Exclui o usuário bob
    
O mecanismo de autenticação da base de dados geral é configurado em pg_hba.conf

Conceder acesso remoto

O arquivo $PGSQL_DATA_D/postgresql.conf especifica em endereço a vinculá-lo. Tipicamente listen_addresses = '*' para Postgres 8.x.
O arquivo $PGSQL_DATA_D/pg_hba.conf define o controle de acesso. Exemplos:
# TYPE  DATABASE    USER        IP-ADDRESS        IP-MASK          METHOD
    host    bobdb       bob        212.117.81.42     255.255.255.255   password
    host    all         all        0.0.0.0/0                           password
    

Fazer backup e restaurar

Os backups e restaurações são feitos com o usuário user pgsql ou postgres. Fazer backup e restaurar uma única base de dados:
# pg_dump --clean dbname > dbname_sql.dump
    # psql dbname < dbname_sql.dump
    
Fazer backup e restorar toda a base de dados (incluindo usuários):
# pg_dumpall --clean > full.dump
    # psql -f full.dump postgres
    
Nesse caso a restauração é iniciada com a base de dados postgres que é melhor quando recarregar um cluster vazio.

MySQL

Alterar senha root ou do usuário do mysql

Método 1

# /etc/init.d/mysql stop
    ou
    # killall mysqld
    # mysqld --skip-grant-tables
    # mysqladmin -u root password 'newpasswd'
    # /etc/init.d/mysql start
    

Método 2

# mysql -u root mysql
    mysql> UPDATE USER SET PASSWORD=PASSWORD("newpassword") where user='root';
    mysql> FLUSH PRIVILEGES;                           # Utilize username ao inves do "root"
    mysql> quit
    

Cria usuário e base de dados (veja MySQL dochttp://dev.mysql.com/doc/refman/5.1/en/adding-users.html)

# mysql -u root mysql
    mysql> CREATE USER 'bob'@'localhost' IDENTIFIED BY 'pwd'; # cria somente um usuário
    mysql> CREATE DATABASE bobdb;
    mysql> GRANT ALL ON *.* TO 'bob'@'%' IDENTIFIED BY 'pwd'; # Utilize localhost ao inves de %
                                                       # para limitar o acesso a rede
    mysql> DROP DATABASE bobdb;                        # Exclui base de dados
    mysql> DROP USER bob;                              # Exclui usuário
    mysql> DELETE FROM mysql.user WHERE user='bob and host='hostname'; # Alt. command
    mysql> FLUSH PRIVILEGES;
    

Conceder acesso remoro

Acesso remoto é tipicamente permitido para uma base de dados, e não todas as bases de dados. O arquivo /etc/my.cnf contem o endereço IP a ser vinculado. (No FreeBSD my.cnf não criada por padrão, copie um arquivo .cnf de /usr/local/share/mysql para /usr/local/etc/my.cnf) Tipicamente comente a linha bind-address = out.
# mysql -u root mysql
    mysql> GRANT ALL ON bobdb.* TO bob@'xxx.xxx.xxx.xxx' IDENTIFIED BY 'PASSWORD';
    mysql> REVOKE GRANT OPTION ON foo.* FROM bar@'xxx.xxx.xxx.xxx';
    mysql> FLUSH PRIVILEGES;                  # Utilize 'hostname' ou também '%' para total acesso
    

realizar backup e restaurar

Backup e restaurar uma única base de dados:
# mysqldump -u root -psecret --add-drop-database dbname > dbname_sql.dump
    # mysql -u root -psecret -D dbname < dbname_sql.dump
    
Realizar backup e restaurar toda a base de dados:
# mysqldump -u root -psecret --add-drop-database --all-databases > full.dump
    # mysql -u root -psecret < full.dump
    
Aqui em "secret" é a senha root do mysql, não há espaço depois do -p. Quando a opção -p é utilizada sosinha (w/o password), a seha é pergunatada no prompt de comando.

SQLite

SQLitehttp://www.sqlite.org é uma base de dados SQL pequena e poderosa independente, sem servidor (serverless), e sem configuração (zero-configuration).

desepejar (Dump) e restaurar

Pode ser útil despejar e restaura uma base de dados SQLite. Por exemplo, você pode editar o arquivo dump para alterar um atributo de coluna ou tipe e depois restaurar a base de dados. Isso é mais fácil do que bagunçar com os comandos do SQL. Utilize o comando sqlite3 para uma base de dados 3.x.
# sqlite database.db .dump > dump.sql              # dump
    # sqlite database.db < dump.sql                    # restaura
    

Converter a base de dados do 2.x para a base de dados do 3.x

sqlite database_v2.db .dump | sqlite3 database_v3.db

Quota de Disco

Uma quota de disco permite limitar a quantidade de espaço em disco e/ou o número de arquivos um usuário (ou membros do grupo) podem usar. As quotas são alocadas em uma base de sistema per-file (por-arquivo) e são impostas pelo kernel.

Configuração no Linux

O pacote de ferramentas de quota geralmente precisa ser instalada, que contem ferramentas em linha de comando.
Ative a quota de usuário no fstab e remonte a partição. Se a partição estiver ocupada, ou todos os arquivos bloqueados devem ser fechados, ou o sistem deve ser reiniciado. Adicione usrquota as opções do montagem do fstab, por exemplo:
/dev/sda2     /home    reiserfs     rw,acl,user_xattr,usrquota 1 1
    # mount -o remount /home
    # mount                              # Verifica se o usrquota está ativo, caso contrario reboot
    
Initialize the quota.user file with quotacheck.
# quotacheck -vum /home
    # chmod 644 /home/aquota.user        # Para deixar os usuários verificarem suas próprias quotas
    
Ativar a quota ou com o script fornecido (ex. /etc/init.d/quotad no SuSE) ou com o quotaon:
quotaon -vu /home
Verificar que a quota está ativa com o:
quota -v

Configuração no FreeBSD

As ferramentas de quota são parte do sistema base, no entanto o kernel precisa da opção quota. Se não estiver la, adicione e recompile o kernel.
options QUOTA
Assim como com o Linux, adicione a quota ás opções do fstab (userquota, não usrquota):
/dev/ad0s1d    /home    ufs     rw,noatime,userquota    2  2
    # mount /home                        # Para remontar a partição
    
Habilita quartos de disco em /etc/rc.conf e inicia a quota.
# grep quotas /etc/rc.conf
    enable_quotas="YES"                  # lig quotas no startup (ou NO).
    check_quotas="YES"                   # Verfica quotas no startup (or NO).
    # /etc/rc.d/quota start
    

Atribuir limites de quota

As quota não são limitadas por padrão (defina a 0). Os limites são definidos com edquota por usuários. Uma quota podem ser duplicadas para muitos usuários.A estrutura de arquivo é diferente entra as implementações de quota, mas o principio é o mesmo: Os valores de blocos e inodes podem ser limitados. Somente altere os valores do soft e hard. Se não especificado, os blocos são de 1k. O grace period é definido com edquota -t. Por exemplo:
# edquota -u colin

Linux

Quotas de disco para o usuário colin (uid 1007):
      Filesystem         blocks       soft       hard     inodes     soft     hard
      /dev/sda8            108       1000       2000          1        0        0
    

FreeBSD

Quotas para os usuário colin:
    /home: kbytes in use: 504184, limits (soft = 700000, hard = 800000)
       inodes in use: 1792, limits (soft = 0, hard = 0)
    

Para muitos usuários

O comando edquota -p é usado para duplicar uma quota á outros usuários. Por exemplo, para duplicar uma quota de referencia a todos os usuários:
# edquota -p refuser `awk -F: '$3 > 499 {print $1}' /etc/passwd`
    # edquota -p refuser user1 user2     # Duplicate to 2 users
    

Verificações

Usuários podem verificar suas quotas ao simplesmente digitar quota (o arquivo quota.user deve ser legivel). O root pode verificar todas as quotas.
# quota -u colin                     # Verfifica quota para um usuário
    # repquota /home                     # relatório total para a partição (para todos os usuários nesse caso)
    

Shells

Muitas distribuições Linux utilizam o shell bash enquanto os BSDs utilizam o tcsh, o bourne shell é utilizado somente para scripts. Filtros são muito uteis e pode ser canalizados: Utilizados todos de uma so vez por exemplo:
# ifconfig | sed 's/  / /g' | cut -d" " -f1 | uniq | grep -E "[a-z0-9]+" | sort -r
    # ifconfig | sed '/.*inet addr:/!d;s///;s/ .*//'|sort -t. -k1,1n -k2,2n -k3,3n -k4,4n
    
O primeiro carácter no parâmetro do sed é uma guia. Para escrever uma guia no console, utilize ctrl-v ctrl-tab.

bash

Redireciona e canaliza para o bash e para o sh:
# cmd 1> file                         # Redireciona a saída padrão (stdout) para o arquivo.
    # cmd 2> file                         # Redireciona o erro padrão (stderr) para o arquivo.
    # cmd 1>> file                        # Redireciona e anexa saída padrão para o arquivo.
    # cmd &> file                         # Redireciona ambas (stdout e stderr) para o arquivo.
    # cmd >file 2>&1                      # Redireciona erro padrão para saída padrão e depois para o arquivo.
    # cmd1 | cmd2                         # canaliza saída padrão para cmd2
    # cmd1 2>&1 | cmd2                    # canaliza stdout e stderr para o cmd2
    
Modificar sua configuração em ~/.bashrc (pode ser também ~/.bash_profile). As seguintes entradas são uteis, recarrega com ". .bashrc". Com o cygwin utilize ~/.bash_profile; com o rxvt cole com o shift + left-click.
# in .bashrc
    bind '"\e[A"':history-search-backward # Utiliza cetas para cima e para baixo para busca
    bind '"\e[B"':history-search-forward  # O history. Inastimável!
    set -o emacs                          # Define o modo emacs no (veja abaixo)
    set bell-style visible                # Não bipa, inverte cores
        # Define um propt agradavel como [user@host]/path/todir>
    PS1="\[\033[1;30m\][\[\033[1;34m\]\u\[\033[1;30m\]"
    PS1="$PS1@\[\033[0;33m\]\h\[\033[1;30m\]]\[\033[0;37m\]"
    PS1="$PS1\w\[\033[1;30m\]>\[\033[0m\]"
    
# Para verificar os apelidos (aliases) ativos atualmente, simplesmente digite alias
    alias  ls='ls -aF'                    # Anexa indicador (um de */=>@|)
    alias  ll='ls -aFls'                  # Listar
    alias  la='ls -all'
    alias ..='cd ..'
    alias ...='cd ../..'
    export HISTFILESIZE=5000              # History maior
    export CLICOLOR=1                     # Utiliza cores (se possivel)
    export LSCOLORS=ExGxFxdxCxDxDxBxBxExEx
    

tcsh

Redirecionar e canlizar para o tcsh e o csh (simples > e >> são os mesmo que no sh):
# cmd >& file                         # Redireciona ambos os padrões (stdout e stderr) para o arquivo.
    # cmd >>& file                        # Uni ambos os padrões (stdout e stderr) para o arquivo.
    # cmd1 | cmd2                         # canaliza a saída padrão para o cmd2
    # cmd1 |& cmd2                        # canaliza saída padrão e de erro para o to cmd2
    
As configurações para o csh/tcsh são definidas em ~/.cshrc, recarregam com o "source .cshrc". Exemplos:
# in .cshrc
    alias  ls      'ls -aF'
    alias  ll      'ls -aFls'
    alias  la      'ls -all'
    alias  ..      'cd ..'
    alias  ...     'cd ../..'
    set   prompt    = "%B%n%b@%B%m%b%/> " # como user@host/path/todir>
    set   history   =  5000
    set   savehist  = ( 6000 merge )
    set   autolist                        # Reporta possíveis conclusões com tab
    set   visiblebell                     # Não bipa, inverte cores
    
# Bindkey and colors
    bindkey -e     Select Emacs bindings  # Utiliza chaves do emacs para editar o prompt de comando
    bindkey -k up history-search-backward # Utilize cetas para cima e para baixo para busca
    bindkey -k down history-search-forward
    setenv CLICOLOR 1                     # Utiliza cores (se possível)
    setenv LSCOLORS ExGxFxdxCxDxDxBxBxExEx
    
O modo do emacs abilita para uso das chaves de atalhos do emacs para modificar o prompt de linha de comando. Isso é extremamente útil (não somente para usuários do emacs). O comandos mais utilizados são: Nota: C- = pressione control, M- = pressione meta (que geralmente é o alt ou a tecla escape).

Scripting

Basicos | Script example | awk | sed | Expressões Regulares | comandos uteis

O shell Bourne (/bin/sh) está presente em todas as instalações Unix e scripts escritos nessa linguagem são (bastante) portáveis; man 1 sh é uma boa referencia.

Basicos

Variaveis e argumentos

Atribui com variável=valor e obtem o conteúdo com $variável
MESSAGE="Hello World"                        # Atribui uma string
    PI=3.1415                                    # Atribui um número decimal
    N=8
    TWON=`expr $N * 2`                           # Expressão aritmética (somente números inteiros)
    TWON=$(($N * 2))                             # Outra syntax
    TWOPI=`echo "$PI * 2" | bc -l`               # Utiliza o bc para operações de ponto flutuante
    ZERO=`echo "c($PI/4)-sqrt(2)/2" | bc -l`
    
Os argumentos de linha de comando
$0, $1, $2, ...                              # $0 é o comando em si 
    $#                                           # O número de argumentos
    $*                                           # Todos os argumentos (também $@)
    

Variáveis especiais

$$                                           # O ID do processo atual
    $?                                           # sai do status do ultimo comando
      command
      if [ $? != 0 ]; then
        echo "command failed"
      fi
    mypath=`pwd`
    mypath=${mypath}/file.txt
    echo ${mypath##*/}                           # Exibe o filename somente
    echo ${mypath%%.*}                           # Caminho completo sem extenção
    foo=/tmp/my.dir/filename.tar.gz
    path = ${foo%/*}                             # Caminho completo sem extensão
    var2=${var:=string}                          # Utiliza var se definido, caso contrario utiliza string
                                                 # atribui string para var e depois para var2.
    size=$(stat -c%s "$file")                    # obtem tamanho do arquivo no script bourne
    filesize=${size:=-1}
    

Constructs

for file in `ls`
    do
        echo $file
    done

    count=0
    while [ $count -lt 5 ]; do
        echo $count
        sleep 1
        count=$(($count + 1))
    done

    myfunction() {
        find . -type f -name "*.$1" -print       # $1 é o primeiro argumento da função
    }
    myfunction "txt"
    

Gerar um arquivo

MYHOME=/home/colin
    cat > testhome.sh << _EOF
    # Tudo isso vai para dentro do arquivo testhome.sh
    if [ -d "$MYHOME" ] ; then
        echo $MYHOME exists
    else
        echo $MYHOME does not exist
    fi
    _EOF
    sh testhome.sh
    

Exemplos de script Bourne

Com um pequeno exemplo, o script utilizado para gerar um livreto PDF a partir desse documento xhtml:
#!/bin/sh
    # Esse script gera um livre em formato pdf pronto para imprimir em uma impressora duplex
    if [ $# -ne 1 ]; then                        # Verifica o argumento
      echo 1>&2 "Usage: $0 HtmlFile"
      exit 1                                     # sai diferente de zero se der erro
    fi

    file=$1                                      # Atribui o filename
    fname=${file%.*}                             # Obtém o nome do arquivo somente
    fext=${file#*.}                              # Obtém a extensão do arquivo

    prince $file -o $fname.pdf                   # Do www.princexml.com
    pdftops -paper A4 -noshrink $fname.pdf $fname.ps # gera livreto postscript
    cat $fname.ps |psbook|psnup -Pa4 -2 |pstops -b "2:0,1U(21cm,29.7cm)" > $fname.book.ps

    ps2pdf13 -sPAPERSIZE=a4 -sAutoRotatePages=None $fname.book.ps $fname.book.pdf
                                                 # utliza #a4 e #Nenhum no Windows!
    exit 0                                       # sair 0 significa sucesso
    

Alguns comandos awk

Awk é util para field stripping, como cortar de um jeito mais poderoso. Busque esse documento para outros exemplos. Veja por exemplo gnulamp.com e one-liners for awk para mais bons exemplos.
awk '{ print $2, $1 }' file                  # Imprime e inverte as primeiras duas colunas
    awk '{printf("%5d : %s\n", NR,$0)}' file     # Adiciona números alinhados a esquerda
    awk '{print FNR "\t" $0}' files              # Adiciona números alinhados a direita
    awk NF test.txt                              # remove linhas em branco (o mesmo que grep '.')
    awk 'length > 80'                            # imprime linha maios que 80 caracteres)
    

Alguns comandos sed

Aqui está a mina de ourohttp://student.northpark.edu/pemente/sed/sed1line.txt. E uma boa introdução e tutorial ao sedhttp://www.grymoire.com/Unix/Sed.html.
sed 's/string1/string2/g'                    # Substituí string1 com string2
    sed -i 's/wroong/wrong/g' *.txt              # Substituí uma palavra recorrente com g
    sed 's/\(.*\)1/\12/g'                        # Modifica anystring1 para anystring2
    sed '/<p>/,/<\/p>/d' t.xhtml                 # Exclui linhas que iniciam com <p>
                                                 # e terminam com </p>
    sed '/ *#/d; /^ *$/d'                        # Remove comentários e linha em branco
    sed 's/[ \t]*$//'                            # Remove trailing espaces (utilize tab como \t)
    sed 's/^[ \t]*//;s/[ \t]*$//'                # Remove leading e trailing spaces
    sed 's/[^*]/[&]/'                            # Cerca primeiro caractere com [] top->[t]op
    sed = file | sed 'N;s/\n/\t/' > file.num     # Numera linhas em um arquivo
    

Expressões regulares

Algumas expressões regulares básicas uteis para o sed também. Veja Syntax Regex Básicashttp://www.regular-expressions.info/reference.html para uma boa impressão.
[\^$.|?*+()                          # carácteres especiais, qualquer outros combinarão entre sim
    \                                    # ignora caráteres especiais e trata-os como literais
    *                                    # repete o item anterior zero ou mais vezes
    .                                    # único carácter exceto caracteres de quebra de linha
    .*                                   # combina zero ou mais caracteres
    ^                                    # combina no inicio de uma linha/string
    $                                    # combina o final de uma linha/string
    .$                                   # combina um único carácter no dinal da linha/string
    ^ $                                  # combina linha com um único espaço
    [^A-Z]                               # combina qualquer linha iniciada com qualquer carácter de A to Z
    

Alguns comandos uteis

O comandos a seguir são uteis para incluir em um script ou como um liners.
sort -t. -k1,1n -k2,2n -k3,3n -k4,4n         # Ordena endereço de ip IPv4
    echo 'Test' | tr '[:lower:]' '[:upper:]'     # Conversão de Case conversion
    echo foo.bar | cut -d . -f 1                 # Retorna foo
    PID=$(ps | grep script.sh | grep bin | awk '{print $1}')    # PID de um script em execução
    PID=$(ps axww | grep [p]ing | awk '{print $1}')             # PID do ping (w/o grep pid)
    IP=$(ifconfig $INTERFACE | sed '/.*inet addr:/!d;s///;s/ .*//')   # Linux
    IP=$(ifconfig $INTERFACE | sed '/.*inet /!d;s///;s/ .*//')        # FreeBSD
    if [ `diff file1 file2 | wc -l` != 0 ]; then [...] fi       # Arquivo alterado?
    cat /etc/master.passwd | grep -v root | grep -v \*: | awk -F":" \ # Gera http passwd
    '{ printf("%s:%s\n", $1, $2) }' > /usr/local/etc/apache2/passwd

    testuser=$(cat /usr/local/etc/apache2/passwd | grep -v \    # Verifica usuário em passwd
    root | grep -v \*: | awk -F":" '{ printf("%s\n", $1) }' | grep ^user$)
    :(){ :|:& };:                                # bash fork bomb. Vai matar a sua máquina
    tail +2 file > file2                         # remove a primeira linha do arquivo
    
I utilizo esse truque para alterar a extensão do arquivo para muitos arquivos de uma vez. Por exemplo de .cxx para .cpp. Testa-o ante sem o | sh no final. Você pode tambem fazer isso com o comando rename se instalado. Ou com o bash builtins.
# ls *.cxx | awk -F. '{print "mv "$0" "$1".cpp"}' | sh
    # ls *.c | sed "s/.*/cp & &.$(date "+%Y%m%d")/" | sh # ex. copia *.c para *.c.20080401
    # rename .cxx .cpp *.cxx                             # Renomeia todos os .cxx para o cpp
    # for i in *.cxx; do mv $i ${i%%.cxx}.cpp; done      # com o bash builtins
    

Programação

Basicos de C

strcpy(newstr,str)                        /* copia str para newstr */
    expr1 ? expr2 : expr3                     /* if (expr1) expr2 else expr3 */
    x = (y > z) ? y : z;                      /* if (y > z) x = y; else x = z; */
    int a[]={0,1,2};                          /* Array inicializada (ou a[3]={0,1,2}; */
    int a[2][3]={{1,2,3},{4,5,6}};            /* Array de array de ints */
    int i = 12345;                            /* Converte de i para char str */
    char str[10];
    sprintf(str, "%d", i);
    

Exemplo de C

Um programa c mínimo simple.c:
#include <stdio.h>
    main() {
        int number=42;
        printf("The answer is %i\n", number);
    }
    
Compile com o:
# gcc simple.c -o simple
    # ./simple
    The answer is 42
    

Básicas do C++

*pointer                                  // Objeto apontado pelo apontador
    &obj                                      // Endereço do objeto obj
    obj.x                                     // Membro x da classe obj (objeto obj)
    pobj->x                                   // Membro x da classe apontado para pobj
                                              // (*pobj).x e pobj->x são os mesmos
    

Exemplo de C++

Como um programa ligeira mete mais realístico em C++: uma classe em seu próprio header (IPv4.h) e implementação (IPv4.cpp) e um programa que utiliza a funcionalidade da classe. A classe converte um endereço de IP em formato integer para o formato quad conhecido.

Classe IPv4

IPv4.h:

#ifndef IPV4_H
    #define IPV4_H
    #include <string>

    namespace GenericUtils {                          // gera um namespace
    class IPv4 {                                      // definição de classe
    public:
        IPv4(); ~IPv4();
        std::string IPint_to_IPquad(unsigned long ip);// interface membro
    };
    } //namespace GenericUtils
    #endif // IPV4_H
    

IPv4.cpp:

#include "IPv4.h"
    #include <string>
    #include <sstream>
    using namespace std;                              // utiliza os namespaces
    using namespace GenericUtils;

    IPv4::IPv4() {}                                   // construtor/destrutor padrão
    IPv4::~IPv4() {}
    string IPv4::IPint_to_IPquad(unsigned long ip) {  // implementação membro
        ostringstream ipstr;                          // utiliza uma stringstream
        ipstr << ((ip &0xff000000) >> 24)             // Bitwise right shift
              << "." << ((ip &0x00ff0000) >> 16)
              << "." << ((ip &0x0000ff00) >> 8)
              << "." << ((ip &0x000000ff));
        return ipstr.str();
    }
    

o programa simplecpp.cpp

#include "IPv4.h"
    #include <iostream>
    #include <string>
    using namespace std;
    int main (int argc, char* argv[]) {
        string ipstr;                                 // define variaveis
        unsigned long ipint = 1347861486;             // O IP em forma integer
        GenericUtils::IPv4 iputils;                   // gera um objeto da classe
        ipstr = iputils.IPint_to_IPquad(ipint);       // chama a classe membro
        cout << ipint << " = " << ipstr << endl;      // imprime o resultado

        return 0;
    }
    
Compile e execute com:
# g++ -c IPv4.cpp simplecpp.cpp                # Compile em objetos
    # g++ IPv4.o simplecpp.o -o simplecpp.exe      # Linka os objetos para o executavel final
    # ./simplecpp.exe 
    1347861486 = 80.86.187.238
    
Utilize ldd para verificar que bibliotecas são utilizadas pelo executável e aonde eles ficam localizados. utilize também para verificar se uma biblioteca compartilhada está faltando ou se o executável é estático.
# ldd /sbin/ifconfig                           # lista dependências de objeto dinâmico
    # ar rcs staticlib.a *.o                       # gera arquivo estático
    # ar t staticlib.a                             # imprime a lista de objetos do arquivo
    # ar x /usr/lib/libc.a version.o               # extrai um objeto arquivo
    # nm version.o                                 # Exibe membros de função fornecidas pelo objeto
    

Simples Makefile

O Makefile mínimo para o programa multi-source é exibido abaixo. As linhas com instruções devem iniciar com um tab! A bara invertida (back slash) "\" pode ser utilizada para cortar linhas longas.
CC = g++
    CFLAGS = -O
    OBJS = IPv4.o simplecpp.o

    simplecpp: ${OBJS}
    	${CC} -o simplecpp ${CFLAGS} ${OBJS}
    clean:
    	rm -f ${TARGET} ${OBJS}
    

Ajuda online

Documentação

Linux Documentation en.tldp.org
Linux Man Pages www.linuxmanpages.com
Linux commands directory www.oreillynet.com/linux/cmd
Linux doc man howtos linux.die.net
FreeBSD Handbook www.freebsd.org/handbook
FreeBSD Man Pages www.freebsd.org/cgi/man.cgi
FreeBSD user wiki www.freebsdwiki.net
Solaris Man Pages docs.sun.com/app/docs/coll/40.10

Outra referências Unix/Linux

Rosetta Stone for Unix bhami.com/rosetta.html (a Unix command translator)
Unix guide cross reference unixguide.net/unixguide.shtml
Linux commands line list www.linuxcmd.org
Short Linux reference www.pixelbeat.org/cmdline.html
Little command line goodies www.shell-fu.org

Isso é tudo pessoal!

Essa documentação: "Unix Toolbox revisão 14.4" está licenciada sob a Creative Commons Licence [Attribution - Share Alike].

Traduzido para o Português do Brasil por Gabriel da Silveira Costa. Revisado por: Rumbler Soppa, Gabriel Almir (kewer), o Gabriel Masson e o Tiago Alvez. Rececbemos também contribuição do João batista, Darleilson e graças ao quadro "Dica de Leitura" recebemos a contribiução do Fábio M. Theofilo.

O Gabriel Masson criou um fork dessa documentação: https://github.com/gmasson/caixaDeFerramentasDoUnix. Assim também como o Tiago Alves criou o seu https://github.com/cegohub/caixaDeFerramentasDoUnix. Desta forma, todas as melhorias e correções serão emergidas nessa documentação, formando assim, a versão atual (uma ótima ideia que o Gabriel Masson teve). Oito pessoas (incluindo Colin Barschel) das quais sou muito grato pelo andamento do projet.