Dificuldade em ler binário

13. Re: Dificuldade em ler binário

aguamole
aguamole

(usa KUbuntu)

Enviado em 17/05/2024 - 01:42h

A partir daqui eu já não tenho mais conhecimento para te ajudar, bom estudo lendo absurdo de paginas e manuais de instruções de CPU. É por isso que foi inventado as linguagens de programação de alto nível, para abstrair essas complexidades e tornar o programador mais produtivo. Abraço.


  


14. Re: Dificuldade em ler binário

Samuel Leonardo
SamL

(usa XUbuntu)

Enviado em 17/05/2024 - 10:47h

O que imagino: Se o computador lê em binário, porque não consigo fazer uma conversão para texto legível da ascii para eu entender o que ele está lendo? 90% do arquivo é ilegível.

O que acontece é que o valor lido pode não ter um correspondente legível ascii, além de que nem todo caractere sairá bonitinho como caracteres deste texto.
Vc pode tentar converter um arquivo binário, no caso um arquivo executável elf usando libs específicas pra ler arquivos elf.
Esse tipo de lib ajuda diminuir o trabalho de ter de fazer na mão toda a leitura do arquivo executável.
Com uma lib para ler elf, vc pode facilmente extrair todas as seções do executável e ai imprimir na saída um código tipo assembly usando cada instrução.
Inclusive, é possível sim converter um arquivo elf para C porém, ele seria ilegível por humanos, digo, muito extensoo e muito complexo.

Uma vez eu tava planejando estudar assembly 6502 pra justamente converter um programa binário em cóidigo C, mesmo que fosse ilegível.
Com o código C do binário 6502 dá pra recompilar em qualquer máquina mais nova e potente e entã teria um código multiplataforma.
Esse projeto ainda não fiz por conta de esquecimento, mas pretendo criá-lo ainda.


https://nerdki.blogspot.com/ acessa ai, blog dedicado Paranóia!
https://github.com/cpusam com o bug fix vem a perfeição!


15. Re: Dificuldade em ler binário

aguamole
aguamole

(usa KUbuntu)

Enviado em 17/05/2024 - 11:42h

@SamL bem lembrado não é tudo que poderá ser entendido por meio de caracteres ASCII, mas tudo pode ser entendido fazendo a leitura binária e sendo interpretado transcrito para assembly ao invés de ASCII, isso porque a linguagem de maquina não é uma linguagem humana e o ASCII é da linguagem humana o que torna incompatível esta leitura em 100% caractere ASCII.
Para sair da linguagem de maquina você terá que passar para o assembly, o assembly usa caractere ASCII. Ai quando vc não estiver entendendo você esta lendo instruções do processador. Lembre-se de que os CPUs tem ou não as mesma instruções entre si, isso vai depender da fabricante. Ou seja você terá que cair de cara em algum livro ou dar um jeito de encontrar essas instruções em algum lugar da internet.


16. Re: Dificuldade em ler binário

aguamole
aguamole

(usa KUbuntu)

Enviado em 17/05/2024 - 12:13h

Para vc ter uma ideia, este livro de instruções de computador tem 247 paginas, se for uma instrução por pagina então são 247 instruções para decorar.
https://www.amazon.com.br/One-Instruction-Computer-Complete-Guide-ebook/dp/B085129MRW

Quero te assustar com a linguagem de maquina não, só estou te mostrando os fatos.
No entanto para aprender assembly também é preciso estudar as instruções, mas a diferença é que não é linguagem de maquina.


17. Re: Dificuldade em ler binário

aguamole
aguamole

(usa KUbuntu)

Enviado em 17/05/2024 - 12:32h

A e tem mais, os primeiros bytes, não sei da onde ate aonde é na verdade informações em bytes para o sistema operacional saber de qual tipo de dados aquele arquivo é, cada tipo de arquivo tem informações em bytes para se auto descrever. Eu esqueci o nome disso, corra atrás.


18. Re: Dificuldade em ler binário

Samuel Leonardo
SamL

(usa XUbuntu)

Enviado em 18/05/2024 - 19:20h


aguamole escreveu:

Para vc ter uma ideia, este livro de instruções de computador tem 247 paginas, se for uma instrução por pagina então são 247 instruções para decorar.
https://www.amazon.com.br/One-Instruction-Computer-Complete-Guide-ebook/dp/B085129MRW

Quero te assustar com a linguagem de maquina não, só estou te mostrando os fatos.
No entanto para aprender assembly também é preciso estudar as instruções, mas a diferença é que não é linguagem de maquina.

Esse livro parece massa! Eu gosto desse tipo de assunto, principalmente do teórico.
Além pc de uma instrução, tem também a arquitetura zisc (zero instruction set), mas essa é voltada pra um pc com IA.
Pense num sistema completo que só está ali na memória e só faz sentido pra uma IA, isso ai é o zisc.

Uma coisa divertida de se fazer é emuladores, aprende-se bastante sobre operações bit a bit. eu fiz um emulador de chip8 em C com sdl2, tinha feito outro de nes mas perdi o código fonte.

Quanto a instrução em si, dava pra fazer assim aguamole: traduzir as intrusções para funções e ai fazer um mapa de memória, adicionar os registradores etc.
Basicamente é um emulador só que tu compila pra C. era assim que eu tava tentando criar isso outro dia, pena que requer muita leitura mas o assunto é bacana.


https://nerdki.blogspot.com/ acessa ai, blog dedicado Paranóia!
https://github.com/cpusam com o bug fix vem a perfeição!


19. Re: Dificuldade em ler binário

Paulo
paulo1205

(usa Ubuntu)

Enviado em 19/05/2024 - 13:12h

Fiz uma “leitura diagonal” do tópico, porque vou ter de sair daqui a pouco.

Não reparei se algum mencionou o programa objdump, com a opção de disassemble, para que o OP consiga ter uma representação clara de tudo (ou pelo menos do mais importante) que está no código dele.

O ELF (Executable and Linking Format) tem muitas informações para além do código executável puro e simples. Existe uma estruturação de seções, segmentação e uso de memória, cada uma delas com um cabeçalho que segue um formato padrão. Desse modo, o conteúdo de um executável terá muito mais “coisas ilegíveis” do que simplesmente os opcodes das instruções em Assembly que correspondem ao código fonte em C.

Não sei qual a intenção do OP ao fazer um dump binário do seu código. Contudo se a intenção for entender quais as partes do executável, e quiçá eliminar redundâncias, eis um artigo muito interessante que eu li anos atrás, que, ao descrever a jornada para chegar ao menor executável (binário) possível usando Linux, passa pelos tópicos de estrutura do ELF e algumas das seções que o compõem: https://www.muppetlabs.com/~breadbox/software/tiny/teensy.html.

