I have the following hex dump: 00000000: 2345 5854 5241 530a 0a31 2e20 746f 2061 #EXTRAS..1. to a 00000010: 6464 2075 7365 723a 2060 7375 646f 2075 dd user: `sudo u 00000020: 7365 7261 6464 205b 7573 6572 6e61 6d65 seradd [username 00000030: 5d60 2061 6e64 2074 6865 6e20 6073 7564 ] and then sud 00000040: 6f20 7061 7373 7764 205b 7573 6572 6e61 o passwd [userna 00000050: 6d65 5d60 2074 6f20 6164 6420 7061 7373 me]` to add pass 00000060: 776f 7264 0a0a 312e 2074 6865 2063 6f6d word..1. the com 00000070: 6d61 6e64 2061 626f 7665 2077 696c 6c20 mand above will 00000080: 6e6f 7420 6164 6420 6120 686f 6d65 2064 not add a home d 00000090: 6972 6563 746f 7279 2066 6f72 2074 6865 irectory for the 000000a0: 2061 6464 6564 2075 7365 720a 0a31 2e20 added user..1. 000000b0: 746f 2067 6976 6520 7468 6520 7573 6572 to give the user 000000c0: 2061 2068 6f6d 6520 6469 7265 6374 6f72 a home director 000000d0: 792c 2069 6e63 6c75 6465 2074 6865 2060 y, include the ` 000000e0: 2d6d 6020 666c 6167 0a0a 0a -m` flag... vim is telling me its 235b and simple command I wrote to count all characters is telling me there are 243 characters: xxd -ps extras.md | sed 's/\(..\)/\1\n/g' | wc -l in addition, the left memory column is telling its taking up: 'd0 + 11 bytes so 219 bytes'? If I'm understanding that right. can someone tie 219, 235 and 243 together for me? or tell me i did everything wrong that works too but let me know how to fix please

I'm using a Mac. In Bash, I'm trying to decode a base64 string and then try to print the Hex value. I'm using base64 -d command and then assigning it to a variable.

myText='YYN29+2wV2XRAHymIyhgytWuqY4atgHnIUFfXA7FPOA='
myTextBytes=$(echo -n "$myText" | base64 --decode)
echo -n $myTextBytes | xxd -p -c 99999

The output of the above script is: > 618376f7edb05765d17ca6232860cad5aea98e1ab601e721415f5c0ec53ce0 However, if i were to run the following command directly:

echo -n "$myText" | base64 --decode | xxd -p -c 100000

I get: > 618376f7edb05765d1**00**7ca6232860cad5aea98e1ab601e721415f5c0ec53ce0 I even tried using openssl enc -base64 and I get the same result. That is, 00 is getting deleted when assigning to a variable. How do I preserve the 00 when I'm assigning it to a variable?

