Eu tenho um disco rígido que ficou ruim e antes de enviá-lo para RMA eu quero limpar o máximo possível dele. Eu tentei usar utilitários do Windows e também fiz dd de / dev / random. O problema é que eu não posso esperar por qualquer uma dessas soluções para terminar como a razão para o RMA é que ele grava a uma velocidade máxima de 1 MB / seg. Levará mais de 140 horas apenas para fazer uma única passagem do disco rígido de 500 GB.
Eu tenho procurado por um utilitário (ou mesmo um script bash no linux) que selecionaria setores aleatoriamente e escreveria dados aleatórios (ou até zeros) nesses setores. Espero que, se eu executar isso por 24 horas, isso limpe aproximadamente 80 GB de dados. Como ele será escolhido aleatoriamente, todos os arquivos maiores serão impossíveis de recuperar e os menores serão apagados, terão partes faltantes ou possivelmente serão recuperáveis. Esta é infelizmente a melhor solução para mim neste momento.
SOLUTION
Graças a "evildead", consegui que muitos dados no disco fossem preenchidos aleatoriamente com lixo de / dev / urandom. O script bash, caso alguém precise, está abaixo:
#!/bin/bash
while (true); do
randnum=${RANDOM}${RANDOM}
number=$((10#$randnum%976773168))
echo -e $number >> progress.txt
dd if=/dev/urandom of=/dev/sdx1 skip=$number count=1
done
Você precisará substituir 976773168 pelo número de blocos em sua unidade. Eu originalmente tentei $ RANDOM no bash, mas é apenas um int de 16 bits e, portanto, é apenas 32k. Como eu precisava de um número acima de 900 Milhões eu combinei dois valores $ RANDOM, então por exemplo se meus números aleatórios são 22.861 e 11.111 eu tenho 2.286.111.111 então encaixando no meu tamanho de bloco eu recebo um valor bastante aleatório no meu range. Não tem entropia perfeita, mas, novamente, o que é realmente aleatório em um computador? ;) O 10 # está lá no caso do primeiro número aleatório ser um 0, ele força o bash a usar a base 10, não a base 8, que é o que ele usa se achar que o número é um octal (zero à esquerda). Eu também escrevo os números aleatórios para um arquivo para análise posterior para ver qual era o spread. Se você não precisa disso, você pode simplesmente tirar
echo -e $number >> progress.txt
e funcionará bem. Também não se esqueça de substituir sdx1 pela unidade ou partição atual em que você deseja trabalhar. Espero que isso seja útil para alguém, sei que foi muito útil para mim.
você pode usar um shellscript em combinação com dd.
por exemplo,
while (true); do
number=$((($RANDOM * 32768 + $RANDOM)))
dd if=/dev/urandom of=/dev/sdx1 seek=$number count=1
done
Você só precisa modificar o número que é generatet de $ RANDOM para caber em seus Blocos.
EDIT 2016: Por favor, note que a solução antiga estava incorreta. Como queremos sobrescrever um byte em uma posição aleatória no fluxo de saída, temos que usar seek em vez de skip, como mencionado nos comentários.
Meu sistema não está corrompido e escrever a partir de /dev/random é de aproximadamente 650Kb / s. Escrevendo de /dev/urandom é 7Kb / s.
Eu trabalhei essa questão para mim e para uma solução puramente bash você tem que ser realista sobre o que seu objetivo é porque a menos que seu objetivo é aprender como fazê-lo em bash porque o ponto é fazer tudo em bash, o objetivo de limpar um disco com segurança é melhor realizado de outras maneiras, embora o bash seja útil na solução.
O algoritmo bash de evildead para selecionar aleatoriamente onde o dd irá gravar no drive funciona, no entanto, o / dev / urandom é significativamente mais lento que / dev / random e eu acho que é menos seguro chupar o drive com pedaços de dados aleatórios e eu acho será mais difícil recuperar dados de uma unidade limpa se você rapidamente fizer dois passos para escrever os zeros.Para mim, escrevi para a unidade com:
tr 'pv < /dev/zero > /dev/sdz
' '7' < /dev/zero | pv > /dev/sdz
então escrevi zeros para a unidade com:
while :; do ./svrandom; done | pv > /dev/sdz
Observe o uso de pv. É um ótimo programa que você tem que instalá-lo na maioria dos sistemas. Fácil de encontrar, não parece vir com uma página de manual, mas existe uma on-line. Ele mostra o progresso dos dados passando por um pipe e com alguns programas você pode até configurá-lo para parar depois que uma certa quantidade de dados é passada.
ENTÃO puramente porque eu estava irritado que nenhuma solução bash iria escrever números aleatórios tão rápido como qualquer uma dessas gravações acima, eu escrevi um pequeno programa em C chamado svrandom para gerar números aleatórios rapidamente que eu chamei de bash da seguinte forma:
/* svrandom
a small program from shadowvision.com September 2015 to generate strings of random numbers.
the default setting of 10000000 gives about 453 megs, adjust as
needed */
#include <stdio.h>
#include <stdlib.h>
int main()
{
int r,a,b;
/* adjust following number as needed to suit your string length */
for(a=0;a<10000000;a++)
{
for(b=0;b<5;b++)
{
r=rand();
printf("%d",r);
}
}
return(0);
}
No meu sistema que preenche o drive / dev / sdz com números aleatórios tão rápido quanto escrever / dev / zero. Objetivo de limpar a unidade com números aleatórios alcançados e bash foi usado na solução.
tr 'pv < /dev/zero > /dev/sdz
' '7' < /dev/zero | pv > /dev/sdz
Na fonte, menciono que você pode controlar o comprimento da sequência numérica aleatória ajustando um número. Se você chamá-lo de um loop while você não terá que, embora possa haver um retorno de carro no final de cada loop, mas se você quiser uma seqüência contínua de apenas o programa, você terá que alterar o número.
recorte! olhando em volta, encontrei essa solução no link
openssl enc -aes-256-ctr -passpass: "$ (dd se = / dev / urandom bs = 128 contador = 1 2 > / dev / null | base64)" -nosalt < / dev / zero | pv > / dev / sd {x}
e como o cara disse, não acredito no quão rápido isso é. Ele está gravando no disco mais rápido do que eu achava que a velocidade máxima de gravação dos discos era.
Parece-me que este comando está usando openssl para criptografar uma cadeia de zeros de / dev / zero usando / dev / urandom como a semente, mas não tenho 100% de certeza. minha solução com o programa C para escrever números aleatórios escreve para o meu sistema a 82mbps, esta solução openssl está escrevendo em 100mbps. uau!
Se você tem um ímã poderoso, pode limpá-lo fisicamente.
Eu desmonto discos rígidos velhos e mortos e obtenho os ímãs da bobina de voz do conjunto de posicionamento da cabeça. Estes são magnetos de terras raras e, de uma típica unidade de 3,5 ", eles são poderosos o suficiente para apagar o suficiente das faixas do servo em um disco rígido, de modo que ele será completamente inutilizável.
De um jeito ou de outro, pegue o ímã, limpe-o para frente e para trás sobre a tampa superior do drive e em menos de um minuto você terá um drive morto. Desde que está sendo RMA de qualquer maneira, eles não deveriam se importar.
Obrigado pela solução no topo!
Como não tenho permissão para comentar a resposta com o script, eu mesmo adiciono meu pequeno aprimoramento.
Eu apenas ajustei um pouco para mais conveniência, de modo que só é preciso definir o dispositivo. O fdisk entregará o número de setores:
#!/bin/bash
# add device to mangle
# example:
# disk=/dev/sde
disk=
# get number of sectors
sectors=$(fdisk $disk -l| head -1| awk '{print $7}')
# run
while (true); do
randnum=${RANDOM}${RANDOM}
number=$((10#$randnum%$sectors))
echo -e $number >> progress.txt
dd if=/dev/urandom of=$disk skip=$number count=1
done
A opção dban é a resposta correta para esse problema.
Escrever dados "aleatórios" de / dev / random terá problemas na maioria dos sistemas, porque você esgotará a entropia no sistema e acabará gravando os dados muito lentamente.
Quase tão "aleatório" quanto a partir de / dev / random é criptografar uma cadeia de zeros com uma senha aleatória. Você pode usar o dd e o openssl para fazer isso, e isso permite que você faça o nuke dos discos tão rápido quanto o sistema é capaz de gravar no disco (ao invés de esperar no / dev / random). Você poderá executar isso de 3 a 5 vezes ao mesmo tempo em que executaria algo que esteja apenas em / dev / random.
dd if=/dev/zero | openssl des > /dev/hda13
Tags hard-drive secure-delete