Abaixo segue uma sessão de compilação e dump de um programa que só faz retornar o valor 42 na saída (como no artigo acima indicado), sem me dar o trabalho de tentar reduzir o tamanho do executável, e possivelmente usando de forma inadequada a opção --disassemble-all, pois há coisas ali que seguramente não correspondem a código de máquina (todas as seções que aparecem como “DATA”, em vez de “CODE”, por exemplo), mas que estão sendo exibidas como se o fossem.

$ echo "int main(void){ return 42; }" > x.c

$ gcc -O0 x.c -o x

$ ls -l x
-rwxr-xr-x 1 user group 15776 May 19 12:58 x

$ strip x

$ ls -l x
-rwxr-xr-x 1 user group 14328 May 19 12:59 x

$ objdump --file-headers --section-headers --disassemble-all x

x: file format elf64-x86-64
architecture: i386:x86-64, flags 0x00000150:
HAS_SYMS, DYNAMIC, D_PAGED
start address 0x0000000000001040

Sections:
Idx Name Size VMA LMA File off Algn
0 .interp 0000001c 0000000000000318 0000000000000318 00000318 2**0
CONTENTS, ALLOC, LOAD, READONLY, DATA
1 .note.gnu.property 00000030 0000000000000338 0000000000000338 00000338 2**3
CONTENTS, ALLOC, LOAD, READONLY, DATA
2 .note.gnu.build-id 00000024 0000000000000368 0000000000000368 00000368 2**2
CONTENTS, ALLOC, LOAD, READONLY, DATA
3 .note.ABI-tag 00000020 000000000000038c 000000000000038c 0000038c 2**2
CONTENTS, ALLOC, LOAD, READONLY, DATA
4 .gnu.hash 00000024 00000000000003b0 00000000000003b0 000003b0 2**3
CONTENTS, ALLOC, LOAD, READONLY, DATA
5 .dynsym 00000090 00000000000003d8 00000000000003d8 000003d8 2**3
CONTENTS, ALLOC, LOAD, READONLY, DATA
6 .dynstr 00000088 0000000000000468 0000000000000468 00000468 2**0
CONTENTS, ALLOC, LOAD, READONLY, DATA
7 .gnu.version 0000000c 00000000000004f0 00000000000004f0 000004f0 2**1
CONTENTS, ALLOC, LOAD, READONLY, DATA
8 .gnu.version_r 00000030 0000000000000500 0000000000000500 00000500 2**3
CONTENTS, ALLOC, LOAD, READONLY, DATA
9 .rela.dyn 000000c0 0000000000000530 0000000000000530 00000530 2**3
CONTENTS, ALLOC, LOAD, READONLY, DATA
10 .init 0000001b 0000000000001000 0000000000001000 00001000 2**2
CONTENTS, ALLOC, LOAD, READONLY, CODE
11 .plt 00000010 0000000000001020 0000000000001020 00001020 2**4
CONTENTS, ALLOC, LOAD, READONLY, CODE
12 .plt.got 00000010 0000000000001030 0000000000001030 00001030 2**4
CONTENTS, ALLOC, LOAD, READONLY, CODE
13 .text 000000f8 0000000000001040 0000000000001040 00001040 2**4
CONTENTS, ALLOC, LOAD, READONLY, CODE
14 .fini 0000000d 0000000000001138 0000000000001138 00001138 2**2
CONTENTS, ALLOC, LOAD, READONLY, CODE
15 .rodata 00000004 0000000000002000 0000000000002000 00002000 2**2
CONTENTS, ALLOC, LOAD, READONLY, DATA
16 .eh_frame_hdr 0000002c 0000000000002004 0000000000002004 00002004 2**2
CONTENTS, ALLOC, LOAD, READONLY, DATA
17 .eh_frame 00000094 0000000000002030 0000000000002030 00002030 2**3
CONTENTS, ALLOC, LOAD, READONLY, DATA
18 .init_array 00000008 0000000000003df0 0000000000003df0 00002df0 2**3
CONTENTS, ALLOC, LOAD, DATA
19 .fini_array 00000008 0000000000003df8 0000000000003df8 00002df8 2**3
CONTENTS, ALLOC, LOAD, DATA
20 .dynamic 000001c0 0000000000003e00 0000000000003e00 00002e00 2**3
CONTENTS, ALLOC, LOAD, DATA
21 .got 00000040 0000000000003fc0 0000000000003fc0 00002fc0 2**3
CONTENTS, ALLOC, LOAD, DATA
22 .data 00000010 0000000000004000 0000000000004000 00003000 2**3
CONTENTS, ALLOC, LOAD, DATA
23 .bss 00000008 0000000000004010 0000000000004010 00003010 2**0
ALLOC
24 .comment 0000002b 0000000000000000 0000000000000000 00003010 2**0
CONTENTS, READONLY

Disassembly of section .interp:

0000000000000318 <.interp>:
318: 2f (bad)
319: 6c insb (%dx),%es:(%rdi)
31a: 69 62 36 34 2f 6c 64 imul $0x646c2f34,0x36(%rdx),%esp
321: 2d 6c 69 6e 75 sub $0x756e696c,%eax
326: 78 2d js 355 <__cxa_finalize@plt-0xcdb>
328: 78 38 js 362 <__cxa_finalize@plt-0xcce>
32a: 36 2d 36 34 2e 73 ss sub $0x732e3436,%eax
330: 6f outsl %ds:(%rsi),(%dx)
331: 2e 32 00 cs xor (%rax),%al

Disassembly of section .note.gnu.property:

0000000000000338 <.note.gnu.property>:
338: 04 00 add $0x0,%al
33a: 00 00 add %al,(%rax)
33c: 20 00 and %al,(%rax)
33e: 00 00 add %al,(%rax)
340: 05 00 00 00 47 add $0x47000000,%eax
345: 4e 55 rex.WRX push %rbp
347: 00 02 add %al,(%rdx)
349: 00 00 add %al,(%rax)
34b: c0 04 00 00 rolb $0x0,(%rax,%rax,1)
34f: 00 03 add %al,(%rbx)
351: 00 00 add %al,(%rax)
353: 00 00 add %al,(%rax)
355: 00 00 add %al,(%rax)
357: 00 02 add %al,(%rdx)
359: 80 00 c0 addb $0xc0,(%rax)
35c: 04 00 add $0x0,%al
35e: 00 00 add %al,(%rax)
360: 01 00 add %eax,(%rax)
362: 00 00 add %al,(%rax)
364: 00 00 add %al,(%rax)
...

Disassembly of section .note.gnu.build-id:

