Automatizando o backup do pendrive no Linux – parte 2

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
7. DIRETORIO=”$HOME/pendrive/”
8. LOG=”/var/log/backup.pendrive.log”
9. ARQUIVODEESTADO=”/tmp/pendrive.estado.txt”
10. DATA=$(date +%Y%m%d-%H%M)
11. BLKID=$(which blkid)
12. UUIDPENDRIVE=”3795-8351″
13. DEVPENDRIVE=$($BLKID | grep “$UUIDPENDRIVE” | cut -f1 -d”:”)
14. ESTADO=$(cat $ARQUIVODEESTADO)
16. # Checa se o UUID existe. Se nao, encerra a execuçao do script.
17. if [ -z $DEVPENDRIVE ]; then
18. echo “0″ > $ARQUIVODEESTADO
19. exit 0
20. else
21. if [ $ESTADO -eq 1 ]; then
22. exit 0
23. fi
24. MOUNTPENDRIVE=$(mount | grep $DEVPENDRIVE | cut -f3 -d” “)
25. echo “$DATA: ——————————————–” >> $LOG
26. echo “$DATA: Procurando vírus” >> $LOG
28. # Caçando o autorun.inf e removendo-o.
29. AUTORUN=$(find $MOUNTPENDRIVE -maxdepth 1 -type f -iname autorun.inf)
30. if [ -f "$AUTORUN" ]
31. then
32. echo “$DATA: Remoção do autorun.inf” >> $LOG
33. OPENLINE=$(grep -i ^open $AUTORUN)
34. VIRUS=${OPENLINE:5}
35. VIRUS=$(find $MOUNTPENDRIVE -name $(basename ${VIRUS//\\//}))
36. chmod +w $VIRUS
37. rm $VIRUS 2>/dev/null || (chmod +w $(dirname $VIRUS); rm $VIRUS)
38. chmod +w $AUTORUN
39. rm $AUTORUN
40. sync
41. else
42. echo “$DATA: Não há autorun.inf” >> $LOG
43. fi
45. # Mesmo sem autorun.inf, o pendrive pode ter um diretorio recycler com binario infectado
46. RECYCLER=$(find $MOUNTPENDRIVE -iname recycler 2>/dev/null)
47. if [ -f "$RECYCLER" ]
48. then
49. echo “$DATA: Remoção do diretório RECYCLER.” >> $LOG
50. chmod -R +w $RECYCLER
51. rm -R $RECYCLER
52. else
53. echo “$DATA: Não há diretorio RECYCLER.” >> $LOG
54. fi
56. # Backup do pendrive
57. echo “$DATA: Backup do pendrive.” >> $LOG
59. # Testa se o diretório existe
60. if [ ! -d $DIRETORIO ]; then mkdir $DIRETORIO; fi
61. rsync -raqzp –delete $MOUNTPENDRIVE/* $DIRETORIO
62. echo “$DATA: Fim.” >> $LOG
63. echo “1″ > $ARQUIVODEESTADO
64. fi
65. sync
66. exit 0
67. # 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 emhttp://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 ), 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 * * * *

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 , 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!

Fonte:Guanabara.info