☰

Как получить формат, подобный hexdump, включающий двоичные строки, в командной строке?

tag-icon • tag-icon linux command-line hexdump
Как получить формат, подобный hexdump, включающий двоичные строки, в командной строке?

Мне очень нравится hexdump, особенно потому, что можно определить собственный формат; например:

$ echo -e '\x00\x01\x02\x03' | hexdump -v -e '1/1 "%_ad: "' -e '4/1 "%02X "' -e '1/1 " : "' -e '4/1 "%_p"' -e '1/1 "\n"'
0: 00 01 02 03 : ....
4: 0A          : .

Итак, я могу выбрать, скажем, 4 байта на строку, записанные сначала как шестнадцатеричные, а затем как символы. Но, чего мне здесь не хватает, так это символа форматирования "двоичной строки" (или "битовой строки"); например, я хотел бы написать что-то вроде -e '4/1 "%08b "'где-то в этой командной строке и получить, например:

0: 00 01 02 03 : 00000000 00000001 00000010 00000011 : ....
4: 0A          : 00001010 : .

Конечно, тогда, вероятно, пришлось бы указывать порядок байтов (если необходимо форматировать группы из более чем одного байта) и т. д. Но в любом случае, насколько я могу судить по руководству, такого форматирования не существует hexdump.

Итак, мой вопрос - какие альтернативы у меня есть в командной строке Linux, чтобы я мог получить форматированный дамп, включающий двоичные строки, как указано выше, и при этом в максимально возможной степени сохраняющий настраиваемость программы hexdump(с точки зрения группировки байтов) при использовании ее -eопции?

решение1

Если программа дампа с подходящими параметрами дампа не справится, вы всегда можете что-то слепить, используя hexdumpи xddи затем объединив вывод с помощью paste. Это некрасиво, но использование оболочки, поддерживающей замену процесса ( bashсделает):

mkfifo fifo
echo -e '\x00\x01\x02\x03' |
  tee fifo |
  paste -d' ' \
    <(hexdump -v -e '1/1 "%_ad: "' -e '4/1 "%02X "' -e '1/1 " :\n"') \
    <(xxd -b -c 4 fifo | cut -d' ' -f 2-)

Выход:

0: 00 01 02 03 : 00000000 00000001 00000010 00000011  ....
4: 0A          : 00001010                             .

решение2

Вот мое предложение с использованием Perl, использующего его спецификаторы форматирования для функции pack()/ unpack(); тестовый вызов будет выглядеть так:

$ echo -e '\x00\x01\x02\x03' | perl hexdump-00.pl --offset 120 --group 4 --add '(H2)*' --add '(B8)*' 
Opening '' STDIN
Cannot seek!
0
00000000: 00 01 02 03 00000000 00000001 00000010 00000011  '....'
00000004: 0a 00001010  '.'

Довольно сложно вставлять строковые маркеры между ними, но приятно то, что вы все равно можете «группировать» байты внутри — например, вы можете сгруппировать два байта и интерпретировать их как знаковое (короткое) целое число, например:

$ perl -e 'print pack("s*\n", (-124))' | hexdump -C
00000000  84 ff                                             |..|
00000002

$ echo -e '\x00\x01\x84\xff' | perl hexdump.pl \
  --offset 120 --group 4 \
  --add '(H2)*' \
  --add '(B8)*' \
  --add '(s2)*'
Opening '' STDIN
Cannot seek!
0
00000000: 00 01 84 ff 00000000 00000001 10000100 11111111 256 -124  '....'
00000004: 0a 00001010  '.'

Вот hexdump-00.pl:

#!/usr/bin/perl

# perl hexdump-00.pl --offset 120 --group 4 --add '(H2)*' --add '(B8)*' test.file

use strict;
use warnings;
use Getopt::Long;
use Fcntl qw(SEEK_CUR SEEK_SET);
my $offset = 0;
my $groupsize = 1;
my $length = 128;
my @list=();
my $result = GetOptions (
  "offset=i" => \$offset,
  "group=i"   => \$groupsize,
  "length=i"   => \$length,
  "add=s" => \@list,
);
my $inputfname="";
my $inputfh;
$inputfname = $ARGV[0] if defined $ARGV[0];
if (($inputfname eq "") || ($inputfname eq "-")) {
  printf(STDERR "Opening '%s' STDIN\n", $inputfname);
  $inputfh = *STDIN;
} else {
  printf(STDERR "Opening '%s'\n", $inputfname);
  open ($inputfh, "<$inputfname");
}