0000000000000368 <.note.gnu.build-id>:
368: 04 00 add $0x0,%al
36a: 00 00 add %al,(%rax)
36c: 14 00 adc $0x0,%al
36e: 00 00 add %al,(%rax)
370: 03 00 add (%rax),%eax
372: 00 00 add %al,(%rax)
374: 47 rex.RXB
375: 4e 55 rex.WRX push %rbp
377: 00 30 add %dh,(%rax)
379: 67 5d addr32 pop %rbp
37b: 95 xchg %eax,%ebp
37c: c0 d6 a9 rcl $0xa9,%dh
37f: 19 12 sbb %edx,(%rdx)
381: 6f outsl %ds:(%rsi),(%dx)
382: 95 xchg %eax,%ebp
383: 8b 50 ce mov -0x32(%rax),%edx
386: 78 b1 js 339 <__cxa_finalize@plt-0xcf7>
388: 53 push %rbx
389: 66 6f outsw %ds:(%rsi),(%dx)
38b: 3d .byte 0x3d

Disassembly of section .note.ABI-tag:

000000000000038c <.note.ABI-tag>:
38c: 04 00 add $0x0,%al
38e: 00 00 add %al,(%rax)
390: 10 00 adc %al,(%rax)
392: 00 00 add %al,(%rax)
394: 01 00 add %eax,(%rax)
396: 00 00 add %al,(%rax)
398: 47 rex.RXB
399: 4e 55 rex.WRX push %rbp
39b: 00 00 add %al,(%rax)
39d: 00 00 add %al,(%rax)
39f: 00 03 add %al,(%rbx)
3a1: 00 00 add %al,(%rax)
3a3: 00 02 add %al,(%rdx)
3a5: 00 00 add %al,(%rax)
3a7: 00 00 add %al,(%rax)
3a9: 00 00 add %al,(%rax)
...

Disassembly of section .gnu.hash:

00000000000003b0 <.gnu.hash>:
3b0: 02 00 add (%rax),%al
3b2: 00 00 add %al,(%rax)
3b4: 05 00 00 00 01 add $0x1000000,%eax
3b9: 00 00 add %al,(%rax)
3bb: 00 06 add %al,(%rsi)
3bd: 00 00 add %al,(%rax)
3bf: 00 00 add %al,(%rax)
3c1: 00 81 00 00 00 00 add %al,0x0(%rcx)
3c7: 00 05 00 00 00 00 add %al,0x0(%rip) # 3cd <__cxa_finalize@plt-0xc63>
3cd: 00 00 add %al,(%rax)
3cf: 00 d1 add %dl,%cl
3d1: 65 ce gs (bad)
3d3: 6d insl (%dx),%es:(%rdi)

Disassembly of section .dynsym:

00000000000003d8 <.dynsym>:
...
3f0: 10 00 adc %al,(%rax)
3f2: 00 00 add %al,(%rax)
3f4: 12 00 adc (%rax),%al
...
406: 00 00 add %al,(%rax)
408: 43 00 00 rex.XB add %al,(%r8)
40b: 00 20 add %ah,(%rax)
...
41d: 00 00 add %al,(%rax)
41f: 00 5f 00 add %bl,0x0(%rdi)
422: 00 00 add %al,(%rax)
424: 20 00 and %al,(%rax)
...
436: 00 00 add %al,(%rax)
438: 6e outsb %ds:(%rsi),(%dx)
439: 00 00 add %al,(%rax)
43b: 00 20 add %ah,(%rax)
...
44d: 00 00 add %al,(%rax)
44f: 00 01 add %al,(%rcx)
451: 00 00 add %al,(%rax)
453: 00 22 add %ah,(%rdx)
...

Disassembly of section .dynstr:

0000000000000468 <.dynstr>:
468: 00 5f 5f add %bl,0x5f(%rdi)
46b: 63 78 61 movsxd 0x61(%rax),%edi
46e: 5f pop %rdi
46f: 66 69 6e 61 6c 69 imul $0x696c,0x61(%rsi),%bp
475: 7a 65 jp 4dc <__cxa_finalize@plt-0xb54>
477: 00 5f 5f add %bl,0x5f(%rdi)
47a: 6c insb (%dx),%es:(%rdi)
47b: 69 62 63 5f 73 74 61 imul $0x6174735f,0x63(%rdx),%esp
482: 72 74 jb 4f8 <__cxa_finalize@plt-0xb38>
484: 5f pop %rdi
485: 6d insl (%dx),%es:(%rdi)
486: 61 (bad)
487: 69 6e 00 6c 69 62 63 imul $0x6362696c,0x0(%rsi),%ebp
48e: 2e 73 6f jae,pn 500 <__cxa_finalize@plt-0xb30>
491: 2e 36 00 47 4c cs ss add %al,0x4c(%rdi)
496: 49 rex.WB
497: 42 rex.X
498: 43 5f rex.XB pop %r15
49a: 32 2e xor (%rsi),%ch
49c: 32 2e xor (%rsi),%ch
49e: 35 00 47 4c 49 xor $0x494c4700,%eax
4a3: 42 rex.X
4a4: 43 5f rex.XB pop %r15
4a6: 32 2e xor (%rsi),%ch
4a8: 33 34 00 xor (%rax,%rax,1),%esi
4ab: 5f pop %rdi
4ac: 49 54 rex.WB push %r12
4ae: 4d 5f rex.WRB pop %r15
4b0: 64 65 72 65 fs gs jb 519 <__cxa_finalize@plt-0xb17>
4b4: 67 69 73 74 65 72 54 imul $0x4d547265,0x74(%ebx),%esi
4bb: 4d
4bc: 43 6c rex.XB insb (%dx),%es:(%rdi)
4be: 6f outsl %ds:(%rsi),(%dx)
4bf: 6e outsb %ds:(%rsi),(%dx)
4c0: 65 54 gs push %rsp
4c2: 61 (bad)
4c3: 62 (bad)
4c4: 6c insb (%dx),%es:(%rdi)
4c5: 65 00 5f 5f add %bl,%gs:0x5f(%rdi)
4c9: 67 6d insl (%dx),%es:(%edi)
4cb: 6f outsl %ds:(%rsi),(%dx)
4cc: 6e outsb %ds:(%rsi),(%dx)
4cd: 5f pop %rdi
4ce: 73 74 jae 544 <__cxa_finalize@plt-0xaec>
4d0: 61 (bad)
4d1: 72 74 jb 547 <__cxa_finalize@plt-0xae9>
4d3: 5f pop %rdi
4d4: 5f pop %rdi
4d5: 00 5f 49 add %bl,0x49(%rdi)
4d8: 54 push %rsp
4d9: 4d 5f rex.WRB pop %r15
4db: 72 65 jb 542 <__cxa_finalize@plt-0xaee>
4dd: 67 69 73 74 65 72 54 imul $0x4d547265,0x74(%ebx),%esi
4e4: 4d
4e5: 43 6c rex.XB insb (%dx),%es:(%rdi)
4e7: 6f outsl %ds:(%rsi),(%dx)
4e8: 6e outsb %ds:(%rsi),(%dx)
4e9: 65 54 gs push %rsp
4eb: 61 (bad)
4ec: 62 .byte 0x62
4ed: 6c insb (%dx),%es:(%rdi)
4ee: 65 gs
...

