Come posso visualizzare il contenuto binario di un file in modo nativo in Windows 7? (È possibile.)

Ho un file, un po 'più grande di 500 MB, che sta causando alcuni problemi.

Credo che il problema sia nella convenzione di fine linea (EOL) utilizzata. Vorrei guardare il file nella sua forma grezza non interpretata (1) per confermare la convenzione EOL del file.

Come posso visualizzare il "binario" di un file usando qualcosa incorporato in Windows 7? Preferirei evitare di scaricare qualcosa di aggiuntivo.

(1) Io e il mio collega abbiamo aperto il file con editor di testo e mostrano le linee come ci si aspetterebbe. Ma entrambi gli editor di testo apriranno i file con diverse convenzioni EOL e li interpreteranno automagicamente. (TextEdit ed Emacs 24.2. Per Emacs avevo creato un secondo file con solo i primi byte 4K usando head -c4096su una scatola di Linux e l'ho aperto dalla mia finestra di Windows.

Ho provato a usare la modalità hexl in Emacs, ma quando sono passato alla modalità hexl e di nuovo alla modalità testo, il contenuto del buffer era cambiato, aggiungendo un ^ M visibile alla fine di ogni riga, quindi non lo sono confidando che al momento.

Credo che il problema potrebbe riguardare i caratteri di fine riga utilizzati. I redattori che io e il mio collega abbiamo provato (1) ha appena riconosciuto automagicamente la convenzione di fine linea e ci ha mostrato le linee. E sulla base di altre prove credo che la convenzione EOL sia solo di ritorno in carrozza. (2) solo ritorno.

Per sapere cosa c'è effettivamente nel file, vorrei guardare il contenuto binario del file, o almeno un paio di migliaia di byte del file, preferibilmente in esadecimale, anche se potrei lavorare con decimale o ottale. Solo quelli a zeri sarebbero piuttosto difficili da guardare.

AGGIORNARE

Tranne quello che suggerisce DEBUG, tutte le risposte di seguito funzionano in un modo o nell'altro. Ho votato ciascuno di questi come utili. La mia domanda era mal formata. Nel testare ogni soluzione suggerita, ho scoperto che volevo davvero fianco a fianco esadecimale e visualizzare i contenuti del testo e che volevo che fosse qualcosa in cui quando avevo il cursore su qualcosa, un valore in byte o un carattere di testo, la cosa corrispondente sul l'altro lato sarebbe evidenziato.

In realtà ho risolto il mio problema quando Emacs hexl-mode ha iniziato a funzionare "correttamente". Così ho finito per non usare nessuna di queste risposte, ma solo per testarle (dovrei davvero indagare sul strano comportamento di Emacs e presentare una segnalazione di bug).

Hai bisogno di un "editor esadecimale". Ho usato "Hex Editor Neo" per anni ed è molto buono. È disponibile in versioni gratuite ea pagamento . (E sono sicuro che ci sono altri strumenti simili disponibili.)

Se si dispone della versione 5.0 o successiva di PowerShell, è possibile utilizzare la powershellfunzione integrataFormat-Hex

PS:21 C:\Temp >Format-Hex application.exe

            0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F

00000000   42 4D 5E 00 00 00 00 00 00 00 36 00 00 00 28 00  BM^.......6...(. 
00000010   00 00 0A 00 00 00 01 00 00 00 01 00 20 00 00 00  ............ ... 
00000020   00 00 00 00 00 00 C4 0E 00 00 C4 0E 00 00 00 00  ......Ä...Ä..... 
00000030   00 00 00 00 00 00 B7 59 71 FF B7 59 71 FF B7 59  ......•Yq.•Yq.•Y 
00000040   71 FF B7 59 71 FF B7 59 71 FF B7 59 71 FF B7 59  q.•Yq.•Yq.•Yq.•Y 
00000050   71 FF B7 59 71 FF B7 59 71 FF B7 59 71 FF        q.•Yq.•Yq.•Yq.

Integrato, veloce e sporco: avvia powershell, esegui:

gc -encoding byte -TotalCount 100 "your_file_path" |% {write-host ("{0:x}" -f $_) -noNewline " "}; write-host   

TotalCount è il conteggio dei byte che si desidera leggere dal file.

'Powdhell ​​hexdump' di Google per ottenere versioni molto più raffinate / realizzabili.

Se disponi di strumenti di Windows Resource Kit (non esattamente integrati, ma vicini) puoi anche usare un'utilità di linea cmd chiamata list.exe. È un piccolo editor con modalità esadecimale. Progettato specificamente per funzionare con file di grandi dimensioni:

Strumento Elenco file di testo (Elenco) è uno strumento da riga di comando che consente di visualizzare e cercare uno o più file di testo. A differenza di altri strumenti di visualizzazione del testo, Elenco non legge l'intero file in memoria quando lo si apre. Consente a un utente di modificare un file di testo in formato esadecimale.

L'elenco è utile per visualizzare file di testo o di registro in remoto e per l'uso su server in cui gli amministratori si preoccupano del degrado delle prestazioni del sistema.

Questo funziona anche su tutto dopo XP:

certutil -encodehex MyProgram.exe MyProgram.txt

XP richiede il pacchetto di strumenti di amministrazione di Windows Server 2003 da qui:

https://www.microsoft.com/en-us/download/details.aspx?id=16770

Copia il file su un nome con .COMun'estensione, in cui il nome di base non è più lungo di otto caratteri. Correre

DEBUG your_filename

Darà un ' -' prompt. genere

DEnter

ripetutamente d isplay file 128 byte alla volta. genere

D indirizzo Enter

per visualizzare 128 byte a partire dall'indirizzo , che deve essere digitato in esadecimale, dove l'inizio del file è l'indirizzo 100. Digitare

D indirizzo ₁ indirizzo ₂ Enter

visualizzare da indirizzo ₁ a indirizzo ₂ . genere

D indirizzo Lnum Enter

per visualizzare num byte (lunghezza) a partire dall'indirizzo .  num è anche inserito in esadecimale. Usa Qper uscire.

Per esempio,

C:\Users\scott\Documents> debug thispost.com
-d
0BE4:0100  43 6F 70 79 20 74 68 65-20 66 69 6C 65 20 74 6F   Copy the file to
0BE4:0110  20 61 20 6E 61 6D 65 20-77 69 74 68 20 61 20 2E    a name with a .
0BE4:0120  43 4F 4D 20 65 78 74 65-6E 73 69 6F 6E 2C 20 77   COM extension, w
0BE4:0130  68 65 72 65 20 74 68 65-20 62 61 73 65 20 6E 61   here the base na
0BE4:0140  6D 65 20 69 73 20 6E 6F-20 6C 6F 6E 67 65 72 20   me is no longer
0BE4:0150  74 68 61 6E 20 65 69 67-68 74 20 63 68 61 72 61   than eight chara
0BE4:0160  63 74 65 72 73 2E 0D 0A-52 75 6E 20 44 45 42 55   cters...Run DEBU
0BE4:0170  47 20 2A 79 6F 75 72 5F-66 69 6C 65 6E 61 6D 65   G *your_filename
-d
0BE4:0180  2A 0D 0A 49 74 20 77 69-6C 6C 20 67 69 76 65 20   *..It will give
0BE4:0190  61 20 27 2D 27 20 70 72-6F 6D 70 74 2E 0D 0A 54   a '-' prompt...T
0BE4:01A0  79 70 65 20 44 20 45 6E-74 65 72 20 72 65 70 65   ype D Enter repe
0BE4:01B0  61 74 65 64 6C 79 20 74-6F 20 2A 2A 64 2A 2A 69   atedly to **d**i
0BE4:01C0  73 70 6C 61 79 20 74 68-65 20 66 69 6C 65 20 31   splay the file 1
0BE4:01D0  32 38 20 62 79 74 65 73-20 61 74 20 61 20 74 69   28 bytes at a ti
0BE4:01E0  6D 65 2E 0D 0A 54 79 70-65 20 44 20 5F 61 64 64   me...Type D _add
0BE4:01F0  72 65 73 73 5F 20 74 6F-20 64 69 73 70 6C 61 79   ress_ to display
-d 200 L16
0BE4:0200  20 31 32 38 20 62 79 74-65 73 20 73 74 61 72 74    128 bytes start
0BE4:0210  69 6E 67 20 61 74                                 ing at
-

HxD è un editor esadecimale portatile, il che significa che non è necessaria alcuna installazione, e non è altro che un singolo file exe.

http://mh-nexus.de/en/hxd/

Un'altra opzione altrettanto portatile è Frhed:

http://frhed.sourceforge.net/en/screenshots/

Poiché Windows 7 viene fornito con il dotnet framework 3.5 integrato, avrai il compilatore C # incorporato, quindi puoi prendere, ad esempio, l'elenco da http://illegalargumentexception.blogspot.co.uk/2008/04/c- file-hex-dump-application.html e quindi compilare usando

  \windows\Microsoft.NET\Framework\v3.5\csc printhex.cs 

e dovresti finire con un printhex.exe che dovrebbe mostrare sia caratteri esadecimali che ascii.

Non è l'ideale, ma se davvero non vuoi scaricare nulla, puoi provare a usare fc / b (cioè confronto dei file in modalità binaria) per confrontare questo file con un altro file completamente diverso, e ti mostrerà l'esadecimale valori di ogni byte diverso. Potresti ottenere alcuni valori che sono uguali nei due file e quindi potrebbero essere saltati dall'output, ma puoi capire se ciò accade verificando i valori mancanti nella colonna offset.

È possibile utilizzare la funzione PowerShell di seguito insieme a Get-Content per visualizzare un dump esadecimale del contenuto del file, ad esempio Get-Content -Encoding Byte 'MyFile.bin' | Format-HexDump. Sono necessari circa 23 secondi per scaricare un file da 222 KB e, se lo si desidera, l'output può essere reindirizzato a un file di testo per facilitare l'esame del dump.

$encodingAutoCompleter = {
    param($commandName, $parameterName, $wordToComplete, $commandAst, $fakeBoundParameters)
    $availableEncodings = ([System.Text.Encoding]::GetEncodings() | Select Name, CodePage, DisplayName) + @( [PSCustomObject] @{ CodePage = '20127'; Name = 'ascii'; DisplayName = 'US-ASCII' }, [PSCustomObject] @{ CodePage = '1200'; Name = 'unicode'; DisplayName = 'Unicode' } )
    $availableEncodings | ?{ $_.Name.StartsWith($wordToComplete) } | %{ New-Object System.Management.Automation.CompletionResult -ArgumentList $_.Name, $_.Name, 'ParameterValue', "$($_.DisplayName). Code Page $($_.CodePage)." }
}

function Format-BufferText([byte[]] $buffer, [System.Text.Encoding] $displayEncoding, [switch] $useControlPictures)
{
    $bufferChars = $displayEncoding.GetChars($buffer);
    $bufferText = (($bufferChars | %{ if ([char]::IsControl($_) -eq $true) { if ($useControlPictures -eq $false) { '.' } else { [char] ($_.ToInt16([cultureinfo]::InvariantCulture) + 0x2400) } } else { "$_" } }) -join "")

    $bufferText
}

<#
    .Synopsis
    Displays binary data as a hexadecimal dump.

    .Description
     Displays binary data as a hexadecimal dump. Options are available to suppress displaying text and to display control characters 
     as Unicode Control Pictures instead of dots.

    .Parameter Bytes
    The bytes to be displayed.

    .Parameter Encoding
    The name of the text encoding to use. The default is ascii.

    .Parameter NoTextDisplay
    If specified the text display sidebar will be suppressed; otherwise, the display text sidebar will be present.

    .Parameter UseControlPictures
    If specified control characters will be displayed as Unicode Control pictures; otherwise, dots are used to represent control 
    characters.

    .Example
    Format-HexDump -Encoding unicode $bytes

    .Example
    Get-Content -Encoding Byte 'MyFile.bin' | Format-HexDump -Encoding unicode

    .Example
    0..255 | Format-HexDump -NoTextDisplay
#>
function Format-HexDump
{
    [CmdletBinding()]
    param
    (
        [Parameter(ValueFromPipeline = $true, ValueFromPipelineByPropertyName = $true)]
        [byte[]] $Bytes,
        [ValidateScript({ if (([System.Text.Encoding]::GetEncodings().Name + @('unicode', 'ascii')) -icontains $_) { return $true } else { Throw "Encoding must be one of the following: $([System.Text.Encoding]::GetEncodings().Name -join ', '), unicode, or ascii." } })]
        [Parameter(ValueFromPipeline = $false)]
        [string] $Encoding = "ASCII",
        [Parameter()]
        [switch] $NoTextDisplay,
        [Parameter()]
        [switch] $UseControlPictures
    )

    BEGIN
    {
        $displayEncoding = [System.Text.Encoding]::GetEncoding($Encoding)

        $counter = 0
        $hexRow = ""
        [byte[]] $buffer = @()
    }

    PROCESS
    {
        foreach ($byte in $Bytes)
        {
            $buffer += $byte
            $hexValue = $byte.ToString("X2")

            if ($counter % 16 -eq 0)
            {
                $buffer = @($byte)
                $hexRow = "$($counter.ToString("X8")): $($hexValue) "
            }
            elseif ($counter % 16 -eq 15)
            {
                if ($NoTextDisplay -eq $true)
                {
                    $hexRow += "$($hexValue)"
                    $hexRow
                }
                else
                {
                    $bufferText = Format-BufferText $buffer $displayEncoding $UseControlPictures
                    $hexRow += "$($hexValue)   $($bufferText)"
                    $hexRow
                }
            }
            else
            {
                $hexRow += "$($hexValue) "
            }

            $counter++
        }
    }

    END
    {
        $counter--

        if ($counter % 16 -ne 15)
        {
            $hexRow += " " * (((16 - $counter % 16) * 3) - 1)

            if ($NoTextDisplay -eq $false)
            {
                $bufferText = Format-BufferText $buffer $displayEncoding $UseControlPictures
                $hexRow += "$($bufferText)"
            }

            $hexRow
        }
    }
}

Register-ArgumentCompleter -CommandName Format-HexDump -ParameterName Encoding -ScriptBlock $encodingAutoCompleter

L'output è simile al seguente:

00000000: 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F   ................
00000010: 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F   ................
00000020: 20 21 22 23 24 25 26 27 28 29 2A 2B 2C 2D 2E 2F    !"#$%&'()*+,-./
00000030: 30 31 32 33 34 35 36 37 38 39 3A 3B 3C 3D 3E 3F   0123456789:;<=>?
00000040: 40 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F   @ABCDEFGHIJKLMNO
00000050: 50 51 52 53 54 55 56 57 58 59 5A 5B 5C 5D 5E 5F   PQRSTUVWXYZ[\]^_
00000060: 60 61 62 63 64 65 66 67 68 69 6A 6B 6C 6D 6E 6F   `abcdefghijklmno
00000070: 70 71 72 73 74 75 76 77 78 79 7A 7B 7C 7D 7E 7F   pqrstuvwxyz{|}~.
00000080: 80 81 82 83 84 85 86 87 88 89 8A 8B 8C 8D 8E 8F   ????????????????
00000090: 90 91 92 93 94 95 96 97 98 99 9A 9B 9C 9D 9E 9F   ????????????????
000000A0: A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 AA AB AC AD AE AF   ????????????????
000000B0: B0 B1 B2 B3 B4 B5 B6 B7 B8 B9 BA BB BC BD BE BF   ????????????????
000000C0: C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 CA CB CC CD CE CF   ????????????????
000000D0: D0 D1 D2 D3 D4 D5 D6 D7 D8 D9 DA DB DC DD DE DF   ????????????????
000000E0: E0 E1 E2 E3 E4 E5 E6 E7 E8 E9 EA EB EC ED EE EF   ????????????????
000000F0: F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 FA FB FC FD FE FF   ????????????????

Dato che Sublime è il mio editor preferito, uso il suo plugin per visualizzare i file esadecimali. http://facelessuser.github.io/HexViewer/

So che stai usando Emacs ma gli utenti di Vim possono usare l' xxdutilità:

xxd -s <start_offset> -l <length_offest> <file>

vale a dire

Usage:
       xxd.exe [options] [infile [outfile]]
    or
       xxd.exe -r [-s [-]offset] [-c cols] [-ps] [infile [outfile]]
Options:
    -a          toggle autoskip: A single '*' replaces nul-lines. Default off.
    -b          binary digit dump (incompatible with -ps,-i,-r). Default hex.
    -c cols     format <cols> octets per line. Default 16 (-i: 12, -ps: 30).
    -E          show characters in EBCDIC. Default ASCII.
    -g          number of octets per group in normal output. Default 2.
    -h          print this summary.
    -i          output in C include file style.
    -l len      stop after <len> octets.
    -ps         output in postscript plain hexdump style.
    -r          reverse operation: convert (or patch) hexdump into binary.
    -r -s off   revert with <off> added to file positions found in hexdump.
    -s [+][-]seek  start at <seek> bytes abs. (or +: rel.) infile offset.
    -u          use upper case hex letters.
    -v          show version: "xxd V1.10 27oct98 by Juergen Weigert (Win32)".