Jump to content

fredericopissarra

Membros
  • Content Count

    215
  • Joined

  • Last visited

Community Reputation

164 Excellent

Personal Information

Recent Profile Visitors

The recent visitors block is disabled and is not being shown to other users.

  1. Não sei se já postei isso por aqui, mas aqui vai uma dica rápida para aquelas funções que precisamos criara para comparações, usadas em funções como qsort() e bsearch(). Ambas têm o protótipo: void qsort( void *base, size_t nmemb, size_t size, int (*comp)(const void *, const void *) ); void *bsearch( const void *key, const void *base, size_t nmemb, size_t size, int (*comp)(const void *, const void *) ); Esse ponteiro para a função de comparação espera uma função que retorne <0, 0 ou >0. No caso do qsort() poderemos ficar tentados a escrever uma rotina assim, para ordenação ascendente de um buffer contendo int's: int mycomp( const void *a, const void *b ) { if ( *(const int *)a < *(const int *)b ) return -1; else if ( *(const int *)a > *(const int *)b ) return 1; else return 0; } Ou algo similar... É uma boa rotina, mas essa é melhor: int mycomp( const void *a, const void *b ) { return ( *(const int *)a > *(const int *)b ) - ( *(const int *)a < *(const int *)b ); } Repare que todo resultado de expressão contendo comparações é sempre 0 ou 1 ( e do tipo int )... Ao comparar se (a > b) obtemos 0 ou 1. Mesma coisa para a comparação (a < b)... E, não parece, mas esse último código é um cadinho mais rápido (e menor) que o anterior... Se quiser fazer a rotina mais legível: int mycomp( const void *a, const void *b ) { const int *a_ = a, *b_ = b; return ( *a_ > *b_ ) - ( *a_ < *b_ ); }
  2. Chegando atrasado aqui, mas ai vai um complemento à resposta do @Felipe.Silva: O GCC, sem otimizações ativadas, gera código bem LERDO e bagunçado. Recomendo usar a opção -O2 também: $ gcc -O2 -masm=intel -S prog.c # Ele vai gerar o prog.s Ainda... sem dizer nada, o GCC tende a colocar código para "proteção" da pilha. Para criar uma listagem em asm mais pura prefiro adicionar a opção -fno-stack-protector: $ gcc -O2 -masm=intel -S -fno-stack-protector prog.c # Ele vai gerar o prog.s Eis um exemplo simples: #include <stddef.h> #include <stdint.h> uint64_t sum( uint32_t *p, size_t size ) { uint64_t s; s = 0; while ( size-- ) s += *p++; return s; } Compilado sem otimizações (retiradas as diretivas): sum: push rbp mov rbp, rsp mov QWORD PTR -24[rbp], rdi mov QWORD PTR -32[rbp], rsi mov QWORD PTR -8[rbp], 0 jmp .L2 .L3: mov rax, QWORD PTR -24[rbp] lea rdx, 4[rax] mov QWORD PTR -24[rbp], rdx mov eax, DWORD PTR [rax] mov eax, eax add QWORD PTR -8[rbp], rax .L2: mov rax, QWORD PTR -32[rbp] lea rdx, -1[rax] mov QWORD PTR -32[rbp], rdx test rax, rax jne .L3 mov rax, QWORD PTR -8[rbp] pop rbp ret Compilado com otimização -O2: sum: test rsi, rsi je .L4 xor edx, edx xor eax, eax .L3: mov ecx, DWORD PTR [rdi+rdx*4] add rdx, 1 add rax, rcx cmp rdx, rsi jne .L3 rep ret .L4: xor eax, eax ret Note que a segunda compilação não usa o stack frame e usa os registradores ao máximo (com apenas 1 referência à memória)... Acho a segunda mais fácil de entender que a primeira.
  3. Eu tava ppensando em algo assim: Só que mais "simples" (e bataro)... Tem uns modelos da Tectronix de $800.
  4. /* boo.c Compile com: gcc -o boo boo.c */ #include <stdio.h> int main( void ) { static char tbl[] = { 28, ' ', 4, 'o', 12, '$', 4, 'o', 1, '\n', 24, ' ', 2, 'o', 24, '$', 1, 'o', 1, '\n', 21, ' ', 2, 'o', 30, '$', 1, 'o', 9, ' ', 1, 'o', 1, '$', 3, ' ', 2, '$', 1, ' ', 1, 'o', 1, '$', 1, '\n', 5, ' ', 1, 'o', 1, ' ', 1, '$', 1, ' ', 2, 'o', 8, ' ', 1, 'o', 36, '$', 1, 'o', 7, ' ', 2, '$', 1, ' ', 2, '$', 1, ' ', 2, '$', 1, 'o', 1, '$', 1, '\n', 2, ' ', 2, 'o', 1, ' ', 1, '$', 1, ' ', 1, '$', 1, ' ', 1, '"', 1, '$', 6, ' ', 1, 'o', 9, '$', 4, ' ', 13, '$', 4, ' ', 9, '$', 1, 'o', 7, ' ', 3, '$', 1, 'o', 2, '$', 1, 'o', 1, '$', 1, '\n', 2, ' ', 1, '"', 6, '$', 1, 'o', 1, '$', 5, ' ', 1, 'o', 9, '$', 6, ' ', 11, '$', 6, ' ', 10, '$', 1, 'o', 4, ' ', 8, '$', 1, '\n', 4, ' ', 7, '$', 4, ' ', 11, '$', 6, ' ', 11, '$', 6, ' ', 23, '$', 1, '\n', 4, ' ', 23, '$', 4, ' ', 13, '$', 4, ' ', 14, '$', 2, ' ', 3, '"', 3, '$', 1, '\n', 5, ' ', 1, '"', 3, '$', 4, '"', 49, '$', 5, ' ', 1, '"', 3, '$', 1, '\n', 6, ' ', 3, '$', 3, ' ', 1, 'o', 50, '$', 5, ' ', 1, '"', 3, '$', 1, 'o', 1, '\n', 5, ' ', 1, 'o', 2, '$', 1, '"', 3, ' ', 51, '$', 7, ' ', 3, '$', 1, 'o', 1, '\n', 5, ' ', 3, '$', 4, ' ', 45, '$', 1, '"', 1, ' ', 1, '"', 6, '$', 5, 'o', 4, '$', 1, 'o', 1, '\n', 4, ' ', 1, 'o', 3, '$', 4, 'o', 5, '$', 2, ' ', 37, '$', 3, ' ', 1, 'o', 17, '$', 1, '\n', 4, ' ', 8, '$', 1, '"', 4, '$', 3, ' ', 34, '$', 5, ' ', 4, '$', 8, '"', 1, '\n', 3, ' ', 4, '"', 7, ' ', 4, '$', 4, ' ', 1, '"', 28, '$', 1, '"', 6, ' ', 1, 'o', 3, '$', 1, '\n', 14, ' ', 1, '"', 3, '$', 1, 'o', 5, ' ', 3, '"', 18, '$', 1, '"', 2, '$', 1, '"', 9, ' ', 3, '$', 1, '\n', 16, ' ', 3, '$', 1, 'o', 10, ' ', 1, '"', 2, '$', 2, '"', 6, '$', 4, '"', 11, ' ', 1, 'o', 3, '$', 1, '\n', 17, ' ', 4, '$', 1, 'o', 32, ' ', 1, 'o', 3, '$', 1, '"', 1, '\n', 18, ' ', 1, '"', 4, '$', 1, 'o', 6, ' ', 1, 'o', 6, '$', 1, 'o', 1, '"', 4, '$', 1, 'o', 8, ' ', 1, 'o', 4, '$', 1, '\n', 20, ' ', 1, '"', 5, '$', 2, 'o', 5, ' ', 2, '"', 4, '$', 1, 'o', 5, '$', 1, 'o', 3, ' ', 1, 'o', 4, '$', 2, '"', 1, '\n', 23, ' ', 2, '"', 5, '$', 4, 'o', 2, ' ', 1, '"', 3, '$', 1, 'o', 9, '$', 3, '"', 1, '\n', 26, ' ', 2, '"', 7, '$', 2, 'o', 1, ' ', 10, '$', 1, '\n', 34, ' ', 4, '"', 11, '$', 1, '\n', 38, ' ', 12, '$', 1, '\n', 39, ' ', 10, '$', 1, '"', 1, '\n', 40, ' ', 1, '"', 3, '$', 4, '"', 1, '\n', 0 }; char *p = tbl; char c, len; while ( *p ) { len = *p++; c = *p++; while ( len-- ) { #ifdef __WIN32 if ( c == '\n' ) { fputs( "\r\n", stdout ); continue; } #endif putchar( c ); } } } Antes que perguntem... roubei isso de um "easter egg" do VIM.
  5. Anyway... gostei da iniciativa para "iniciantes". Mostrar a cara das ferramentas e comentários práticos ficou excelente!
  6. Não é lá muito confiável, huh? Resolução (em bits), cadê? Taxa de amostragem (cadê)? 2% de erro (MUITO!)... Tem screenshots? (vi essa saidinha HDMI ai)... Estava pensando em algo um cadinho mais profissional... PS: Entre isso e usar a entrada de audio do PC para fazer sampling, a segunda fica ainda mais barata... 🙂
  7. Há anos que não "futuco" mais circuitos e tenho pensado em montar meu pequeno laboratório em casa... Eis uma pergunta: Qual osciloscópio, de bom preço (mais barato) você recomendaria (e onde comprá-lo)? Estou pensando num não tão simples assim, com capacidade de storage (Analisador lógico?!) para lidar com sinais digitais também (não cíclicos)... Ainda tenho muito o que adquirir aqui para ter um pequeno laboratório "do meu jeito"... 😉 PS: Eu ainda não tenho muito interesse em RF...
  8. Algumas coisas podem ser retiradas... Eis um makefile para seu hello.c: CFLAGS=-O2 -fno-stack-protector # No meu caso, as libs do GCC 7 estão no diretório CRT_GCC_PATH. # CRT de "C RunTime". CRT_GCC_PATH=/usr/lib/gcc/x86_64-linux-gnu/7 CRT_PATH=/usr/lib/x86_64-linux-gnu/ # O linker precisa do plugin dynamic linker para linkar códigos do GCC (por quê executáveis no modo x86-64 são, essencialmente, shared # objects que são carregados por esse "runtime"); # # O executável precisa ser PIE (para o x86-64); # # Scrt1.o, crti.o, crtbeginS.o, crtendS.o e crtn.o precisam ser linkados junto com libgcc_s e libgcc, bem como a libc. # Esses são os códigos de inicialização e finalização da libc (e builtins do GCC). # # O formato do elf é elf_x86_64 por default, assim a opção -m é desnecessária. LDFLAGS=--dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -L$(CRT_GCC_PATH) -L$(CRT_PATH) -s CRT_OBJECTS=$(CRT_PATH)/Scrt1.o $(CRT_PATH)/crti.o $(CRT_GCC_PATH)/crtbeginS.o $(CRT_GCC_PATH)/crtendS.o $(CRT_PATH)/crtn.o LIBS=-lc -lgcc_s -lgcc # Em essência isso faz a mesma coisa que `gcc -o hello hello.o`. # Adicionei um exemplo onde apago a section .comment do binário final, diminuindo o tamanho um pouquinho... hello: hello.o Makefile $(LD) $(LDFLAGS) -o $@.elf $(CRT_OBJECTS) $< $(LIBS) objcopy -R .comment $@.elf $@ && rm $@.elf hello.o: hello.c Como demonstração da alegação do executável ser um shared object: $ make cc -O2 -fno-stack-protector -c -o hello.o hello.c ld --dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -L/usr/lib/gcc/x86_64-linux-gnu/7 -L/usr/lib/x86_64-linux-gnu/ -s -o hello.elf /usr/lib/x86_64-linux-gnu//Scrt1.o /usr/lib/x86_64-linux-gnu//crti.o /usr/lib/gcc/x86_64-linux-gnu/7/crtbeginS.o /usr/lib/gcc/x86_64-linux-gnu/7/crtendS.o /usr/lib/x86_64-linux-gnu//crtn.o hello.o -lc -lgcc_s -lgcc objcopy -R .comment hello.elf hello && rm hello.elf $ ./hello Hello $ file hello hello: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/l, for GNU/Linux 3.2.0, stripped
  9. PS: Conheço um monte de gente que fica espantadíssima e expressam dúvidas de minha alegação, por exemplo, de que consigo ler mais de 100 livros por ano (de conteúdo técnico ou não)... EU considero que quem lê menos de uns 30 livros (e os entende!) por ano é um iletrado (para não usar palavra mais ofensiva!).
  10. Lendro, eu compartilho de sua visão da coisa toda. Pelo que percebo, o problema é que certificações e cursos (de uma forma geral) só têm serventia mesmo se a pessoa está legitimamente interessada no assunto e quer melhorar seu repertório. Algo do tipo "quem sabe não ensinam um truque novo para um cachorro velho?". No geral, de novo, pelo que percebo, a maioria das pessoas tenta usar cursos e certificações como um trampolim profissional, mas de forma totalmente artificial. Ou seja, não é baseado no "eu sei isso", mas, "eu sou certificado nisso". Não foi essa intenção do Fernando, acredito, mas, como ele mesmo disse (parafraseando), é para "facilitar a busca de emprego". Não digo isso de forma leviana, como uma crença pessoal apenas. Trabalhei, durante uma década, como professor de disciplinas técnicas de cursos profissionalizantes do SENAI e, exceto por alguns casos de pessoas genuinamente interessadas no assunto, a maioria faz "cursos" porque "o chefe mandou", porque é uma "folga do trabalho rotineiro" ou porque "vai aumentar o currículo"... A última é uma alegação perfeitamente válida (do ponto de vista da empregabilidade), mas não faz de ninguém um expert. Junte isso ao fato de que o aluno médio não sabe sequer que existem métodos para "estudar" ou o que quer que isso signifique além de "tirar nota boa" e temos experts que não são especializados em coisa alguma, no geral.
  11. A data da criação/modificação/acesso do arquivo fica no filesystem, não no arquivo em si: $ cc -xc -O2 -s -include stdio.h - <<< 'int main(void){puts("Hello.");}' $ ./a.out Hello. $ file ./a.out ./a.out: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/l, for GNU/Linux 3.2.0, BuildID[sha1]=5578b89998d1ac2d8cb3126f7ffc5d9b7b1ff167, stripped $ readelf -e ./a.out ELF Header: Magic: 7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00 Class: ELF64 Data: 2's complement, little endian Version: 1 (current) OS/ABI: UNIX - System V ABI Version: 0 Type: DYN (Shared object file) Machine: Advanced Micro Devices X86-64 Version: 0x1 Entry point address: 0x550 Start of program headers: 64 (bytes into file) Start of section headers: 4400 (bytes into file) Flags: 0x0 Size of this header: 64 (bytes) Size of program headers: 56 (bytes) Number of program headers: 9 Size of section headers: 64 (bytes) Number of section headers: 27 Section header string table index: 26 Section Headers: [Nr] Name Type Address Offset Size EntSize Flags Link Info Align [ 0] NULL 0000000000000000 00000000 0000000000000000 0000000000000000 0 0 0 [ 1] .interp PROGBITS 0000000000000238 00000238 000000000000001c 0000000000000000 A 0 0 1 [ 2] .note.ABI-tag NOTE 0000000000000254 00000254 0000000000000020 0000000000000000 A 0 0 4 [ 3] .note.gnu.build-i NOTE 0000000000000274 00000274 0000000000000024 0000000000000000 A 0 0 4 [ 4] .gnu.hash GNU_HASH 0000000000000298 00000298 000000000000001c 0000000000000000 A 5 0 8 [ 5] .dynsym DYNSYM 00000000000002b8 000002b8 00000000000000a8 0000000000000018 A 6 1 8 [ 6] .dynstr STRTAB 0000000000000360 00000360 0000000000000082 0000000000000000 A 0 0 1 [ 7] .gnu.version VERSYM 00000000000003e2 000003e2 000000000000000e 0000000000000002 A 5 0 2 [ 8] .gnu.version_r VERNEED 00000000000003f0 000003f0 0000000000000020 0000000000000000 A 6 1 8 [ 9] .rela.dyn RELA 0000000000000410 00000410 00000000000000c0 0000000000000018 A 5 0 8 [10] .rela.plt RELA 00000000000004d0 000004d0 0000000000000018 0000000000000018 AI 5 22 8 [11] .init PROGBITS 00000000000004e8 000004e8 0000000000000017 0000000000000000 AX 0 0 4 [12] .plt PROGBITS 0000000000000500 00000500 0000000000000020 0000000000000010 AX 0 0 16 [13] .plt.got PROGBITS 0000000000000520 00000520 0000000000000008 0000000000000008 AX 0 0 8 [14] .text PROGBITS 0000000000000530 00000530 00000000000001a2 0000000000000000 AX 0 0 16 [15] .fini PROGBITS 00000000000006d4 000006d4 0000000000000009 0000000000000000 AX 0 0 4 [16] .rodata PROGBITS 00000000000006e0 000006e0 000000000000000b 0000000000000000 A 0 0 4 [17] .eh_frame_hdr PROGBITS 00000000000006ec 000006ec 000000000000003c 0000000000000000 A 0 0 4 [18] .eh_frame PROGBITS 0000000000000728 00000728 0000000000000100 0000000000000000 A 0 0 8 [19] .init_array INIT_ARRAY 0000000000200db8 00000db8 0000000000000008 0000000000000008 WA 0 0 8 [20] .fini_array FINI_ARRAY 0000000000200dc0 00000dc0 0000000000000008 0000000000000008 WA 0 0 8 [21] .dynamic DYNAMIC 0000000000200dc8 00000dc8 00000000000001f0 0000000000000010 WA 6 0 8 [22] .got PROGBITS 0000000000200fb8 00000fb8 0000000000000048 0000000000000008 WA 0 0 8 [23] .data PROGBITS 0000000000201000 00001000 0000000000000010 0000000000000000 WA 0 0 8 [24] .bss NOBITS 0000000000201010 00001010 0000000000000008 0000000000000000 WA 0 0 1 [25] .comment PROGBITS 0000000000000000 00001010 000000000000002b 0000000000000001 MS 0 0 1 [26] .shstrtab STRTAB 0000000000000000 0000103b 00000000000000ee 0000000000000000 0 0 1 Key to Flags: W (write), A (alloc), X (execute), M (merge), S (strings), I (info), L (link order), O (extra OS processing required), G (group), T (TLS), C (compressed), x (unknown), o (OS specific), E (exclude), l (large), p (processor specific) Program Headers: Type Offset VirtAddr PhysAddr FileSiz MemSiz Flags Align PHDR 0x0000000000000040 0x0000000000000040 0x0000000000000040 0x00000000000001f8 0x00000000000001f8 R 0x8 INTERP 0x0000000000000238 0x0000000000000238 0x0000000000000238 0x000000000000001c 0x000000000000001c R 0x1 [Requesting program interpreter: /lib64/ld-linux-x86-64.so.2] LOAD 0x0000000000000000 0x0000000000000000 0x0000000000000000 0x0000000000000828 0x0000000000000828 R E 0x200000 LOAD 0x0000000000000db8 0x0000000000200db8 0x0000000000200db8 0x0000000000000258 0x0000000000000260 RW 0x200000 DYNAMIC 0x0000000000000dc8 0x0000000000200dc8 0x0000000000200dc8 0x00000000000001f0 0x00000000000001f0 RW 0x8 NOTE 0x0000000000000254 0x0000000000000254 0x0000000000000254 0x0000000000000044 0x0000000000000044 R 0x4 GNU_EH_FRAME 0x00000000000006ec 0x00000000000006ec 0x00000000000006ec 0x000000000000003c 0x000000000000003c R 0x4 GNU_STACK 0x0000000000000000 0x0000000000000000 0x0000000000000000 0x0000000000000000 0x0000000000000000 RW 0x10 GNU_RELRO 0x0000000000000db8 0x0000000000200db8 0x0000000000200db8 0x0000000000000248 0x0000000000000248 R 0x1 Section to Segment mapping: Segment Sections... 00 01 .interp 02 .interp .note.ABI-tag .note.gnu.build-id .gnu.hash .dynsym .dynstr .gnu.version .gnu.version_r .rela.dyn .rela.plt .init .plt .plt.got .text .fini .rodata .eh_frame_hdr .eh_frame 03 .init_array .fini_array .dynamic .got .data .bss 04 .dynamic 05 .note.ABI-tag .note.gnu.build-id 06 .eh_frame_hdr 07 08 .init_array .fini_array .dynamic .got $ stat ./a.out File: ./a.out Size: 6128 Blocks: 16 IO Block: 4096 regular file Device: 811h/2065d Inode: 18614071 Links: 1 Access: (0755/-rwxr-xr-x) Uid: ( 1000/frederico) Gid: ( 1000/frederico) Access: 2019-10-05 13:24:16.941141704 -0300 Modify: 2019-10-05 13:24:16.941141704 -0300 Change: 2019-10-05 13:24:16.941141704 -0300 Birth: -
  12. Alguns vídeos interessantes sobre Diffie-Helman, RSA e ECC: DH: RSA: ECC:
  13. Sim, sim... existe, é claro, um certo exagero (típico de quem quer lucrar), mas RSA está, de fato, com os dias contados e os bancos serão os primeiros a migrarem para ECDSA. De fato, a maioria dos sites já migrou, pelo menos, para o ECDHE (key exchange), uma vez que certificados digitais só servem para autenticação (identificação) e não vale à pena gastar dimdim só para trocar um certificado que ainda é válido (certificados são caros!). Mas, pelo menos, o canal de troca de chave não usa mais o DHE (que é a base do algoritmo RSA). "Ahhh, mas tem o Let's Encrypt!"... Yep, mas o Let's Encrypt também oferece certificados com ECDSA - Embora exista um problema conceitual com ele (o Let's Encrypt, nao o certificado!): Qual é a utilidade de uma "Autoridade Certificadora"? Ela é uma "autoridade" porque estabelece uma cadeia de confiança entre o cliente e o fornecedor do serviço e, por isso, ambos confiam em certificados assinados por ela... Como essa confiança é estabelecida? O fornecedor (site) tem que, além de pagar uma valor pelo certificado (afugentando os pobretões!), verificar a validade dos dados do fornecedor (documentação)... Há alguns anos, autoridades como a Verisign, por exemplo, pediam CNPJ, documentação do responsável técnico, documentação autenticada em cartório, etc... Com o Let's Encrypt quaalquer pessoa pode adquirir um certificado digital assinado, bastando apenas ter um nome válido que possa ser buscado por DNS. Ou seja, a cadeia de confiança só existe no nome "chain of trust", não na prática! Porque estou citando o Let's Encrypt? Só porque percebi que o certificado DESTE forum é deles (e RSA), embora o key exchange seja feito por ECDHE e via TLS 1.2. O problema de todo esquema de criptografia assimétrica, até então, é que eles se baseiam na impossibilidade prática de fatoração. Para encontrar dois números primos relativos enormes e o módulo usado no cálculo, era estimado que um computador doméstico levaria algumas dezenas de bilhões de anos para fazer. Hoje, com alguma grana sobrando, isso tende a cair consideravelmente (alguns anos? meses? semanas? Provavelmente, daqui a uns anos levará alguns segundos!). As curvas elípticas adicionam alguns fatores a mais a esse esquema: A curva é parametrizada pelo lado de quem gera as chaves e, sem esses parâmetros, temos um grupo considerável de curvas disponíveis para a mesma "classe" de curvas (imagine as chaves sendo intersecções de uma linha entre dois pontos da curva. Se você não sabe como a curva se apresenta [não conhece os parâmetros da curva, mas só sua aparência geral], não dá para achar o outro ponto [o primeiro é a chave pública])... Isso, mais o esquema parecido com o Diffie-Helman (aritmética exponencial e modular) torna as EC trocentas vezes mais seguras que o RSA - mesmo para os futuros computadores quênticos...
×
×
  • Create New...