Disassembly of section .gnu.version:

00000000000004f0 <.gnu.version>:
4f0: 00 00 add %al,(%rax)
4f2: 02 00 add (%rax),%al
4f4: 01 00 add %eax,(%rax)
4f6: 01 00 add %eax,(%rax)
4f8: 01 00 add %eax,(%rax)
4fa: 03 00 add (%rax),%eax

Disassembly of section .gnu.version_r:

0000000000000500 <.gnu.version_r>:
500: 01 00 add %eax,(%rax)
502: 02 00 add (%rax),%al
504: 22 00 and (%rax),%al
506: 00 00 add %al,(%rax)
508: 10 00 adc %al,(%rax)
50a: 00 00 add %al,(%rax)
50c: 00 00 add %al,(%rax)
50e: 00 00 add %al,(%rax)
510: 75 1a jne 52c <__cxa_finalize@plt-0xb04>
512: 69 09 00 00 03 00 imul $0x30000,(%rcx),%ecx
518: 2c 00 sub $0x0,%al
51a: 00 00 add %al,(%rax)
51c: 10 00 adc %al,(%rax)
51e: 00 00 add %al,(%rax)
520: b4 91 mov $0x91,%ah
522: 96 xchg %eax,%esi
523: 06 (bad)
524: 00 00 add %al,(%rax)
526: 02 00 add (%rax),%al
528: 38 00 cmp %al,(%rax)
52a: 00 00 add %al,(%rax)
52c: 00 00 add %al,(%rax)
...

Disassembly of section .rela.dyn:

0000000000000530 <.rela.dyn>:
530: f0 3d 00 00 00 00 lock cmp $0x0,%eax
536: 00 00 add %al,(%rax)
538: 08 00 or %al,(%rax)
53a: 00 00 add %al,(%rax)
53c: 00 00 add %al,(%rax)
53e: 00 00 add %al,(%rax)
540: 20 11 and %dl,(%rcx)
542: 00 00 add %al,(%rax)
544: 00 00 add %al,(%rax)
546: 00 00 add %al,(%rax)
548: f8 clc
549: 3d 00 00 00 00 cmp $0x0,%eax
54e: 00 00 add %al,(%rax)
550: 08 00 or %al,(%rax)
552: 00 00 add %al,(%rax)
554: 00 00 add %al,(%rax)
556: 00 00 add %al,(%rax)
558: e0 10 loopne 56a <__cxa_finalize@plt-0xac6>
55a: 00 00 add %al,(%rax)
55c: 00 00 add %al,(%rax)
55e: 00 00 add %al,(%rax)
560: 08 40 00 or %al,0x0(%rax)
563: 00 00 add %al,(%rax)
565: 00 00 add %al,(%rax)
567: 00 08 add %cl,(%rax)
569: 00 00 add %al,(%rax)
56b: 00 00 add %al,(%rax)
56d: 00 00 add %al,(%rax)
56f: 00 08 add %cl,(%rax)
571: 40 00 00 rex add %al,(%rax)
574: 00 00 add %al,(%rax)
576: 00 00 add %al,(%rax)
578: d8 3f fdivrs (%rdi)
57a: 00 00 add %al,(%rax)
57c: 00 00 add %al,(%rax)
57e: 00 00 add %al,(%rax)
580: 06 (bad)
581: 00 00 add %al,(%rax)
583: 00 01 add %al,(%rcx)
...
58d: 00 00 add %al,(%rax)
58f: 00 e0 add %ah,%al
591: 3f (bad)
592: 00 00 add %al,(%rax)
594: 00 00 add %al,(%rax)
596: 00 00 add %al,(%rax)
598: 06 (bad)
599: 00 00 add %al,(%rax)
59b: 00 02 add %al,(%rdx)
...
5a5: 00 00 add %al,(%rax)
5a7: 00 e8 add %ch,%al
5a9: 3f (bad)
5aa: 00 00 add %al,(%rax)
5ac: 00 00 add %al,(%rax)
5ae: 00 00 add %al,(%rax)
5b0: 06 (bad)
5b1: 00 00 add %al,(%rax)
5b3: 00 03 add %al,(%rbx)
...
5bd: 00 00 add %al,(%rax)
5bf: 00 f0 add %dh,%al
5c1: 3f (bad)
5c2: 00 00 add %al,(%rax)
5c4: 00 00 add %al,(%rax)
5c6: 00 00 add %al,(%rax)
5c8: 06 (bad)
5c9: 00 00 add %al,(%rax)
5cb: 00 04 00 add %al,(%rax,%rax,1)
...
5d6: 00 00 add %al,(%rax)
5d8: f8 clc
5d9: 3f (bad)
5da: 00 00 add %al,(%rax)
5dc: 00 00 add %al,(%rax)
5de: 00 00 add %al,(%rax)
5e0: 06 (bad)
5e1: 00 00 add %al,(%rax)
5e3: 00 05 00 00 00 00 add %al,0x0(%rip) # 5e9 <__cxa_finalize@plt-0xa47>
5e9: 00 00 add %al,(%rax)
5eb: 00 00 add %al,(%rax)
5ed: 00 00 add %al,(%rax)
...

Disassembly of section .init:

0000000000001000 <.init>:
1000: f3 0f 1e fa endbr64
1004: 48 83 ec 08 sub $0x8,%rsp
1008: 48 8b 05 d9 2f 00 00 mov 0x2fd9(%rip),%rax # 3fe8 <__cxa_finalize@plt+0x2fb8>
100f: 48 85 c0 test %rax,%rax
1012: 74 02 je 1016 <__cxa_finalize@plt-0x1a>
1014: ff d0 call *%rax
1016: 48 83 c4 08 add $0x8,%rsp
101a: c3 ret

Disassembly of section .plt:

0000000000001020 <.plt>:
1020: ff 35 a2 2f 00 00 push 0x2fa2(%rip) # 3fc8 <__cxa_finalize@plt+0x2f98>
1026: f2 ff 25 a3 2f 00 00 bnd jmp *0x2fa3(%rip) # 3fd0 <__cxa_finalize@plt+0x2fa0>
102d: 0f 1f 00 nopl (%rax)

Disassembly of section .plt.got:

