Camisetas Guanabara.info !! Garanta já a sua!

Automatizando o backup do pendrive no Linux – parte 2

Categorias: Aulas, Linux

4 comente

O script propriamente dito

Então, parti para a solução baseada em cron mesmo. Abaixo vocês vêem o script que escrevi. Maiores explicações ao longo do post:


  1. #!/bin/sh
  2. # Papavirus de Pendrive e Backup automático
  3. # Ricardo Jurczyk Pinheiro
  4. # Baseado no trabalho de Fabiano Caixeta Duarte
  5. # e Welington Rodrigues Braga
  6. DIRETORIO=”$HOME/pendrive/”
  7. LOG=”/var/log/backup.pendrive.log”
  8. ARQUIVODEESTADO=”/tmp/pendrive.estado.txt”
  9. DATA=$(date +%Y%m%d-%H%M)
  10. BLKID=$(which blkid)
  11. UUIDPENDRIVE=”3795-8351″
  12. DEVPENDRIVE=$($BLKID | grep “$UUIDPENDRIVE” | cut -f1 -d”:”)
  13. ESTADO=$(cat $ARQUIVODEESTADO)
  14. # Checa se o UUID existe. Se nao, encerra a execuçao do script.
  15. if [ -z $DEVPENDRIVE ]; then
  16. echo “0″ > $ARQUIVODEESTADO
  17. exit 0
  18. else
  19. if [ $ESTADO -eq 1 ]; then
  20. exit 0
  21. fi
  22. MOUNTPENDRIVE=$(mount | grep $DEVPENDRIVE | cut -f3 -d” “)
  23. echo “$DATA: ——————————————–” >> $LOG
  24. echo “$DATA: Procurando vírus” >> $LOG
  25. # Caçando o autorun.inf e removendo-o.
  26. AUTORUN=$(find $MOUNTPENDRIVE -maxdepth 1 -type f -iname autorun.inf)
  27. if [ -f "$AUTORUN" ]
  28. then
  29. echo “$DATA: Remoção do autorun.inf” >> $LOG
  30. OPENLINE=$(grep -i ^open $AUTORUN)
  31. VIRUS=${OPENLINE:5}
  32. VIRUS=$(find $MOUNTPENDRIVE -name $(basename ${VIRUS//\\//}))
  33. chmod +w $VIRUS
  34. rm $VIRUS 2>/dev/null || (chmod +w $(dirname $VIRUS); rm $VIRUS)
  35. chmod +w $AUTORUN
  36. rm $AUTORUN
  37. sync
  38. else
  39. echo “$DATA: Não há autorun.inf” >> $LOG
  40. fi
  41. # Mesmo sem autorun.inf, o pendrive pode ter um diretorio recycler com binario infectado
  42. RECYCLER=$(find $MOUNTPENDRIVE -iname recycler 2>/dev/null)
  43. if [ -f "$RECYCLER" ]
  44. then
  45. echo “$DATA: Remoção do diretório RECYCLER.” >> $LOG
  46. chmod -R +w $RECYCLER
  47. rm -R $RECYCLER
  48. else
  49. echo “$DATA: Não há diretorio RECYCLER.” >> $LOG
  50. fi
  51. # Backup do pendrive
  52. echo “$DATA: Backup do pendrive.” >> $LOG
  53. # Testa se o diretório existe
  54. if [ ! -d $DIRETORIO ]; then mkdir $DIRETORIO; fi
  55. rsync -raqzp –delete $MOUNTPENDRIVE/* $DIRETORIO
  56. echo “$DATA: Fim.” >> $LOG
  57. echo “1″ > $ARQUIVODEESTADO
  58. fi
  59. sync
  60. exit 0
  61. # MSX r0x a lot
Vamos comentar as linhas:
  • Linhas 1 a 5: O já tradicional “shebang” (#!/bin/sh) para chamar o interpretador e o cabeçalho do script, dando o devido mérito a quem o merece.
  • Linhas 7 a 14: Variáveis criadas. Algumas considerações sobre as variáveis:
    • O diretório para aonde irá o backup do pendrive, na linha 7.
    • O arquivo de log, na linha 8. Afinal das contas, sempre é bom saber o que está acontecendo, mesmo que não apareça nada na tela.
    • Um arquivo de estado, na linha 9. Esse arquivo será útil e explicarei depois.
    • A data do sistema, na linha 10. O que está ao lado do comando date é o formato pelo qual a data será informada, e será usado no arquivo de log.
    • Comandos definidos dentro de variáveis, como na linha 11. Dessa forma, você executará exatamente o comando que você quer executar, o comando which retornará para a variável o caminho absoluto do programa executável. Assim não há risco de executar o que não deve.
    • O UUID do pendrive, na linha 12. O UUID é um número único de identificação para partições, e isso permite que façamos o backup apenas de um único pendrive específico. Maiores informações podem ser lidas em http://en.wikipedia.org/wiki/Universally_unique_identifier.
    • O dispositivo do pendrive, na linha 13. Note que fiz uso do comando definido na linha 11 e da variável da linha 12). Assim teremos o dispositivo exato relacionado ao UUID.
    • A variável que guarda o estado, na linha 14, lendo a partir do arquivo de estado definido na linha 9.
  • Linhas 16 a 23: O comentário já explica tudo, mas vá lá: O script verifica se o pendrive está na máquina. Se não estiver, fim do script (16 a 19). Senão, ele vai ver o arquivo de estado. Se for 1, significa que o backup já foi feito, e o script é encerrado (20 a 23).
  • Linhas 24 a 26: Então, nesse caso, existe um pendrive na máquina, e é o pendrive que queremos investigar e fazer um backup. Descobrimos o ponto de montagem usado (linha 24) e já fazemos algumas entradas no log do sistema (linhas 25 e 26).
  • Linhas 29 a 43: Aqui está a caçada ao arquivo autorun.inf.
    • A variável AUTORUN contém o resultado da busca pelo dito cujo (linha 29). Se há alguma coisa por lá, fazemos a entrada no log e procedemos à etapa de busca pelo autorun.inf.
    • Nas linhas 33 e 34, o arquivo autorun.inf é aberto, e o arquivo que deve ser removido é reconhecido, sendo colocado o seu nome na variável VIRUS.
    • Na linha 35, o arquivo é encontrado, e na linha seguinte, seu atributo de gravação é ligado.
    • Na linha 37, o ataque fulminante: O arquivo é apagado. Note as duas barras verticais (||). Se for um diretório (e não um arquivo), o mesmo é removido também.
    • Nas linhas 38 a 40, o arquivo autorun.inf é removido também, e o pendrive, sincronizado.
    • Nas linhas 41 a 43, mais informações para o log do script, no caso que o autorun.inf não foi encontrado.
  • Linhas 45 a 54: Aqui eu acrescentei a remoção dos diretórios RECYCLER que encontramos nos pendrives. Esse é um nome dado pelo Windows à lixeira, e dessa forma você pode remover algum diretório que não deveria estar lá. Você pode adaptar, por exemplo, para remover os diretórios .Trash-xxx, que o Linux cria nas partições e que funcionam também como lixeira.
  • Linhas 56 a 63: Aqui, a rotina de backup do pendrive.
  • O script verifica se o diretório de backup existe, e se não, cria-o (linha 56).
  • Dali, basta executar o comando rsync para fazer o backup do pendrive para o diretório (linha 61), resultado para o log (linha 62) e o arquivo de estado recebe a marcação de que o pendrive foi copiado (linha 63).
  • Note que o rsync faz o que conhecemos como backup incremental: Apenas as atualizações serão salvas no diretório que guarda o backup. Se você apagar 3 arquivos entre um backup e outro, somente esses 3 arquivos serão apagados no backup. É claro que o primeiro backup é o maior de todos, pois irá copiar todo o conteúdo do pendrive para dentro do micro.

Vamos ao cron

Coloque o script em algum diretório, ligue o atributo de execução (chmod +x <nome do arquivo>), e agende a sua execução no cron. Para fazer isso, basta digitar crontab -e (ou edite o arquivo /etc/crontab), e insira a seguinte linha:
*/1 * * * * <usuário> <caminho para o script>
Sobre o cron, vale dizer que a opção */1 significa que o script será executado uma vez a cada minuto, a todo o tempo. Para evitar a perda de processamento de forma inútil, por isso o uso do arquivo de estado: Se o pendrive já tiver sido copiado, ele é executado e encerrado imediatamente. Se você remover o pendrive, o script só irá checar a existência do pendrive. Se não houver pendrive, ele irá encerrar. Ao recolocar o pendrive posteriormente, na primeira execução será feita a faxina no pendrive novamente, e o backup será atualizado. Ainda no campo <usuário>, você deverá colocar o nome do usuário que irá executar esse script. Note que isso é necessário se você fizer a entrada no /etc/crontab. Se você fizer a mesma entrada no crontab do próprio usuário, não há necessidade de preencher esse campo.

Como melhorar?

É claro que a solução do cron não é a melhor: Eu preferiria associá-la ao udev, e logo quando o pendrive fosse espetado na USB, o serviço seria feito. Seria uma solução mais “limpa”. Mas não funcionou comigo, conforme o que vocês viram no início desse texto. Peço então que todos que fizerem tal modificação nas regras do udev e funcionarem… Que compartilhem como procederam para que funcionasse. Agradeço sugestões!

Um abraço a todos, e que o Linux viva para sempre!

Ricardo Pinheiro

Related Posts with Thumbnails

Comentar