I'm distributing a desktop application and I'm unsure if xxd should be listed as a (build) dependency. My first though was not, since it's documented in the [Linux manpages](https://www.linux.org/docs/man1/xxd.html) and therefore should be available on all Linux machines, shoudln't it? (Correct me if I'm wrong) However I recently received some issues saying that the xxd was missing in their systems (Arch on Steam Deck and Debian). Doing some research found that in some distros the xxd binary is **only** distributed alongside vim as a dependency (See [this](https://discussion.fedoraproject.org/t/which-package-provides-xxd-could-not-figure-it-out/15866) and [this](https://www.reddit.com/r/archlinux/comments/5yznre/xxd_is_missing_in_neovim_package_in_arch_linux/)) , which confuses me even more, so I now depend on vim to be installed? Should I list xxd as a dependency or leave it up to the user to have the binary installed?

On unix if I do

printf "aY.S'Hk([;jYJ}8eJ5)Wsd58/x}s]Pne3V-6:t@" | xxd -p -c 256

I get

61592e5327486b285b3b6a594a7d38654a352957736435382f787d735d50 
6e6533562d363a7440

However on mac os (which is what I want on linux as well) I get

61592e5327486b285b3b6a594a7d38654a352957736435382f787d735d506e6533562d363a7440

I couldn't find any way to prevent xxd from adding a line break to hex output. I have tried sed to remove the line break but it doesn't work. I can't install tr on my unix machine. Is there any way I can create a hex output from my string that doesn't have any line break or whitespace or is there a way to configure xxd on linux to not add any whitespace? Note, I have tried pretty much all the options of xxd with no luck

I wish to dump the raw content of a SD card into a file for inspection. Most parts of it are zeroes. Learnt from this SuperUser answer I could use pv to show the progress of od and hexdump. Both ETA are 1.5 hours. # pv /dev/sdd | od -x --endian=big > sdd_file ... ... ... [> ] ... ETA 1:34:42 and # pv /dev/sdd | hexdump -C > sdd_file ... ... ... [> ] ... ETA 1:35:01 However xxd would need 11 hours. # pv /dev/sdd | xxd -a -u > sdd_file ... ... ... [> ] ... ETA 10:48:53 I prefer xxd mostly because of the -revert possibility. But xxd would take way too long to process a disk. How to format hexdump (or od) to produce the same file format as xxd, so that the file is possible to be -reverted by xxd?

*Long story short:* how to print in a terminal the binary digits constituting a file e.g. a library *.so* or a simple text *.txt* file --- *PC hardware works with electrical signal (basically it's an ON/OFF behaviour) which is well logically translated by the binary system (digits 0s and 1s). Visualizing the content of a file would be an interesting **educational exercise**, as well as comparing a .txt and an executable that prints the same text.*

The hex string 0068732f6e69622f represents the ASCII string /bin/sh, when it's stored in memory in LE-format. Is there any Linux utiltity that will take the hex string and reverse it bytes (2f62696e2f736800), such that xxd -r -ps will display /bin/sh? $ echo -n 0068732f6e69622f | xxd -r -ps hs/nib/ I've looked into xxd -e, but it's not possible to use it with -r: -e little-endian dump (incompatible with -ps,-i,-r).

For showing the content of a file with both formatted text **and** binary data inside in another post on SE I couldn't decide on wheather to show the ASCII rendered output or a the xxd output. As a middle course I thought about a hexdump that **does** respect newlines. (Other) example:

00000000: 636f 6d6d 6974 2031 3933 0074 7265 6520  commit 193.tree
00000010: 3331 3439 3530 3736 3263 6561 3232 3364  314950762cea223d
00000020: 3230 6233 3931 6235 3162 3336 3463 6134  20b391b51b364ca4
00000030: 3165 3636 3234 3931 0a61 7574 686f 7220  1e662491.author
00000040: 4578 616d 706c 6520 5573 6572 203c 6578  Example User  149
00000070: 3831 3236 3633 3320 2b30 3230 300a 636f  8126633 +0200.co
00000080: 6d6d 6974 7465 7220 4578 616d 706c 6520  mmitter Example
00000090: 5573 6572 203c 6578 616d 706c 6575 7365  User  1498126633
000000c0: 2b30 3230 300a 0a69 6e69 740a            +0200..init.

would become

00000000: 636f 6d6d 6974 2031 3933 0074 7265 6520  commit 193.tree
00000010: 3331 3439 3530 3736 3263 6561 3232 3364  314950762cea223d
00000020: 3230 6233 3931 6235 3162 3336 3463 6134  20b391b51b364ca4
00000030: 3165 3636 3234 3931 0a                   1e662491.
                                
00000030:                       61 7574 686f 7220           author
00000040: 4578 616d 706c 6520 5573 6572 203c 6578  Example User  149
00000070: 3831 3236 3633 3320 2b30 3230 300a       8126633 +0200.
                                            
00000070:                                    636f                co
00000080: 6d6d 6974 7465 7220 4578 616d 706c 6520  mmitter Example
00000090: 5573 6572 203c 6578 616d 706c 6575 7365  User  1498126633
000000c0: 2b30 3230 300a                           +0200.

000000c0:                0a                              .

000000c0:                  69 6e69 740a                   init.

or

00000000: 636f 6d6d 6974 2031 3933 0074 7265 6520  commit 193.tree
00000010: 3331 3439 3530 3736 3263 6561 3232 3364  314950762cea223d
00000020: 3230 6233 3931 6235 3162 3336 3463 6134  20b391b51b364ca4
00000030: 3165 3636 3234 3931 0a                   1e662491.
00000030:                       61 7574 686f 7220           author
00000040: 4578 616d 706c 6520 5573 6572 203c 6578  Example User  149
00000070: 3831 3236 3633 3320 2b30 3230 300a       8126633 +0200.
00000070:                                    636f                co
00000080: 6d6d 6974 7465 7220 4578 616d 706c 6520  mmitter Example
00000090: 5573 6572 203c 6578 616d 706c 6575 7365  User  1498126633
000000c0: 2b30 3230 300a                           +0200.
000000c0:                0a                              .
000000c0:                  69 6e69 740a                   init.

or

00000000: 636f 6d6d 6974 2031 3933 0074 7265 6520  commit 193.tree
00000010: 3331 3439 3530 3736 3263 6561 3232 3364  314950762cea223d
00000020: 3230 6233 3931 6235 3162 3336 3463 6134  20b391b51b364ca4
00000030: 3165 3636 3234 3931 0a                   1e662491.
                                61 7574 686f 7220           author
00000040: 4578 616d 706c 6520 5573 6572 203c 6578  Example User  149
00000070: 3831 3236 3633 3320 2b30 3230 300a       8126633 +0200.
                                             636f                co
00000080: 6d6d 6974 7465 7220 4578 616d 706c 6520  mmitter Example
00000090: 5573 6572 203c 6578 616d 706c 6575 7365  User  1498126633
000000c0: 2b30 3230 300a                           +0200.
                         0a                              .
                           69 6e69 740a                   init.

or similar

My tool is wtiting binary chars to stdout and I can view it in hex with # ./md /dev/ttyUSB0 | xxd 0000000: 6f03 1100 0003 0084 8400 0000 0900 0a00 o............... 0000010: 0008 0004 0000 0000 2c00 0000 0000 0000 ........,....... ... 00000b0: 8000 8000 8000 8000 8000 8000 8000 8000 ................ 00000c0: 8047 ffff ff6f 04fd 2180 ff02 f700 f702 .G...o..!....... 00000d0: fbb6 00bf 10e1 a57f 4004 fb00 a780 7e00 ........@. unfortunately, when I am trying to watch this screen watch ./md /dev/ttyUSB0 | xxd watch ./md /dev/ttyUSB0 | hexdump It prints something like either corrupting or misinterpretting output. What do I do wrong?

For an assignment I was given this problem: >What has 8 faces and cannot see? followed by this character set:

412068657861676f6e616c20707269736d21204f6b2c207468617420776173206e6f742066756e6e792e20416e79776179732c206865726520697320796f757220666c61673a0a46537b65696768745f657965735f776f756c645f62655f615f626c696e645f7370696465725f3236313446397d

One of the hints I was given was to identify the character set first. So I was just wondering if anyone can help me identify this set.

I have a binary file type (many instances of these files) where I would like to replace the string "DC-GX850" with "DMC-GX95". Fortunately the two strings are of equal length. The files may be as large as 22MB. Typically the string occurs twice in the file, within the first 1000 bytes. both need to be replaced. My operating system is MacOS 10.14.6, running standard BASH. I have two parts of the solution working, but I am unable to combine them. For my test case, the source file is P1000047.RW2, and the modified file is P1000047D.RW2; "44434d2d47583835" is the hex representation of "DMC-GX95"; 3a4 and 10f0 are the file offsets for the start of the strings for this instance of the file; other files may have different offsets. This code correctly patches the file: echo "3a4: 44434d2d47583835" | xxd -r - P1000047D.RW2 echo "10f0: 44434d2d47583835" | xxd -r - P1000047D.RW2 This code produces the two strings needed for the patch: strings -t x P1000047.RW2 | grep "DC-GX850" | sed s/\ DC-GX850/:\ 44434d2d47583835/ Result: 3a4: 44434d2d47583835 10f0: 44434d2d47583835 However, when I try to combine the two, this code only executes the first patch strings -t x P1000047.RW2 | grep "DC-GX850" | sed s/\ DC-GX850/:\ 44434d2d47583835/ | xxd -r - P1000047D.RW2 I've tried using sed with the -n option but still unable to get it to work. I could of course write the script as a loop, but I'd like to avoid that if possible. Any suggestions?

I'm attempting to start with a file in the following form: ~~~ 00: 42 ; byte 0 is 0x42 / d 01: 52 ; byte 1 is 0x52 / r 02: 62 ; byte 2 is 0x62 / D 03: 72 ; byte 3 is 0x72 / R 07: 1f ; bytes 03..0e are implicitly 00, byte 0f is 0x1f ~~~ and use it to generate an 8-byte file whose values (in hex form) would be: 42 52 62 72 00 00 00 1f The exact input format isn't carved in stone. I just picked ';' as a comment delimiter because it's a single character and unambiguous. The form of the offset: and 2-digit hex value just seemed obvious based on tradition. I suspect the ultimate solution involves using sed or awk to strip away the comment, then piping their output to xxd, but so far my first experiment has fallen flat on its face & I can't even get xxd to parse what ought to be a best-case simple text file. --- For my first attempt, I simplified config.src: ~~~ 00: 42 01: 52 02: 62 03: 72 ~~~ (omitting the comments and implied zero-bytes for now, and sticking to values corresponding to printable ASCII) ... then tried to generate the binary file from it: xxd -r config.src config.bin What I expected to see from cat config.bin and xxd config.bin: BRbr and 00000000: 42 52 62 72 BRbr What I ended up with: a 2-byte file with unprintable content cat can't render, and the following output from xxd config.bin: 00000000: 0301 So... problem #1... *What am I doing wrong with xxd*, and how can I fix it (or is there a better approach)? Keep in mind that I really want to specify one byte value per line, and would really like to be able to automatically skip sequential values and have them automatically filled with zeroes. The... problem #2... once I get xxd to parse my file, how can I go add the comments and strip them away before xxd sees them? Note that I'm not hellbent on using xxd per se... but this is a shared web server to which I don't have root or admin access, so apt-get install isn't an option, and compiling my own copies from source wouldn't necessarily be easy). --- *(Background info... not necessary essential to solving the problem, but adding context to why I'm trying to do it)* I'm working on an Arduino-based IoT controller. For the past few weeks, its configuration has consisted of hardcoded values and various interpretations of a DIP switch I've repurposed every few days. It's getting tedious. I'm not in the mood yet to implement a proper UI, so I came up with the idea of having it just fetch a binary config blob from my web server into a char[] as its first act upon starting up (enabling me to tweak runtime config values without having to go all the way and reflash the board itself, which is honestly kind of a pain at this point).

So Im using emacs which has a stupendous hexl-mode to view the byte offset in a file right over the hex values similar to: 87654321 0011 2233 4455 6677 8899 aabb ccdd eeff 0123456789abcdeff 00000000: 5765 6c63 6f6d 6520 746f 2047 4e55 2045 Welcome to GNU E As a fan of this capability. Wondering if this is a capability I can pull out of in the xxd or hexdump? Or if anybody has an awk script that does this and keeps it lined up properly

I find xxd to be nice and convenient for simple manipulation of binary data in the terminal. However it has a limitation in that all addresses outputted by the program is limited to 32 bits. E.g. root:/# xxd -s 0x5baae0000 /dev/sda baae0000: 2d7c 6176 6976 6172 7c61 7469 7a61 720a -|avivar|atizar. Notice the 5 at the beginning is gone. This means that using this directly with xxd -r will end up patching a region over 10 billion bytes earlier than what I want. In other words I want to e.g. do this, root:/# echo HELLO | xxd -o 0x5baae0000 | xxd -r - /dev/sdb but I end up having to work around this by doing something like this, root:/# echo HELLO | xxd -o 0x5baae0000 | xxd -r -seek 0x500000000 - /dev/sdb which adds back the missing 0x5000000 bytes offset into the target file when parsing the patch. --- In any case I want to know if there is either a unknown/clever way to have xxd use 64 bit addresses or an alternative program that operates like xxd without these limitations?