Visualizando os bits brutos do disco

Question

Existe um comando que me permite "ver" os bits brutos de um disco? Em outras palavras, ignorar o sistema de arquivos e gerar a "imagem grande" dos zeros e dos literais, conforme o disco. (O ideal é não exigir um armazenamento temporário de tamanho de TB).

O que estou realmente procurando é uma maneira de saber facilmente se as seções do disco contêm seqüências repetitivas simples , como todas as 0 s, todas 1 s, todas 01 s, todos 0101011 s, etc, etc.

Qual é a melhor maneira de fazer isso?

    

Answer 1

Sparklines podem ajudar ... primeiro obter o spark util e instale o most text viewer .

1. Este hack exibe uma visão abstrata dos primeiros 61 setores de / dev / sda :

   for f in 'seq 0 1 60' ; do :
       printf "%.03i %s\n" $f \
           $({   printf '4294967295\n'
                 sudo dd if=/dev/sda skip=$f bs=512 count=1 2> /dev/null |
                 od -v -A n -t uI ; } | 
              spark | sed 's/^.//' )
   done | most
   

   Saída no meu sistema (abreviadas primeiro duas linhas):

   000 ▁▁▁▃▆▆▁▁▄▇▂▆▁▁▆▁▁▁▄▄▄▁ ...
   001 ▁▆▃▇▂▁▁▁▄▃▆▂▄▂▁▁▁▁▁▁▁▂ ...
   

   Cada linha representa um setor de disco. Linhas curtas são números pequenos, linhas altas são números grandes. Cada sparkline char aqui representa um inteiro sem sinal, (4 bytes), que é relativamente compacto. Se isso não cabe tudo na tela em most , use a direita e a esquerda setas para rolar para o lado.

   Para ver como são os dados vazios, substitua o /dev/sda por /dev/zero .

   O código acima pode ser usado para percorrer um disco, apenas alterando o seq valores. Use sudo hdparm -i /dev/sda | grep CurCHS para obter o cilindro (faixas), cabeças e números do setor, que no meu sistema retorna:

   CurCHS=16383/16/63, CurSects=16514064, LBA=yes, LBAsects=312581808
   

   Isso significa que todo setor 16383rd é o primeiro setor de um (virtual) faixa. Para um disco quase vazio em disco, estes mostrariam onde os dados acabam.

   Alterar o seq acima para seq 0 16383 $((16383*60)) mostraria os primeiros setores das primeiras 61 faixas no disco.

   Para que o sparkline mostre apenas 1 byte por caractere, altere 4294967295 para 255 e uI para uC .

   Notas sobre como o código funciona:

   dd envia um setor de dados 512 bytes para od , que gera inteiros sem sinal, que é o maior número que spark compreende.

   spark usa alturas relativas calculadas a partir da entrada, (tente spark <<< '1 2 3 4' para ver como funciona), o que significa que, a menos que haja levando o número máximo, as diferentes linhas poderiam ser para diferentes escalas. Para evitar enganar diferentes escalas, printf é usado para prefixar o máximo correto, o que faz com que spark use um valor consistente escala, mas deixa para trás um primeiro caracter alto indesejado, que é mais tarde removido com sed .

2. Uma técnica semelhante pode mostrar uma visão geral difusa da densidade de dados de um disco ou partição. Em vez de abstrair um alguns bytes em um caractere de centelha, abstraem uma amostra de blocos , ou melhor, as taxas de compressão relativas de uma amostragem de blocos.

   Mais dois utilitários são necessários: pigz , (para a maioria compactação zlib sem cabeçalho pv . pv é realmente opcional, mas uma barra de progresso torna a espera menos entediante.

   O código:

   d=sda b=512 c=1 m=$(( (512*$(</sys/block/${d/s???*/${d%%[0-9]*}/$d}/size))/b )) \
   s=200 i=$((m/s)) ; \
   for ((f=0;f<m;f+=i)) ; do 
      sudo dd if=/dev/${d} skip=$f bs=$b count=$c 2> /dev/null | 
      pigz -9z | 
      wc -c
   done | pv -l -s $s -i "0.1" \
             -F 'Read %b of '"$((s+1)) $((b*c))-byte"' blocks %p%e' | 
   spark
   

   Saída (no meu HD):

   Read  201  of 201 512-byte blocks [=====================================>] 100%
   ▇███▁█▂██▃█▆▂▂██▃▆███▆█▅▁█████▇▂▇▂▁▇▂▂▂▆▄█▃▅█▁▄█▃▅▅▅▃▃▂▅
   ▃▂█▆▅▇▁▅▃▆▄▁█▃▇▁▁▂▂▅█████▇█████████▆█████████▅█▁████████
   ███████████████████████▆███████▆██▃███████▁████████▂███▂
   ▁▁▁▁▂▂▂▂██████████▁█▁▁▅▃▁▃█▂▅▄▅▁▁
   

   O disco rígido $d é dividido em 200 ( $s ) partes e o primeiro bloco de cada parte é compactado com pigz , canalizado para wc para um byte contar, e a lista de números resultante é alimentada para spark .

   Os caracteres 200 spark representam as densidades de dados de 200 512 bytes blocos de amostra. Os caracteres preenchidos são blocos com dados densos que não são compactados, os caracteres mais curtos são dados esparsos que é bastante compressível.

   Defina s=2000 para uma visualização mais significativa. As variáveis estão todas em o começo, e pode ser ajustado conforme desejado. Aumente $b (mas somente da forma 512 * 2 ^ n ) ou $c para ler amostras maiores. É interessante que aumentar os tamanhos de amostra (ler um bloco 8K em vez de 512 byte ) geralmente desenha um sparkline muito semelhante, o que implica um 512 byte bloco é bom o suficiente ...

Answer 2

dd if=/dev/sda | hd | less

Isso produzirá todo o conteúdo do disco em hexadecimal, uma tela cheia por vez. Longas corridas da mesma sequência byte serão anotadas e ignoradas.