0000000000001030 <__cxa_finalize@plt>:
1030: f3 0f 1e fa endbr64
1034: f2 ff 25 bd 2f 00 00 bnd jmp *0x2fbd(%rip) # 3ff8 <__cxa_finalize@plt+0x2fc8>
103b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)

Disassembly of section .text:

0000000000001040 <.text>:
1040: f3 0f 1e fa endbr64
1044: 31 ed xor %ebp,%ebp
1046: 49 89 d1 mov %rdx,%r9
1049: 5e pop %rsi
104a: 48 89 e2 mov %rsp,%rdx
104d: 48 83 e4 f0 and $0xfffffffffffffff0,%rsp
1051: 50 push %rax
1052: 54 push %rsp
1053: 45 31 c0 xor %r8d,%r8d
1056: 31 c9 xor %ecx,%ecx
1058: 48 8d 3d ca 00 00 00 lea 0xca(%rip),%rdi # 1129 <__cxa_finalize@plt+0xf9>
105f: ff 15 73 2f 00 00 call *0x2f73(%rip) # 3fd8 <__cxa_finalize@plt+0x2fa8>
1065: f4 hlt
1066: 66 2e 0f 1f 84 00 00 cs nopw 0x0(%rax,%rax,1)
106d: 00 00 00
1070: 48 8d 3d 99 2f 00 00 lea 0x2f99(%rip),%rdi # 4010 <__cxa_finalize@plt+0x2fe0>
1077: 48 8d 05 92 2f 00 00 lea 0x2f92(%rip),%rax # 4010 <__cxa_finalize@plt+0x2fe0>
107e: 48 39 f8 cmp %rdi,%rax
1081: 74 15 je 1098 <__cxa_finalize@plt+0x68>
1083: 48 8b 05 56 2f 00 00 mov 0x2f56(%rip),%rax # 3fe0 <__cxa_finalize@plt+0x2fb0>
108a: 48 85 c0 test %rax,%rax
108d: 74 09 je 1098 <__cxa_finalize@plt+0x68>
108f: ff e0 jmp *%rax
1091: 0f 1f 80 00 00 00 00 nopl 0x0(%rax)
1098: c3 ret
1099: 0f 1f 80 00 00 00 00 nopl 0x0(%rax)
10a0: 48 8d 3d 69 2f 00 00 lea 0x2f69(%rip),%rdi # 4010 <__cxa_finalize@plt+0x2fe0>
10a7: 48 8d 35 62 2f 00 00 lea 0x2f62(%rip),%rsi # 4010 <__cxa_finalize@plt+0x2fe0>
10ae: 48 29 fe sub %rdi,%rsi
10b1: 48 89 f0 mov %rsi,%rax
10b4: 48 c1 ee 3f shr $0x3f,%rsi
10b8: 48 c1 f8 03 sar $0x3,%rax
10bc: 48 01 c6 add %rax,%rsi
10bf: 48 d1 fe sar %rsi
10c2: 74 14 je 10d8 <__cxa_finalize@plt+0xa8>
10c4: 48 8b 05 25 2f 00 00 mov 0x2f25(%rip),%rax # 3ff0 <__cxa_finalize@plt+0x2fc0>
10cb: 48 85 c0 test %rax,%rax
10ce: 74 08 je 10d8 <__cxa_finalize@plt+0xa8>
10d0: ff e0 jmp *%rax
10d2: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1)
10d8: c3 ret
10d9: 0f 1f 80 00 00 00 00 nopl 0x0(%rax)
10e0: f3 0f 1e fa endbr64
10e4: 80 3d 25 2f 00 00 00 cmpb $0x0,0x2f25(%rip) # 4010 <__cxa_finalize@plt+0x2fe0>
10eb: 75 2b jne 1118 <__cxa_finalize@plt+0xe8>
10ed: 55 push %rbp
10ee: 48 83 3d 02 2f 00 00 cmpq $0x0,0x2f02(%rip) # 3ff8 <__cxa_finalize@plt+0x2fc8>
10f5: 00
10f6: 48 89 e5 mov %rsp,%rbp
10f9: 74 0c je 1107 <__cxa_finalize@plt+0xd7>
10fb: 48 8b 3d 06 2f 00 00 mov 0x2f06(%rip),%rdi # 4008 <__cxa_finalize@plt+0x2fd8>
1102: e8 29 ff ff ff call 1030 <__cxa_finalize@plt>
1107: e8 64 ff ff ff call 1070 <__cxa_finalize@plt+0x40>
110c: c6 05 fd 2e 00 00 01 movb $0x1,0x2efd(%rip) # 4010 <__cxa_finalize@plt+0x2fe0>
1113: 5d pop %rbp
1114: c3 ret
1115: 0f 1f 00 nopl (%rax)
1118: c3 ret
1119: 0f 1f 80 00 00 00 00 nopl 0x0(%rax)
1120: f3 0f 1e fa endbr64
1124: e9 77 ff ff ff jmp 10a0 <__cxa_finalize@plt+0x70>
1129: f3 0f 1e fa endbr64
112d: 55 push %rbp
112e: 48 89 e5 mov %rsp,%rbp
1131: b8 2a 00 00 00 mov $0x2a,%eax
1136: 5d pop %rbp
1137: c3 ret

Disassembly of section .fini:

0000000000001138 <.fini>:
1138: f3 0f 1e fa endbr64
113c: 48 83 ec 08 sub $0x8,%rsp
1140: 48 83 c4 08 add $0x8,%rsp
1144: c3 ret

Disassembly of section .rodata:

0000000000002000 <.rodata>:
2000: 01 00 add %eax,(%rax)
2002: 02 00 add (%rax),%al

Disassembly of section .eh_frame_hdr:

0000000000002004 <.eh_frame_hdr>:
2004: 01 1b add %ebx,(%rbx)
2006: 03 3b add (%rbx),%edi
2008: 28 00 sub %al,(%rax)
200a: 00 00 add %al,(%rax)
200c: 04 00 add $0x0,%al
200e: 00 00 add %al,(%rax)
2010: 1c f0 sbb $0xf0,%al
2012: ff (bad)
2013: ff 5c 00 00 lcall *0x0(%rax,%rax,1)
2017: 00 2c f0 add %ch,(%rax,%rsi,8)
201a: ff (bad)
201b: ff 84 00 00 00 3c f0 incl -0xfc40000(%rax,%rax,1)
2022: ff (bad)
2023: ff 44 00 00 incl 0x0(%rax,%rax,1)
2027: 00 25 f1 ff ff 9c add %ah,-0x6300000f(%rip) # ffffffff9d00201e <__cxa_finalize@plt+0xffffffff9d000fee>
202d: 00 00 add %al,(%rax)
...

Disassembly of section .eh_frame:

0000000000002030 <.eh_frame>:
2030: 14 00 adc $0x0,%al
2032: 00 00 add %al,(%rax)
2034: 00 00 add %al,(%rax)
2036: 00 00 add %al,(%rax)
2038: 01 7a 52 add %edi,0x52(%rdx)
203b: 00 01 add %al,(%rcx)
203d: 78 10 js 204f <__cxa_finalize@plt+0x101f>
203f: 01 1b add %ebx,(%rbx)
2041: 0c 07 or $0x7,%al
2043: 08 90 01 00 00 14 or %dl,0x14000001(%rax)
2049: 00 00 add %al,(%rax)
204b: 00 1c 00 add %bl,(%rax,%rax,1)
204e: 00 00 add %al,(%rax)
2050: f0 ef lock out %eax,(%dx)
2052: ff (bad)
2053: ff 26 jmp *(%rsi)
2055: 00 00 add %al,(%rax)
2057: 00 00 add %al,(%rax)
2059: 44 07 rex.R (bad)
205b: 10 00 adc %al,(%rax)
205d: 00 00 add %al,(%rax)
205f: 00 24 00 add %ah,(%rax,%rax,1)
2062: 00 00 add %al,(%rax)
2064: 34 00 xor $0x0,%al
2066: 00 00 add %al,(%rax)
2068: b8 ef ff ff 10 mov $0x10ffffef,%eax
206d: 00 00 add %al,(%rax)
206f: 00 00 add %al,(%rax)
2071: 0e (bad)
2072: 10 46 0e adc %al,0xe(%rsi)
2075: 18 4a 0f sbb %cl,0xf(%rdx)
2078: 0b 77 08 or 0x8(%rdi),%esi
207b: 80 00 3f addb $0x3f,(%rax)
207e: 1a 3a sbb (%rdx),%bh
2080: 2a 33 sub (%rbx),%dh
2082: 24 22 and $0x22,%al
2084: 00 00 add %al,(%rax)
2086: 00 00 add %al,(%rax)
2088: 14 00 adc $0x0,%al
208a: 00 00 add %al,(%rax)
208c: 5c pop %rsp
208d: 00 00 add %al,(%rax)
208f: 00 a0 ef ff ff 10 add %ah,0x10ffffef(%rax)
...
209d: 00 00 add %al,(%rax)
209f: 00 1c 00 add %bl,(%rax,%rax,1)
20a2: 00 00 add %al,(%rax)
20a4: 74 00 je 20a6 <__cxa_finalize@plt+0x1076>
20a6: 00 00 add %al,(%rax)
20a8: 81 f0 ff ff 0f 00 xor $0xfffff,%eax
20ae: 00 00 add %al,(%rax)
20b0: 00 45 0e add %al,0xe(%rbp)
20b3: 10 86 02 43 0d 06 adc %al,0x60d4302(%rsi)
20b9: 46 0c 07 rex.RX or $0x7,%al
20bc: 08 00 or %al,(%rax)
20be: 00 00 add %al,(%rax)
20c0: 00 00 add %al,(%rax)
...

Disassembly of section .init_array:

0000000000003df0 <.init_array>:
3df0: 20 11 and %dl,(%rcx)
3df2: 00 00 add %al,(%rax)
3df4: 00 00 add %al,(%rax)
...

Disassembly of section .fini_array:

0000000000003df8 <.fini_array>:
3df8: e0 10 loopne 3e0a <__cxa_finalize@plt+0x2dda>
3dfa: 00 00 add %al,(%rax)
3dfc: 00 00 add %al,(%rax)
...

Disassembly of section .dynamic:

0000000000003e00 <.dynamic>:
3e00: 01 00 add %eax,(%rax)
3e02: 00 00 add %al,(%rax)
3e04: 00 00 add %al,(%rax)
3e06: 00 00 add %al,(%rax)
3e08: 22 00 and (%rax),%al
3e0a: 00 00 add %al,(%rax)
3e0c: 00 00 add %al,(%rax)
3e0e: 00 00 add %al,(%rax)
3e10: 0c 00 or $0x0,%al
3e12: 00 00 add %al,(%rax)
3e14: 00 00 add %al,(%rax)
3e16: 00 00 add %al,(%rax)
3e18: 00 10 add %dl,(%rax)
3e1a: 00 00 add %al,(%rax)
3e1c: 00 00 add %al,(%rax)
3e1e: 00 00 add %al,(%rax)
3e20: 0d 00 00 00 00 or $0x0,%eax
3e25: 00 00 add %al,(%rax)
3e27: 00 38 add %bh,(%rax)
3e29: 11 00 adc %eax,(%rax)
3e2b: 00 00 add %al,(%rax)
3e2d: 00 00 add %al,(%rax)
3e2f: 00 19 add %bl,(%rcx)
3e31: 00 00 add %al,(%rax)
3e33: 00 00 add %al,(%rax)
3e35: 00 00 add %al,(%rax)
3e37: 00 f0 add %dh,%al
3e39: 3d 00 00 00 00 cmp $0x0,%eax
3e3e: 00 00 add %al,(%rax)
3e40: 1b 00 sbb (%rax),%eax
3e42: 00 00 add %al,(%rax)
3e44: 00 00 add %al,(%rax)
3e46: 00 00 add %al,(%rax)
3e48: 08 00 or %al,(%rax)
3e4a: 00 00 add %al,(%rax)
3e4c: 00 00 add %al,(%rax)
3e4e: 00 00 add %al,(%rax)
3e50: 1a 00 sbb (%rax),%al
3e52: 00 00 add %al,(%rax)
3e54: 00 00 add %al,(%rax)
3e56: 00 00 add %al,(%rax)
3e58: f8 clc
3e59: 3d 00 00 00 00 cmp $0x0,%eax
3e5e: 00 00 add %al,(%rax)
3e60: 1c 00 sbb $0x0,%al
3e62: 00 00 add %al,(%rax)
3e64: 00 00 add %al,(%rax)
3e66: 00 00 add %al,(%rax)
3e68: 08 00 or %al,(%rax)
3e6a: 00 00 add %al,(%rax)
3e6c: 00 00 add %al,(%rax)
3e6e: 00 00 add %al,(%rax)
3e70: f5 cmc
3e71: fe (bad)
3e72: ff 6f 00 ljmp *0x0(%rdi)
3e75: 00 00 add %al,(%rax)
3e77: 00 b0 03 00 00 00 add %dh,0x3(%rax)
3e7d: 00 00 add %al,(%rax)
3e7f: 00 05 00 00 00 00 add %al,0x0(%rip) # 3e85 <__cxa_finalize@plt+0x2e55>
3e85: 00 00 add %al,(%rax)
3e87: 00 68 04 add %ch,0x4(%rax)
3e8a: 00 00 add %al,(%rax)
3e8c: 00 00 add %al,(%rax)
3e8e: 00 00 add %al,(%rax)
3e90: 06 (bad)
3e91: 00 00 add %al,(%rax)
3e93: 00 00 add %al,(%rax)
3e95: 00 00 add %al,(%rax)
3e97: 00 d8 add %bl,%al
3e99: 03 00 add (%rax),%eax
3e9b: 00 00 add %al,(%rax)
3e9d: 00 00 add %al,(%rax)
3e9f: 00 0a add %cl,(%rdx)
3ea1: 00 00 add %al,(%rax)
3ea3: 00 00 add %al,(%rax)
3ea5: 00 00 add %al,(%rax)
3ea7: 00 88 00 00 00 00 add %cl,0x0(%rax)
3ead: 00 00 add %al,(%rax)
3eaf: 00 0b add %cl,(%rbx)
3eb1: 00 00 add %al,(%rax)
3eb3: 00 00 add %al,(%rax)
3eb5: 00 00 add %al,(%rax)
3eb7: 00 18 add %bl,(%rax)
3eb9: 00 00 add %al,(%rax)
3ebb: 00 00 add %al,(%rax)
3ebd: 00 00 add %al,(%rax)
3ebf: 00 15 00 00 00 00 add %dl,0x0(%rip) # 3ec5 <__cxa_finalize@plt+0x2e95>
...
3ecd: 00 00 add %al,(%rax)
3ecf: 00 03 add %al,(%rbx)
3ed1: 00 00 add %al,(%rax)
3ed3: 00 00 add %al,(%rax)
3ed5: 00 00 add %al,(%rax)
3ed7: 00 c0 add %al,%al
3ed9: 3f (bad)
3eda: 00 00 add %al,(%rax)
3edc: 00 00 add %al,(%rax)
3ede: 00 00 add %al,(%rax)
3ee0: 07 (bad)
3ee1: 00 00 add %al,(%rax)
3ee3: 00 00 add %al,(%rax)
3ee5: 00 00 add %al,(%rax)
3ee7: 00 30 add %dh,(%rax)
3ee9: 05 00 00 00 00 add $0x0,%eax
3eee: 00 00 add %al,(%rax)
3ef0: 08 00 or %al,(%rax)
3ef2: 00 00 add %al,(%rax)
3ef4: 00 00 add %al,(%rax)
3ef6: 00 00 add %al,(%rax)
3ef8: c0 00 00 rolb $0x0,(%rax)
3efb: 00 00 add %al,(%rax)
3efd: 00 00 add %al,(%rax)
3eff: 00 09 add %cl,(%rcx)
3f01: 00 00 add %al,(%rax)
3f03: 00 00 add %al,(%rax)
3f05: 00 00 add %al,(%rax)
3f07: 00 18 add %bl,(%rax)
3f09: 00 00 add %al,(%rax)
3f0b: 00 00 add %al,(%rax)
3f0d: 00 00 add %al,(%rax)
3f0f: 00 1e add %bl,(%rsi)
3f11: 00 00 add %al,(%rax)
3f13: 00 00 add %al,(%rax)
3f15: 00 00 add %al,(%rax)
3f17: 00 08 add %cl,(%rax)
3f19: 00 00 add %al,(%rax)
3f1b: 00 00 add %al,(%rax)
3f1d: 00 00 add %al,(%rax)
3f1f: 00 fb add %bh,%bl
3f21: ff (bad)
3f22: ff 6f 00 ljmp *0x0(%rdi)
3f25: 00 00 add %al,(%rax)
3f27: 00 01 add %al,(%rcx)
3f29: 00 00 add %al,(%rax)
3f2b: 08 00 or %al,(%rax)
3f2d: 00 00 add %al,(%rax)
3f2f: 00 fe add %bh,%dh
3f31: ff (bad)
3f32: ff 6f 00 ljmp *0x0(%rdi)
3f35: 00 00 add %al,(%rax)
3f37: 00 00 add %al,(%rax)
3f39: 05 00 00 00 00 add $0x0,%eax
3f3e: 00 00 add %al,(%rax)
3f40: ff (bad)
3f41: ff (bad)
3f42: ff 6f 00 ljmp *0x0(%rdi)
3f45: 00 00 add %al,(%rax)
3f47: 00 01 add %al,(%rcx)
3f49: 00 00 add %al,(%rax)
3f4b: 00 00 add %al,(%rax)
3f4d: 00 00 add %al,(%rax)
3f4f: 00 f0 add %dh,%al
3f51: ff (bad)
3f52: ff 6f 00 ljmp *0x0(%rdi)
3f55: 00 00 add %al,(%rax)
3f57: 00 f0 add %dh,%al
3f59: 04 00 add $0x0,%al
3f5b: 00 00 add %al,(%rax)
3f5d: 00 00 add %al,(%rax)
3f5f: 00 f9 add %bh,%cl
3f61: ff (bad)
3f62: ff 6f 00 ljmp *0x0(%rdi)
3f65: 00 00 add %al,(%rax)
3f67: 00 03 add %al,(%rbx)
...

Disassembly of section .got:

0000000000003fc0 <.got>:
3fc0: 00 3e add %bh,(%rsi)
...

Disassembly of section .data:

0000000000004000 <.data>:
...
4008: 08 40 00 or %al,0x0(%rax)
400b: 00 00 add %al,(%rax)
400d: 00 00 add %al,(%rax)
...

Disassembly of section .bss:

0000000000004010 <.bss>:
...

Disassembly of section .comment:

0000000000000000 <.comment>:
0: 47 rex.RXB
1: 43 rex.XB
2: 43 3a 20 rex.XB cmp (%r8),%spl
5: 28 55 62 sub %dl,0x62(%rbp)
8: 75 6e jne 78 <__cxa_finalize@plt-0xfb8>
a: 74 75 je 81 <__cxa_finalize@plt-0xfaf>
c: 20 31 and %dh,(%rcx)
e: 31 2e xor %ebp,(%rsi)
10: 34 2e xor $0x2e,%al
12: 30 2d 31 75 62 75 xor %ch,0x75627531(%rip) # 75627549 <__cxa_finalize@plt+0x75626519>
18: 6e outsb %ds:(%rsi),(%dx)
19: 74 75 je 90 <__cxa_finalize@plt-0xfa0>
1b: 31 7e 32 xor %edi,0x32(%rsi)
1e: 32 2e xor (%rsi),%ch
20: 30 34 29 xor %dh,(%rcx,%rbp,1)
23: 20 31 and %dh,(%rcx)
25: 31 2e xor %ebp,(%rsi)
27: 34 2e xor $0x2e,%al
29: 30 00 xor %al,(%rax)



