Format-Hex

  • Referência
Módulo:
Microsoft.PowerShell.Utility

Exibe um arquivo ou outra entrada como hexadecimal.

Sintaxe

Format-Hex
      [-Path] <String[]>
      [-Count <Int64>]
      [-Offset <Int64>]
      [<CommonParameters>]
Format-Hex
      -LiteralPath <String[]>
      [-Count <Int64>]
      [-Offset <Int64>]
      [<CommonParameters>]
Format-Hex
      -InputObject <PSObject>
      [-Encoding <Encoding>]
      [-Count <Int64>]
      [-Offset <Int64>]
      [-Raw]
      [<CommonParameters>]

Description

O Format-Hex cmdlet exibe um arquivo ou outra entrada como valores hexadecimais. Para determinar o deslocamento de um caractere a partir da saída, adicione o número na extremidade esquerda da linha ao número na parte superior da coluna desse caractere.

O Format-Hex cmdlet pode ajudá-lo a determinar o tipo de arquivo de um arquivo corrompido ou de um arquivo que pode não ter uma extensão de nome de arquivo. Você pode executar esse cmdlet e ler a saída hexadecimal para obter informações do arquivo.

Ao usar Format-Hex em um arquivo, o cmdlet ignora os caracteres de nova linha e retorna todo o conteúdo de um arquivo em uma cadeia de caracteres com os caracteres de nova linha preservados.

Exemplos

Exemplo 1: Obter a representação hexadecimal de uma cadeia de caracteres

Esse comando retorna os valores hexadecimais de uma cadeia de caracteres.

'Hello World' | Format-Hex

Label: String (System.String) <2944BEC3>

          Offset Bytes                                           Ascii
                 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
          ------ ----------------------------------------------- -----
0000000000000000 48 65 6C 6C 6F 20 57 6F 72 6C 64                Hello World

A cadeia de caracteres Hello World é enviada pelo pipeline para o Format-Hex cmdlet. A saída hexadecimal de mostra os valores de cada caractere na cadeia de Format-Hex caracteres.

Exemplo 2: Localizar um tipo de arquivo na saída hexadecimal

Este exemplo usa a saída hexadecimal para determinar o tipo de arquivo. O cmdlet exibe o caminho completo do arquivo e os valores hexadecimais.

Para testar o comando a seguir, faça uma cópia de um arquivo PDF existente no computador local e renomeie o arquivo copiado para File.t7f.

Format-Hex -Path .\File.t7f -Count 48

Label: C:\Test\File.t7f

          Offset Bytes                                           Ascii
                 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
          ------ ----------------------------------------------- -----
0000000000000000 25 50 44 46 2D 31 2E 35 0D 0A 25 B5 B5 B5 B5 0D %PDF-1.5..%????.
0000000000000010 0A 31 20 30 20 6F 62 6A 0D 0A 3C 3C 2F 54 79 70 .1 0 obj..<</Typ
0000000000000020 65 2F 43 61 74 61 6C 6F 67 2F 50 61 67 65 73 20 e/Catalog/Pages

O Format-Hex cmdlet usa o parâmetro Path para especificar um nome de arquivo no diretório atual, File.t7f. A extensão .t7f do arquivo é incomum, mas a saída %PDF hexadecimal mostra que é um arquivo PDF. Neste exemplo, o parâmetro Count é usado para limitar a saída aos primeiros 48 bytes do arquivo.

Exemplo 3: Formatar uma matriz de diferentes tipos de dados

Este exemplo usa uma matriz de tipos de dados diferentes para realçar como Format-Hex os manipula no Pipeline.

Ele passará cada objeto pelo Pipeline e processará individualmente. No entanto, se forem dados numéricos e o objeto adjacente também for numérico, ele os agrupará em um único bloco de saída.

'Hello world!', 1, 1138, 'foo', 'bar', 0xdeadbeef, 1gb, 0b1101011100 , $true, $false | Format-Hex

