Comandos para manipulação de dados de formatos binários para octave / hex?

Question

Eu preciso converter dados binários para hex / octave / qualquer formato adequado e voltar para o binário quando estou dividindo um grande arquivo de 1GB em arquivos contendo 777 eventos cada, que não são do mesmo tamanho, de modo que cada evento é separado por um string fafafafa no formato hexdump (mas note que este separador pode não existir em telnet-examples, então você pode escolher qualquer string lá para praticar). Estou tentando entender quais desses comandos são adequados para isso, motivados por esta resposta aqui .

A seguinte fonte de dados, binário de telnet, é apenas um exemplo. Eu uso por propósito pseudolevel em comentar sobre as saídas, não confundi-lo com detalhes; Eu tenho documentação completa dos cabeçalhos e suas partes, mas a compreensão deles não é necessária para essa tarefa.

od - v

od -v /usr/bin/telnet | head
0000000 042577 043114 000402 000001 000000 000000 000000 000000
0000020 000003 000076 000001 000000 054700 000000 000000 000000
0000040 000100 000000 000000 000000 073210 000001 000000 000000
0000060 000000 000000 000100 000070 000010 000100 000034 000033
0000100 000006 000000 000005 000000 000100 000000 000000 000000
0000120 000100 000000 000000 000000 000100 000000 000000 000000
0000140 000700 000000 000000 000000 000700 000000 000000 000000
0000160 000010 000000 000000 000000 000003 000000 000004 000000
0000200 001000 000000 000000 000000 001000 000000 000000 000000
0000220 001000 000000 000000 000000 000034 000000 000000 000000

Comentários

• as primeiras strings devem ter algum cabeçalho, mas é estranho que elas passem de 2, 4, 6, 10, ... então acho que isso pode ser uma limitação posterior

hexdump -v

hexdump -v /usr/bin/telnet | head
0000000 457f 464c 0102 0001 0000 0000 0000 0000
0000010 0003 003e 0001 0000 59c0 0000 0000 0000
0000020 0040 0000 0000 0000 7688 0001 0000 0000
0000030 0000 0000 0040 0038 0008 0040 001c 001b
0000040 0006 0000 0005 0000 0040 0000 0000 0000
0000050 0040 0000 0000 0000 0040 0000 0000 0000
0000060 01c0 0000 0000 0000 01c0 0000 0000 0000
0000070 0008 0000 0000 0000 0003 0000 0004 0000
0000080 0200 0000 0000 0000 0200 0000 0000 0000
0000090 0200 0000 0000 0000 001c 0000 0000 0000

Comentários

• numeração da primeira string ok
• algumas letras entre podem ser problemas posteriores para legibilidade
• tamanho diferente da primeira string do que combinações posteriores de quatro letras

hexdump -vb

hexdump -vb /usr/bin/telnet | head
0000000 177 105 114 106 002 001 001 000 000 000 000 000 000 000 000 000
0000010 003 000 076 000 001 000 000 000 300 131 000 000 000 000 000 000
0000020 100 000 000 000 000 000 000 000 210 166 001 000 000 000 000 000
0000030 000 000 000 000 100 000 070 000 010 000 100 000 034 000 033 000
0000040 006 000 000 000 005 000 000 000 100 000 000 000 000 000 000 000
0000050 100 000 000 000 000 000 000 000 100 000 000 000 000 000 000 000
0000060 300 001 000 000 000 000 000 000 300 001 000 000 000 000 000 000
0000070 010 000 000 000 000 000 000 000 003 000 000 000 004 000 000 000
0000080 000 002 000 000 000 000 000 000 000 002 000 000 000 000 000 000
0000090 000 002 000 000 000 000 000 000 034 000 000 000 000 000 000 000

O comando od -v me dá seis strings de letras como 000000 042577 , que eu acho que é um formato de oitava. Outro comando hexdump -v também me dá quatro sequências de letras como 457f 464c , mas com algumas opções de oitava hexdump -vo fornece três palavras de letra como 000000 177 105 ... .

Quais destes comandos são adequados para a manipulação de dados binários, de modo a facilitar a divisão?

    

Answer 1

Dados de teste binário 1GB, discutidos aqui , são criados por

dd if=/dev/urandom of=sample.bin bs=64M count=16

Divisão por posição de byte

Por favor, veja o tópico sobre este aqui . Eu acho que esta é a maneira mais apropriada de fazer a divisão se o byte offset for corrigido. Você precisa determinar os locais dos dois primeiros cabeçalhos de eventos e contar o tamanho do evento. Considere também a cauda do último cabeçalho do evento para saber quando terminar a divisão.

xxd

A resposta está no comentário do FloHimself.

xxd -ps sample.bin | process | xxd -ps -r

od -v

Em od -v , deve-se especificar o formato de saída como o seguinte, com base no comentário de StephenKitt

od -v -t x1 sample.bin

dando

0334260    00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00
0334300    00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00
0334320    00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00
0334340    00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00
0334360    00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00
0334400    00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00
0334420    00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00
0334440    00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00
0334460    00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00
0334500    00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00
0334520    00  00  00  00  00  00  00  00  00  00  00  00  00  00  00  00
0334540

que é mais fácil de manusear.

Comentário sobre a passagem pelo canal Ascii em vez de hexadecimal / oitava

Acho que a conversão de binário para hexadecimal e de volta para binário é suficiente em xxd -ps . Eu fiz base64 sample.bin | less -s -M +Gg , mas notei um processamento e uma saída significativamente mais lentos como este

CGgUAMA0GCSqGSIb3DQEBAQUABIIBABR2EFj76BigPN+jzlGvk9g3rYrHiPKNIjKGprJMaB91ATT6gc0Rs3xlEr6Ybzm8NVcxMnR+2chto/oSh85ExuH4Lk8mELHOIZLeAUUr8eFAXKnZ4SBZ6a8Ewr0x/zX09Bp6IMk18bdVUCT15PT2fbluvJfj7htWCDy0ewm+eU2LIJgkriK8AA0oarqjjK/CIhfglQutfN6QDEp4zqc6tJVqUO7XrEsFlGDOgcPTzeWJuWx31/8MrvEn5HcPzhq+nMI1D6NYjzGhHN08//ObF3z3zthlCDVmowbV161i2LhQ0jy9a/TNyAM0juCR0IF9j7zSyFW0/vvMZYdt5kg1J1EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA