DEV Community: Hilton Fernandes

Busca em arquivos binários

Hilton Fernandes — Sat, 22 Aug 2026 18:04:59 +0000

Algumas vezes é necessário fazer buscas em arquivos binários. Há relativamente poucos tutoriais disponíveis na Web sobre o tema, apesar das ferramentas disponíveis no Linux oferecerem recursos para isso.

Este tutorial é escrito para apresentar esses recursos.

Visualização do arquivo com `hexdump`

O programa hexdump não está disponível nas instalações padrão do Linux.

Assim, é preciso instalalá-lo. Em distribuições derivadas do Debian (como Ubuntu, Linux Mint etc.), isto pode ser feito com o familiar comando

apt install hexdump

A partir daí, uma apresentação muito conveniente é dada pela opção -C, que mostrará o conteúdo do arquivo em hexadecimal e ao lado, uma tentativade mostrá-lo em ASCII.

Vamos usar, nos exemplos a seguir, o conto Quem boa cama faz* de Machado de Assis, que é um pequeno arquivo PDF disponível para ser baixado legal e gratuitamente em

https://dominiopublico.mec.gov.br/download/texto/ua000225.pdf

É um texto breve, de 19 páginas, com tamanho de apenas 64 kb.

Segue a apresentação das primeiras 10 linhas, obtidas com os comandos

hexdump -C ua000225.pdf | head

Neste caso o programa head mostra as 10 primeiras linhas da saída da execução de hexdump -C

A barra em pé | chamada de pipe ou "canalização", conecta a saída de hexdump -C com a entrada de head.