Label: String (System.String) <24F1F0A3>

          Offset Bytes                                           Ascii
                 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
          ------ ----------------------------------------------- -----
0000000000000000 48 65 6C 6C 6F 20 77 6F 72 6C 64 21             Hello world!

   Label: Int32 (System.Int32) <2EB933C5>

          Offset Bytes                                           Ascii
                 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
          ------ ----------------------------------------------- -----
0000000000000000 01 00 00 00 72 04 00 00                         �   r�

   Label: String (System.String) <4078B66C>

          Offset Bytes                                           Ascii
                 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
          ------ ----------------------------------------------- -----
0000000000000000 66 6F 6F                                        foo

   Label: String (System.String) <51E4A317>

          Offset Bytes                                           Ascii
                 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
          ------ ----------------------------------------------- -----
0000000000000000 62 61 72                                        bar

   Label: Int32 (System.Int32) <5ADF167B>

          Offset Bytes                                           Ascii
                 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
          ------ ----------------------------------------------- -----
0000000000000000 EF BE AD DE 00 00 00 40 5C 03 00 00             ï¾-Þ   @\�

   Label: Boolean (System.Boolean) <7D8C4C1D>

          Offset Bytes                                           Ascii
                 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F
          ------ ----------------------------------------------- -----
0000000000000000 01 00 00 00 00 00 00 00                         �

Parâmetros

-Count

Isso representa o número de bytes a serem incluídos na saída hexadecimal.

Esse parâmetro foi introduzido no PowerShell 6.2.

Tipo:Int64
Cargo:Named
Valor padrão:Int64.MaxValue
Obrigatório:False
Aceitar a entrada de pipeline:False
Aceitar caracteres curinga:False

-Encoding

Especifica a codificação das cadeias de caracteres de entrada. Isso se aplica apenas à [string] entrada. O parâmetro não tem efeito sobre tipos numéricos. O valor de saída é sempre utf8NoBOM.

Os valores aceitáveis para este parâmetro são os seguintes:

  • ascii: Usa a codificação para o conjunto de caracteres ASCII (7 bits).
  • ansi: Usa a codificação para a página de código ANSI da cultura atual. Essa opção foi adicionada no PowerShell 7.4.
  • bigendianunicode: Codifica no formato UTF-16 usando a ordem de bytes big-endian.
  • bigendianutf32: Codifica no formato UTF-32 usando a ordem de bytes big-endian.
  • oem: Usa a codificação padrão para MS-DOS e programas de console.
  • unicode: Codifica no formato UTF-16 usando a ordem de bytes little-endian.
  • utf7: Codifica no formato UTF-7.
  • utf8: Codifica no formato UTF-8.
  • utf8BOM: Codifica no formato UTF-8 com Marca de Ordem de Byte (BOM)
  • utf8NoBOM: Codifica no formato UTF-8 sem Marca de Ordem de Byte (BOM)
  • utf32: Codifica no formato UTF-32.

A partir do PowerShell 6.2, o parâmetro Encoding também permite IDs numéricas de páginas de código registradas (como -Encoding 1251) ou nomes de cadeia de caracteres de páginas de código registradas (como -Encoding "windows-1251"). Para obter mais informações, consulte a documentação do .NET para Encoding.CodePage.

A partir do PowerShell 7.4, você pode usar o Ansi valor do parâmetro Encoding para passar a ID numérica da página de código ANSI da cultura atual sem precisar especificá-la manualmente.

Observação

O uso de UTF-7* não é mais recomendado. A partir do PowerShell 7.1, um aviso será escrito se você especificar utf7 para o parâmetro Codificação .

Tipo:Encoding
Valores aceitos:ASCII, BigEndianUnicode, BigEndianUTF32, OEM, Unicode, UTF7, UTF8, UTF8BOM, UTF8NoBOM, UTF32
Cargo:Named
Valor padrão:UTF8NoBOM
Obrigatório:False
Aceitar a entrada de pipeline:False
Aceitar caracteres curinga:False

-InputObject