binmode($inputfh);
my $startaddr=0;
if( not(defined($startaddr = sysseek($inputfh, $offset-1, SEEK_SET))) ) {
  printf(STDERR "Cannot seek!\n");
  #~ $startaddr = sysseek($inputfh, 0, 0); // cannot reset like this
  $startaddr = 0; # just avoid errors
}
print(STDERR $startaddr . "\n");

my $buffer=undef;
my $nread;
my $total=0;
while (($nread=sysread($inputfh, $buffer, $groupsize)) > 0) { # , $startaddr
  #~ printf("%08X: nr: %d, buf '%s'\n",$startaddr,$nread,$buffer);
  printf("%08X: ", $startaddr);
  foreach my $tformat (@list) {
    foreach my $tentry (unpack($tformat, $buffer)) {
      printf("%s ", $tentry);
    }
  }
  (my $newbuf = $buffer) =~ s/[^[:print:]]/./g; # make non-printable into '.'
  printf(" '%s'", $newbuf);
  print("\n");
  $startaddr += $nread;
  $total += $nread;
  if ($total > $length) { last; }
}

close($inputfh);

решение3

Вот несколько sedсоветов, которые нужно уговорить dcперевести odвывод в двоичную систему счисления:

od -t d1z -w4 -v -N12 </dev/urandom |
sed -e '1i2o' -e 's/.*/[&]p/p;$d
    s/>/]n [>/;s/[^ ]*/&]n [/;h;s/>.*//;
    s/ -/ _/g;s/ [^] [][^ ]*/ ]n&n [ /g;G
    s/\n[^>]*//' | 
dc

Теперь стало немного проще - не говоря уже о том, что стало быстрее - но все еще не королева красоты. Он также печатает десятичные и двоичные значения всех байтов.

При запуске я получаю:

0000000  -43  125 -117  -39  >.}..<
0000000  -101011   1111101  -1110101   -100111   >.}..<
0000004   62   28   80   61  >>.P=<
0000004   111110    11100    1010000    111101   >>.P=<
0000010    6   14  120  -16  >..x.<
0000010    110    1110   1111000   -10000   >..x.<
0000014

Или...

echo aBcD | od -t d1z -w4 -v | sed ... | dc


0000000   97   66   99   68  >aBcD<
0000000   1100001    1000010    1100011    1000100   >aBcD<
0000004   10                 >.<
0000004   1010                  >.<
0000005

Ширина поля может потребовать немного работы, но это все ваше дело. Вам не нужна эта -N12опция — я просто использовал ее, чтобы не захлебнуться бесконечным потоком псевдослучайных данных. И -w4указывает 4 байта на строку, но вы должны иметь возможность использовать любое количество байтов. Также команда 1i2o sedявляется dcинструкцией относительно ее выходной базы — 2для двоичной — но любая база от 2 до 16 должна работать так же хорошо. Если вы хотите увидеть, например, шестнадцатеричный и двоичный вывод, вам нужно будет добавить '16i' к этому первому sedоператору и изменить odопцию -t d1zна t x1z.

Другие варианты включают в себя...

printf делает это:

printf '%o\n%x\n' 128 128

200

80

...даже...

printf '%o\n%x\n' "'a" "'a"

141

61

Двоичный код не так прост, но bcможет делать все, что нужно, если вы настроите его obase=в соответствии со своими требованиями:

printf 'obase=2;%d
        obase=8;%d
        obase=16;%d
        obase=2;%d
        ' 64 128 "'A" "'a" |
bc

ВЫХОД

1000000
200
41
1100001

dcне такой уж болтливый:

printf '%do%dn10P' 2 64 8 128 16 "'A" 2 "'a" |dc

ВЫХОД

1000000
200
41
1100001

Для получения более подробной информации сделайте это man dc bc.

И опять же, для файловых потоков вы всегда можете использовать od:

for o in o d x ; do
    echo aBcD | 
    od -A n -t ${o}1z -v -w4
done

ВЫХОД

 141 102 143 104  >aBcD<
 012              >.<
  97  66  99  68  >aBcD<
  10              >.<
  61  42  63  44  >aBcD<
  0a              >.<

С^это^один я говорю odне печатать смещения - в чем я сейчас сомневаюсь - что я хочу вывод -tтипа o, d, или xпо одному байту за раз и что я хочу ASCII-представление zкаждого байта, добавленное в конец строки, -vточнее(чтобы он не просто печатал мне 0*for 0000)в -w4байтах на строку.

Без -A nнего печатает:

0000000 141 102 143 104  >aBcD<
0000004 012              >.<
0000005
0000000  97  66  99  68  >aBcD<
0000004  10              >.<
0000005
0000000  61  42  63  44  >aBcD<
0000004  0a              >.<
0000005

И, dc bc odконечно, в |pipeline.

Связанный контент