00000000  25 50 44 46 2d 31 2e 32  20 0d 0a 25 e2 e3 cf d3  |%PDF-1.2 ..%....|
00000010  0d 0a 20 0d 0a 38 20 30  20 6f 62 6a 0d 0a 3c 3c  |.. ..8 0 obj..<<|
00000020  0d 0a 2f 4c 65 6e 67 74  68 20 39 20 30 20 52 0d  |../Length 9 0 R.|
00000030  0a 2f 46 69 6c 74 65 72  20 2f 46 6c 61 74 65 44  |./Filter /FlateD|
00000040  65 63 6f 64 65 20 0d 0a  3e 3e 0d 0a 73 74 72 65  |ecode ..>>..stre|
00000050  61 6d 0d 0a 48 89 85 96  dd 6e 62 39 0c c7 9f 80  |am..H....nb9....|
00000060  77 c8 65 47 da 93 c6 76  3e 7b 35 14 a8 54 69 a7  |w.eG...v>{5..Ti.|
00000070  d3 d1 d2 3b 6e ce 00 dd  65 05 54 0b 6a 2b f5 e9  |...;n...e.T.j+..|
00000080  c7 49 ce a1 b4 98 1d 21  50 48 9c ff cf 71 e2 38  |.I.....!PH...q.8|
00000090  d7 d3 81 c5 a4 42 8c 1a  9d 52 d3 f1 c0 28 a3 9d  |.....B...R...(..|

Os arquivos PDF possuem muitas informações codificadas em binário, mas também têm conteúdo em texto ASCII. Por exemplo, neste caso, o arquivo contém o texto /FlateDecode.

Outras informações podem ser obtidas paginando a execução de hexdump -C por mais linhas, usando, por exemplo, hexdump -C | less.

Busca com `grep`

Para buscar um padrão específico em um arquivo, o comando grep é uma espécie canivete suíço -- com múltiplas utilidades.

Uma busca simples em um arquivo de textos comum -- por exemplo, o código fonte de um programa --, a sintaxe de grep é trivial:

grep 'padrão'nome_do_arquivo

Para buscas em arquivos binários, outras opções são necessárias. Segue uma lista delas:

-a ou --text faz com que grep ignore marcações especiais no arquivo binário;
-b ou --byte-offset faz com que grep mostre o deslocamento (ou offset) em bytes da cadeia de caracteres encontrada.

Neste caso, offset significa que o primeiro byte é referidocomo0, o segundo como 1 etc.
-o ou --only-matching faz com que grep mostre apenas a cadeia de caracteres que atende os critérios de busca.

Para localizar a cadeia de caracteres Filter no arquivo ua000225.pdf aqui usado como exemplo, pode-se fazer

grep -a -b -o 'Filter' ua000225.pdf

Como sabemos que há muitas ocorrências da palavra Filter neste pequeno arquivo, vamos restringir sua busca por apenas 1 ocorrência, usando novamente o utilitário head:

grep -a -b -o 'Filter' ua000225.pdf | head -1

Isto gerará a saída:

50:Filter

Isto significa que a palavra Filter começa a partir da posição 51 do
arquivo ua000225.pdf O que, segundo alguns, é uma boa ideia.

Expressões regulares

Para aumentar ainda mais o poder do grep há o recurso das
expressões regulares

Esse recurso é muito poderoso e pode até mesmo se tornar complexo. Aqui, usaremos apenas o mínimo delas.

Para usar expressões regulares com o grep pode-se usar a opção -E ou --extended-regexp, que permite certas simplificações.

Por exemplo, para encontrar todas palavras iniciadas por uma letra maiúscula e seguidas por pelo menos uma letra minúscula, usa-se como expressão de busca o texto [A-Z][a-z]\+

As expressões [A-Z] e [a-z] indicam classes de caracteres. No caso, respectivamente todas as letras maiúsculas e todas as letras minúsculas. O sinal + indica que o caractere anterior deve aparecer pelo menos uma vez, sem limite de repetições.

O caracter + é prefixado por uma contrabarra, ou \ para distinguir essa repetição da busca do caracter +.

Então, neste caso, o comando se torna:

grep -a -b -o '[A-Z][a-z]\+' ua000225.pdf

Então, surgem 1088 linhas. Para restringir a busca a apenas 10 linhas, usamos novamente head:

grep -a -b -o '[A-Z][a-z]\+' ua000225.pdf | head

O que gera:

35:Length
50:Filter
58:Flate
63:Decode
109:Ti
160:Ae
279:Tc
283:Kpj
292:Hu
340:Rɢ

As cadeias de caracteres muito curtas (como Ti ou Ae) possivelmente são combinações aleatórias de valores binários. É possível exigir comprimentos mínimos maiores de resultados de busca. Uma das formas é usar as chaves.

Uma curiosidade é que quando se usa + em vez de +, o resultado é
diferente. Ou seja: os comandos

grep -a -b -o '[A-Z][a-z]+' ua000225.pdf

geram

12090:Yk+
24288:Ld+

A breve visualização do arquivo mostrou que as palavras maiores são
precedidas por uma barra /. Assim, pode-se alterar a expressão de busca para

grep -a -b -o '/[A-Z][a-z]\+' ua000225.pdf

Isto gerará 428 ocorrências no arquivo em uso. Para restringi-las, usa-se
novamente o head:

grep -a -b -o '/[A-Z][a-z]\+' ua000225.pdf | head

E finalmente,

34:/Length
49:/Filter
57:/Flate
339:/Rɢ
992:/Type
1008:/Subtype
1017:/Image
1025:/Name
1037:/Filter
1058:/Width

Separação de campos

Para usar os resultados das buscas, pode-se aplicar o utilitário padrão awk, que permite separar o offset da cadeia de caracteres.

Por exemplo, para extrair apenas a cadeia de caracteres:

grep -a -b -o '/[A-Z][a-z]\+' ua000225.pdf | awk -F ':' '{ print $2 }'

Para apresentar apenas as primeiras linhas, usa-se de novo head:

grep -a -b -o '/[A-Z][a-z]\+' ua000225.pdf | awk -F ':' '{ print $2 }' | head

O que gera:

/Length
/Filter
/Flate
/Rɢ
/Type
/Subtype
/Image
/Name
/Filter
/Width

Ou para extrair apenas o offset:

grep -a -b -o '/[A-Z][a-z]\+' ua000225.pdf | awk -F ':' '{ print $1 }' | head

Com o resultado:

Pelos exemplos, não é tão difícil ver que o comando awk está permitindo separar os elementos da saída de grep. A opção -F ':'' define o caracter de separação entre os dois campos, que é :'.

A forma $1 define o primeiro campo (o offset) e a forma $2 define o
segundo campo, que é a cadeia de caracteres encontrada.

Contagem de ocorrências

Para contar quantas vezes uma determinada string aparece, podem-se suar dois comandos, sort e uniq.

O comando sort (literalmente "classificação") ordena a saída de grep. Assim, a linha

grep -a -b -o '/[A-Z][a-z]\+' ua000225.pdf | awk -F ':' '{ print $2 }' | sort | head

vai mostrar

/Amer
/Amer
/Arial
/Arial
/Arial
/Arial
/Ascent
/Ascent
/Ascent
/Ascent

O que permite contar que /Amer occore 2 vezes e /Arial ocorre 4 vezes.

Para contar todas as ocorrências, usa-se uniq -c. Assim, a linha

grep -a -b -o '/[A-Z][a-z]\+' ua000225.pdf | awk -F ':' '{ print $2 }' | sort | uniq -c | head

mostra

2 /Amer
4 /Arial
6 /Ascent
6 /Avg
6 /Base
2 /Batang
1 /Bi
1 /Bits
2 /Cal
6 /Cap

Caso não se queira a contagem, deixa-se de lado o -c do uniq.

Assim, a linha

grep -a -b -o '/[A-Z][a-z]\+' ua000225.pdf | awk -F ':' '{ print $2 }' | sort | uniq | head

agora mostra

/Amer
/Arial
/Ascent
/Avg
/Base
/Batang
/Bi
/Bits
/Cal
/Cap

Por último, para se saber quais são as cadeias de caracteres mais comuns,faz-se

grep -a -b -o '/[A-Z][a-z]\+' ua000225.pdf | awk -F ':' '{ print $2 }' | sort | uniq -c | sort -r -n | head

O que gera

49 /Font
38 /Type
23 /Parent
21 /Length
21 /Filter
20 /Flate
19 /Resources
19 /Proc
19 /Page
19 /Contents

A opção -r de sort faz com que a ordenação seja decrescente: do mais frequente para o menos frequente. A opção -n faz com que o primeiro campo da saída seja interpretado como um número.

Leveling with cluster analysis in Python: basic Python concepts

Hilton Fernandes — Thu, 06 Nov 2025 21:36:06 +0000

This is the 2nd of a series of 5 little articles that intend to present a simple idea of time series, and their implementation in Python. The purpose here is to present both a time series problem, and how we can solve it in simple Python code.

Only very basic knowledge of Python and time series are needed as most concepts will be explained with care and references to longer tutorials.

Roadmap

The 1st article of the series presented the basic concepts of this series. This one, the 2nd one will present basic Python concepts and techniques to be used in the solution. The 3rd one will present a solution implemented in Python. The 4th article will add a sinusoidal decomposition of the data after the filtering of the solution. And the 5th and last one will use all the elements to address a real problem in cryptocurrencies.
'

Some simple Python ideas

Libraries, modules and submodules

Isaac Newton, that created a huge part of modern Physics and Mathematics once said the he could see further because because he standed in the shoulder of giants.

This concept is behind most software codes: they do not create everything, they use a large part of what was already created, mainly in the form of sofware libraries. Python is very good at this, and here is the part of the code used here that will use some libraries. In Python, a library is usually named a module.

import numpy as np 

import matplotlib.pyplot as plt
from sklearn.cluster import KMeans

The idea that the current code will bring information from another one is encompassed in the word import in the code above. Another important point is that programmers usually prefer to write less. So, in the 1st line, the library numpy is renamed as np. In another line, the module matplotlib.pyplot is renamed simply as plt.

And in the last line of the code, another shortening is presented: instead of renaming a code fragment in a shorter from, Python lets one pick only what a programmer needs. In this case, only KMeans will be picked from sklearn.cluster.

A less important point is that use of a dot lets selecting a part of a module; that is: a submodule. In the code shown, matplotlib.pyplot means the submodule pyplot of the module matplotlib. And, of course, sklearn.cluster is the submodule cluster of the module sklearn. Creating submodules increases the organization of larger modules, as this divides them in specialized parts.

Pieces of information in scalar variables

The next part of the code deals with storing information that shall be processed. Here a list of scalar variables, or variables that are individual:

coeff : float = 0.25

base : float = 0.0
ladder : float = 1.0
n_points : int = 101
n_half : int = n_points // 2

delta : float = 1.0 / n_points

There are two types of information in this code fragment: int, that hold only integral values. In this case the count of points (n_point) and the half of that count, n_half.

The double bar in the line for n_half is used to make sure the division of n_points by 2 will generate a number of type int, and not a float number. That is: it will hold 50, and not 50.5, as the division of 101 by 2 would create.

The type float can be used to hold number with a decimal part. For instance, coeff will be used to hold a coefficient. In this case, 0.25. Since the problem here is to represent a discontuinuity, a set of values will be close to a base level, while other ones will be above it, in ladder.

And finally, delta holds the step that will be used as a clock tick in our time series.

A data generator

A time series usually is a series of data collected along the time. For instance, mean wage in a certain year. But to avoid the need of getting real data, this code will generate its own data. By means of a pseudorandom number generator, aka PRNG. In a few words, a PRNG is a mathematical algorithm that can generate a sequence of numbers without any pattern; that is: they look random. It's called pseudorandom because if one such algorithm is fed with a constant seed it will always generate the same sequence of numbers.

In this case it is:

rng = np.random.default_rng(42)

In this code, rng is the name of the fabric of numbers, and it's created by calling the function (or piece of code) defaut_rng with the parameter 42. This function is in the submodule np.random.

Pieces of information in arrays

Since a time series contain several data, a scalar variable can't be used to contain it. The module numpy has the resource of arrays or ndarrays. In an array, the elements are identified by an index, that is analogous to the apartment number in a building.

The following code fragment creates the arrays needed to this problem:

x : np.ndarray = np.linspace(0.0, 1.0, n_points)
y : np.ndarray = rng.uniform(-0.5, 0.5, size=n_points)

y[n_half : ] += ladder

In the 1st line, the array x receives n_points (aka 101) numbers from 0.0 to 1.0, subdivided in increments of 0.01; that is: 0.0, 0.01, 0.02, ..., 0.99, 1.0

In the 2nd line, the array y receives n_points numbers chosen pseudorandomly between -05 and 0.5.

In the third line, the 2nd half of y receives an increment of ladder. That creates the discontinuity to be solved in the remaining of the texts.

Plotting the data

Please consider the following code fragment:

fig, ax = plt.subplots()
ax.plot(x, y)

ax.set_xlabel('x')
ax.set_ylabel('y')

plt.grid(visible=True)
plt.show()

The 1st line is a generic one, that can be used to create plots -- aka charts -- much more complicated than the ones used here. For instance, several plots in the same image.

The 2nd line plots the elements of two arrays, taking care of connecting by lines each one of their values.

The 3rd and 4th lines of the code label the x and y axis.

The 5th line of the code create a grid to ease the visualization of data. And the 6th and final line causes the chart to be shown in the screen.

The final result is like this:

Leveling with cluster analysis in Python: general concepts

Hilton Fernandes — Thu, 30 Oct 2025 18:52:11 +0000

Financial markets have discontinuities: sometimes a price jumps up or down in a time so short that it can be considered a real discontinuity if the time measured by our clocks were really continuous, real-line continuous.

Those discontinuities create problems for many forms of mathematical modelling, since their models are based upon continuous functions. For instance, many price oscillations look like periodic functions, but when a discontinuity is found, any harmonic analysis becomes troublesome.

Actually, a trend can also be troublesome to the fitting of periodic functions to financial data. But in this case, fitting a polynomial of low grade to the data can filter the trend and then a periodic function series can be fitted to the residuals, the difference between the fitted polynomial and the original data.

The purpose of this suite of articles is to present a simple method to eliminate jumps from the observed data. Of course, when reconstructing the fitted data, the discontinuity will be added back.

Only very basic knowledge of Python and time series are needed as most concepts will be explained with care and references to longer tutorials.

Roadmap

This one, the 1st of 5 short articles, will introduce the general concepts for the solution, the 2nd one will present basic Python concepts and techniques to be used in the solution, the 3rd one will present a solution implemented in Python, the 4th article will add a sinusoidal decomposition of the data after the filtering of the solution, and the 5th and last one will use all the elements to address a real problem in cryptocurrencies.

Cluster analysis as a means to group similar data

Cluster analysis is a well-known technique for grouping data elements based on their similarities. In a metric space, similarity means smaller distances. There are several ways to devise the groups or clusters of data, and one of the simplest is called k-means clustering. In very few words, it creates clusters by assigning a mean average of the coordinates to a point, that's a centroid. Through these articles we shall use only k-means clustering.

The following image is a typical two-dimensional representation of two groups.

The points are in blue, and the centroids are in red.

Cluster analysis in a curve

Since the k-means clustering is based upon the distance of points, an interesting effect will happen when the points are connected in a curve; therefore, they are much closer to each other than the points dispersed in a cloud, like in the previous image.

Please consider the following image that shows a time series with a discontinuity.

When a k-means cluster analysis is applied to it, the centroids of the clusters are shown in red.

It's easy to see that the there are two groups are in different levels, as shown in the following image:

The Group 2 is around the green line, while the Group 1 is around the red line.

Then to eliminate the discontinuity, it's enough to lower the Group 1 to the level of the Group 2. That is: to subtract from the points y coordinate the difference between the level of the two groups.

That can be shown in the following image:

Now no differences can be seen in the two groups of points.

Next step

The next article in this suit will introduce the basic Python concepts needed to create the 1st of the images presented here, and also used in the other articles.

DEV Community: Hilton Fernandes

Busca em arquivos binários

Visualização do arquivo com hexdump

Busca com grep

Expressões regulares

Separação de campos

Contagem de ocorrências

Leveling with cluster analysis in Python: basic Python concepts

Roadmap

Some simple Python ideas

Libraries, modules and submodules

Pieces of information in scalar variables

A data generator

Pieces of information in arrays

Plotting the data

Leveling with cluster analysis in Python: general concepts

Roadmap

Cluster analysis as a means to group similar data

Cluster analysis in a curve

Next step

Visualização do arquivo com `hexdump`

Busca com `grep`