Especifica os objetos a serem formatados. Insira uma variável que contém os objetos ou digite um comando ou uma expressão que obtém os objetos.

Apenas alguns tipos escalares e [system.io.fileinfo] são suportados.

Os tipos escalares com suporte são:

  • [string], [char]
  • [byte], [sbyte]
  • [int16], [uint16], [short], [ushort]
  • [int], [uint], [int32], [uint32],
  • [long], [ulong], [int64], [uint64]
  • [single], [float], [double]
  • [boolean]

Antes do PowerShell 6.2, Format-Hex lidava com uma entrada de pipeline com vários tipos de entrada agrupando todos os objetos semelhantes. Agora, ele lida com cada objeto individual à medida que passa pelo Pipeline e não agrupa objetos, a menos que objetos semelhantes sejam adjacentes.

Tipo:PSObject
Cargo:Named
Valor padrão:None
Obrigatório:True
Aceitar a entrada de pipeline:True
Aceitar caracteres curinga:False

-LiteralPath

Especifica o caminho completo para um arquivo. O valor de LiteralPath é usado exatamente como é digitado. Esse parâmetro não aceita caracteres curinga. Para especificar vários caminhos para arquivos, separe os caminhos com uma vírgula. Se o parâmetro LiteralPath incluir caracteres de escape, coloque o caminho entre aspas simples. O PowerShell não interpreta nenhum caractere em uma única cadeia de caracteres entre aspas como sequências de escape. Para obter mais informações, consulte about_Quoting_Rules.

Tipo:String[]
Aliases:PSPath, LP
Cargo:Named
Valor padrão:None
Obrigatório:True
Aceitar a entrada de pipeline:False
Aceitar caracteres curinga:False

-Offset

Isso representa o número de bytes a serem ignorados de fazer parte da saída hexadecimal.

Esse parâmetro foi introduzido no PowerShell 6.2.

Tipo:Int64
Cargo:Named
Valor padrão:0
Obrigatório:False
Aceitar a entrada de pipeline:False
Aceitar caracteres curinga:False

-Path

Especifica o caminho para os arquivos. Use um ponto (.) para especificar o local atual. O caractere curinga (*) é aceito e pode ser usado para especificar todos os itens em um local. Se o parâmetro Path incluir caracteres de escape, coloque o caminho entre aspas simples. Para especificar vários caminhos para arquivos, separe os caminhos com uma vírgula.

Tipo:String[]
Cargo:0
Valor padrão:None
Obrigatório:True
Aceitar a entrada de pipeline:False
Aceitar caracteres curinga:True

-Raw

Este parâmetro não faz mais nada. Ele é mantido para compatibilidade de script.

Tipo:SwitchParameter
Cargo:Named
Valor padrão:None
Obrigatório:False
Aceitar a entrada de pipeline:False
Aceitar caracteres curinga:False

Entradas

String

Você pode canalizar uma cadeia de caracteres para esse cmdlet.

Saídas

ByteCollection

Esse cmdlet retorna um ByteCollection. Esse objeto representa uma coleção de bytes. Ele inclui métodos que convertem a coleção de bytes em uma cadeia de caracteres formatada como cada linha de saída retornada por Format-Hex. A saída também indica o tipo de bytes que estão sendo processados. Se você especificar o parâmetro Path ou LiteralPath , o objeto conterá o caminho do arquivo que contém cada byte. Se você passar uma string, booleana, inteiro, etc, ela será rotulada adequadamente.

Observações

O PowerShell inclui os seguintes aliases para Format-Hex:

  • Todas as plataformas:
    • fhx

A coluna de saída mais à direita tenta renderizar os bytes como caracteres ASCII:

Geralmente, cada byte é interpretado como um ponto de código Unicode, o que significa que:

  • Os caracteres ASCII imprimíveis são sempre renderizados corretamente
  • Caracteres UTF-8 de vários bytes nunca são renderizados corretamente
  • Os caracteres UTF-16 são renderizados corretamente somente se seu byte de alta ordem for NUL.