... Então Jesus afirmou de novo: “(...) eu vim para que tenham vida, e a tenham plenamente.” (João 10:7-10)


20. Re: Dificuldade em ler binário

Apprentice X
ApprenticeX

(usa FreeBSD)

Enviado em 22/05/2024 - 01:44h

paulo1205 escreveu:
Não sei qual a intenção do OP ao fazer um dump binário do seu código.

O Objetivo não é um disassemble. O Objetivo é entender o que está escrito e porque. Citando um exemplo, se leio no arquivo um "RS" que trata-se de um caracter ilegível, eu sei o que significa e faz esse character, sei o porque ele está ali escrito.

Programas que leem um binário para fazer um disassemble, ou mesmo dar informações do binário, quem cria esses programas sabe o que está escrito em binário, até para localizar as seções onde estão as informações.

Citando outro exemplo mais fácil do que eu quero:
Quando olhamos um arquivo HTML no Browser: Veremos algo assim: Bom Dia!
Mas se lermos o arquivo HTML de verdade, veremos algo assim: <div><p>Bom Dia!</p></div>
Então cada tag html que existe escrita eu sei para que serve e o que ela faz, e o porque ela está lá, inclusive o porque o programador usou TABS, ou SPACES.

Eu consigo ler o binário da mesma forma como um html. Algumas coisas escritas eu consigo entender. Mas ao converter o binário como mostro na imagem que postei anteriormente, não está fazendo sentido porque cada sequencia binária obviamente esta lá porque é necessária para o computador entender, mas quando olho vários PONTOS "." ou espaços vazios aparentemente sem significado algum, eu gostaria de saber o que significa, porque não são comandos assembly, não são hexadecimais, como mostro na imagem posteriormente postada!

https://www.vivaolinux.com.br/comunidades/imagens/anexos/1715903110.A.png

Teclas que estão escritas com letras eu compreendo.
Não compreendo as que não foram identificadas <?>
Não compreendo os espaços
Não entendo characteres soltos e espalhados no meio de enormes espaços
Characteres que constam na tabela ASCII são fáceis de identificar

Mas imagino que espaços possam siginifcar algum tipo de marcação, ou tabela...

Eu quero poder ler o binário convertido para sequencias binárias que foi convertido para texto para entender o padrão
Em como é escrito esse binário para que o PC compreenda o que está escrito, e para isso, eu tenho que saber ler o arquivo exatamente como o PC lê

Esse é meu objetivo!


21. Re: Dificuldade em ler binário

aguamole
aguamole

(usa KUbuntu)

Enviado em 22/05/2024 - 12:57h

ApprenticeX escreveu:
https://www.vivaolinux.com.br/comunidades/imagens/anexos/1715903110.A.png
Teclas que estão escritas com letras eu compreendo.
Não compreendo as que não foram identificadas <?>
Não compreendo os espaços
Não entendo characteres soltos e espalhados no meio de enormes espaços
Characteres que constam na tabela ASCII são fáceis de identificar

Rapais, esse tempo todo vc estava perguntando dos espaços da imagem? Pó velho, é uma coisa tão lógica, que nem passo isso na minha cabeça que vc queria saber, o computador ele entende apenas ligado e desligado(1 bit ou 0 bit) que é se o transistor vai abrir ou vai fechar, esses 1 bit ou 0 bit se agrupam em grupo de 8 bit que ai forma o byte que é 8 bits, é por isso que vc vê esses espaços, o espaço aparece quando forma 1 byte que é a unidade de medida de grupo de 8bit, não tem significado na linguagem de maquina, isso só aparece apenas para facilitar a você fazer a sua leitura. Pode contar os bits ai, eu te garanto que o espaço só aparece após a contagem de 8 bits.

https://pt.wikipedia.org/wiki/Bit


22. Re: Dificuldade em ler binário

aguamole
aguamole

(usa KUbuntu)

Enviado em 22/05/2024 - 13:27h

Meu 6 dias para eu entender o que vc esta falando. Analfabetismo funcional pego agora.


23. Re: Dificuldade em ler binário

Apprentice X
ApprenticeX

(usa FreeBSD)

Enviado em 23/05/2024 - 00:58h

aguamole escreveu:
Rapais, esse tempo todo vc estava perguntando dos espaços da imagem? Pó velho, é uma coisa tão lógica, que nem passo isso na minha cabeça que vc queria saber, o computador ele entende apenas ligado e desligado(1 bit ou 0 bit) que é se o transistor vai abrir ou vai fechar, esses 1 bit ou 0 bit se agrupam em grupo de 8 bit que ai forma o byte que é 8 bits, é por isso que vc vê esses espaços, o espaço aparece quando forma 1 byte que é a unidade de medida de grupo de 8bit, não tem significado na linguagem de maquina, isso só aparece apenas para facilitar a você fazer a sua leitura. Pode contar os bits ai, eu te garanto que o espaço só aparece após a contagem de 8 bits.
https://pt.wikipedia.org/wiki/Bit

Não compreendi bem sua resposta. Conforme eu disse e você mesmo repetiu: "espaços não tem signifcado na linguagem de máquina"
Logo não eram para existir no arquivo! Porque um arquivo binário seria disperdiçado com vários bytes de cada espaço se não servem pra nada?
Pense 100 espaços = 100 Bytes
Se esses espaços para O PC não são lidos, ou não tem nenhuma serventia, a lógica seria eles não estarem lá, isso diminuiria bastante o tamano do arquivo binário.

aguamole escreveu: garanto que o espaço só aparece após a contagem de 8 bits

Isso não ocorre! Exemplo, se eu escrevo um texto em binário por exemplo: test
Só existirá no arquivo: 01110100011001010111001101110100
Não existe espaço em lugar algum, somente as sequências binárias!

Porque um código compilado iria colocar espaços? se dizem que o compilador remove tanto os espaços e até comentários da linguagem ao gravar? Justamente para não inchar o arquivo binário. Até mesmo muda determinado comandos escritos errados pelo programador para comandos mais simples que fazem a mesma coisa, como substituição de printf("\n"); ou puts(""); para putchar('\n');


24. Re: Dificuldade em ler binário

Apprentice X
ApprenticeX

(usa FreeBSD)

Enviado em 23/05/2024 - 00:59h

aguamole escreveu: Meu 6 dias para eu entender o que vc esta falando. Analfabetismo funcional pego agora.

Acho que trata-se apenas de falta de atenção, talvez por ansiedade!





01 02 03



Patrocínio

Site hospedado pelo provedor RedeHost.
Linux banner

Destaques

Artigos

Dicas

Tópicos

Top 10 do mês

Scripts