Jump to content

All Activity

This stream auto-updates     

  1. Yesterday
  2. Olá meus queridos escovadores de bytes! Estamos aqui hoje para falar um pouco mais sobre os queridos exploits: queridos para quem os desenvolve e temido por muitas empresas e raças humanas. Em uma terra onde bytes são importantes, um bom escovador de bytes é rei! Então chega de delongas e vamos ao que interessa: Na primeira parte desse tutorial mostramos que podemos fazer um programa feito em S.O Linux se comportar incorretamente, mas não debugamos os resultados, aqui procuraremos desenvolver o mesmo assunto porém mostraremos com maior riqueza de detalhes os registradores que foram modificados. Bem, utilizaremos o mesmo programa vulnerável a buffer overflow, o código é esse: ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ //Programa vulnerável para teste de exploit #include <stdio.h> int main() { char login[15]; char senha[6]; printf(" Login: "); gets(login); printf(" Senha: "); gets(senha); printf("Login %s!!\n\n", login); printf("Senha %s!!\n\n", senha); } ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Graças ao compilador c, tanto no S.O Linux quanto no S.O Windows o código compila sem alteração. Note abaixo que compilaremos o código no Dev C++ Depois foi salvo o código e criado o vuln2.exe Depois abrimos o vuln2.exe no debug Immunity debugger E começamos a entrar dados. Nesse momento nosso objetivo é descobrir se os registradores serão alterados, para que isso ocorra entramos com muitos A que em hexadecimal é 0x41 ou no debug apenas 41. Na primeira entrada de A notamos que não houve alteração. Então continuamos na execução do programa onde o programa nos solicitou que seja teclado uma senha. Daí eu pensei vamos ver o que acontece se colocamos varios A, após a entrada dos mesmo verificamos no nosso debug e constatamos que os registrados ESP e EIP foram alterados para 41414141 conforme mostrado na foto seguinte. O que isso significa para nós? Para alguns isso significa apenas um programa em colapso, mas para nós que seremos escovadores mundiais de bytes, isso significa que você pode carregar um lindo shellcode nessa oportunidade. Bem explicarei mais um pouco para que você entenda a coisa: o registrador EIP de 32 bits é parte do nosso alvo principal pois é nele que alteraremos o ponto da próxima instrução para algo que queremos. Ficou curioso, fique de olho nos outros posts... Por hoje é só, espero que tenha gostado e até a próxima... Autor: Lincoln César dos Reis Arantes - Analista de Sistema(graduado) Contato: lincolnsetelagoas@yahoo.com.br
  3. Last week
  4. A fraca segurança da rede Wi-Fi da WeWork, empresa americana que aluga espaços de trabalho compartilhados para startups, tem deixado dados de usuários expostos. Segundo o Dark Reading, a vulnerabilidade pode prejudicar tanto empresas que utilizam o espaço quando as que nunca entraram na WeWork, mas negociam com empresas que usam seus escritórios. Uma reportagem mais detalhada do CNET, em inglês, fala sobre as implicações que essa falha pode causar aos usuários do espaço. As descobertas são de Teemu Airamo, que avaliou a segurança do Wi-Fi da WeWork em 2015, quando considerou mudar sua empresa de mídia digital para um dos escritórios da empresa em Manhattan. Ele conseguiu visualizar centenas de registros financeiros de outras empresas e de dispositivos na rede do edifício. Ao alertar o gerente da comunidade sobre sua descoberta, a resposta foi que a WeWork já sabia que isso era poderia ocorrer. As descobertas de Airamo incluem 658 dispositivos que expõem inúmeros de dados, entre eles registros financeiros, transações comerciais, bancos de dados de clientes, e-mails de outras empresas, varreduras de carteira de motorista e passaporte, pedidos de emprego, contratos, ações judiciais, credenciais bancárias e dados de saúde. Para piorar a situação, vários locais do cenário massivo da WeWork usam exatamente a mesma senha de acesso à rede Wi-Fi. 😱 Em resposta às revelações, a WeWork disse que pôde entrar em detalhes sobre sua segurança, alegando período de silêncio determinado pelo governo em torno de seu IPO pendente. 🤷‍♀️
  5. Olá, Gostaria de saber onde eu posso digitar os comandos no Delphi, no caso, variáveis. Estou seguindo um tutorial em que antes de entrar no BEGIN / END ele digita comandos pra uma "barra de progresso" e para o dono do vídeo funciona. Veja como tem comandos ANTES do BEGIN / END; nesta imagem que peguei da video-aula: https://i.ibb.co/6sdHWgQ/image.png Eu seguindo este tutorial não "posso" digitar os comandos antes do "BEGIN/END;": https://i.ibb.co/5BQc4rJ/image.png Alguém entende porque no vídeo funciona e pra mim na minha máquina não funciona? Obrigado.
  6. Oi Ciro. Ainda não. O único problema aqui é tempo. Eu quero muito que vá, mas não sei quando vou conseguir fazer. 🤷‍♂️
  7. PS: "Fred, porque você não usou MOVSB?"... É que MOVSB não afeta os registradores. e preciso verifiacar o NUL char ao copiar uma string!
  8. Um banco de dados inseguro contendo 18 Gb de informações expôs mais de 20 milhões de registros, a maioria sobre cidadãos do Equador. De acordo com o ZDNet, a população afetada inclui 6,7 milhões de crianças. Muitos registros vazados foram duplicados, como informações de indivíduos falecidos. Os pesquisadores do vpnMentor, Noam Rotem e Ran Locar, descobriram o banco de dados desprotegido em um servidor Elasticsearch, que parece pertencer à empresa equatoriana de consultoria Novaestrat. Eles compartilharam a descoberta com o ZDNet, que auxiliou na análise dos dados vazados. As informações mais extensas parecem ter sido coletadas no registro civil do governo equatoriano, contendo nome completo de pessoas, data e local de nascimento, endereço residencial, estado civil, números de identificação nacional, informações sobre trabalho, números de telefone e níveis de escolaridade. O ZDNet verificou a autenticidade desses dados, que estavam atualizados e com informações recentes, ainda deste ano. No vazamento ainda foi encontrado um índice "família", que continha informações sobre membros da família de todos os cidadãos, como filhos e pais, permitindo que alguém reconstruísse árvores genealógicas de toda a população do país. Em uma análise mais detalhada, o banco de dados também continha índices rotulados com siglas de entidades privadas, entre elas o Banco del Instituto Ecuatoriano de Seguridad Social e a Associação de Empresas Automotivas do Equador. No total, foram encontrados 7 milhões de registros financeiros e 2,5 milhões de registros contendo detalhes de carros e proprietários de automóveis. 😱 O banco de dados foi protegido no final da semana passado. 🙌
  9. Olá a todos, existe alguma maneira de se extrair o conteúdo do livro de engenharia reversa para que eu posso lê-lo em um dispositivo kindle?
  10. Uma desvantagem de chamar código para processadores Intel de "Assembly" é que existem "Assemblies" diferentes para modos e processadores diferentes. Eis um código que faz a mesma coisa para o ARM (AArch32): @ test.S @ Compilar com: @ as -o test.o test.S @ ld -o test test.o @ Note que tanto faz usar uma instrução ou outra para zerar um registrador: @ mov r1, #0 @ eor r1, r1, r1 @ As instruções do ARM tem tamanho fixo de 32 bits! .section .rodata msg: .ascii "Hello!\n" .equ msg_len, . - msg .text .globl _start _start: mov r0, #4 @ syscall_write mov r1, #1 @ fd = STDOUT ldr r2, msgptr @ ptr mov r3, #msg_len @ size swi 0x420000 @ chama a syscall. mov r0, #1 @ syscall_exit mov r1, #0 swi 0x420000 @ chama a syscall. @ No ARM a referência a um símbolo numa outra section @ tem que ser feita de forma indireta?! msgptr: .word msg Dá pra notar que: As instruções e os registradores são completamente diferentes; As systemcalls são diferentes; As regras para acesso a recursos em sections diferentes são... ora bolas... diferentes... "Assembly" é a linguagem mnemônica de programação cujo alvo é um processador de tipo específico, operando em um modo específico. Por exemplo, se você fizer um código para Intel usando instruções como AAA, AAM, DAA, no modo IA-32 (i386), entre outras, elas não poderão ser compiladas para o mesmo processador trabalhando no modo IA-32e (x86-64). Essas instruções não existem no modo x86-64... Escrever programas inteiros diretamente em Assembly (sempre para o processador específico), geralmente, não é uma boa ideia...
  11. Bem... mas, às vezes, Assembly pode ser a solução... Eis uma rotina que é mais rápida que a rotina da glibc: /* Pela convenção de chamada SysV ABI x86-64, RDI=dptr, RSI=sptr */ char *strcpy_( char *dptr, char *sptr ) { __asm__ __volatile__ ( "movq %%rdi,%%rdx\n\t" /* salva RDI (stosb altera RDI) */ "1:\n\t" "lodsb\n\t" "stosb\n\t" "testb %%al,%%al\n\t" "jnz 1b\n\t" "movq %%rdx,%%rdi\n\t" /* Recupera RDI */ : : "D" (dptr), "S" (sptr) : "%rax", "%rdx" ); return dptr; } Comparando uma chamada a essa função contra a função strcpy() original, obtenho cerca de 80% (medido!) de ganho de performance num i5-3570 (Haswell)...
  12. PS: Quem quiser, pode baixar meu header cycle_counting.h aqui: cycle_counting.h no meu sandbox, no Gitlab.
  13. Eis um exemplo de que a ideia de que um código escrito em assembly é mais rápido do que um escrito em outra linguagem. No exemplo abaixo em preencho um array de 1000 inteiros (32 bits) com valores aleatórios. Isso coloca 4000 bytes no cache L1d. Daí, em chamo as rotinas suma(), que é o equivalente em assembly da rotina sumc(), essa última escrita em C, medindo a quantidade de ciclos gastos na soma de todos os inteiros do array. Faço o mesmo com a rotina sumc()... Eis o resultado em uma de minhas máquinas de teste (i5-3570 @ 3.4 GHz): $ ./test sum (asm) = 1032606550591 (4556 ciclos) sum (c) = 1032606550591 (3094 ciclos) Yep... nossa rotina em C é 32% mais rápida que a rotina em assembly! Eis o código: /* test.c */ /* Compilar com: $ gcc -O2 -o test test.c */ #include <stdio.h> #include <stdlib.h> #include <time.h> #include <stdint.h> #include <inttypes.h> /* Não é absolutamente necessário, já que não escreveemos nada no array durante a medição. */ #define SYNC_MEM /* Minhas duas rotinas de contagem de ciclos */ #include "cycle_counting.h" /* Uso isso só para exportar as funções, para verificar o código gerado com objdump... */ #ifndef NDEBUG #define STATIC #else #define STATIC static #endif /* Quantidade de inteiros no array de teste */ #define MAX_ITEMS 1000 __attribute__ ( ( noinline ) ) STATIC int64_t suma ( int32_t *, size_t ); __attribute__ ( ( noinline ) ) STATIC int64_t sumc ( int32_t *, size_t ); int main ( void ) { static int32_t array[MAX_ITEMS]; int32_t *ptr; int n; int64_t sum1, sum2; counter_T c1, c2; // preenche o array com valores aleatórios. srand ( time ( NULL ) ); n = MAX_ITEMS; ptr = array; while ( n-- ) *ptr++ = rand(); c1 = BEGIN_TSC(); sum1 = suma ( array, MAX_ITEMS ); END_TSC ( &c1 ); c2 = BEGIN_TSC(); sum2 = sumc ( array, MAX_ITEMS ); END_TSC ( &c2 ); printf ( "sum (asm) = %" PRIi64 " (%" PRIu64 " ciclos)\n" "sum (c) = %" PRIi64 " (%" PRIu64 " ciclos)\n", sum1, c1, sum2, c2 ); } /* Essa rotina é, essencialmente, a mesma coisa que sumc(), mas em asm. */ int64_t suma ( int32_t *ptr, size_t size ) { long sum; __asm__ __volatile__ ( "xorl %%edx,%%edx\n" /* Acumulador é zerado */ "testq %2,%2\n\t" /* Testa se o contador é zero... */ "1:\n\t" "jz 2f\n\t" /* Sai do loop se o contador é zero */ "movslq (%1),%%rax\n\t" /* Pega o inteiro do array */ "addq %%rax,%%rdx\n\t" /* Acumula */ "addq $4,%1\n\t" /* Avança o ponteiro */ "subq $1,%2\n\t" /* Decrementa o contador */ "jmp 1b\n" /* Continua acumulando... */ "2:\n\t" "movq %%rdx,%0\n\t" : /* Copia o acumulador para 'sum'. */ "=g" ( sum ) : /* GCC alocará sum em RAX, mas não confio nisso! */ "D" ( ptr ), "S" ( size ) : /* Usei RDI e RSI por causa da convenção de chamada x86-64. */ "%rdx" ); return sum; } int64_t sumc ( int32_t *ptr, size_t size ) { long sum; sum = 0; while ( size-- ) sum += *ptr++; return sum; } Geralmente o GCC e o CLANG fazem um trabalho melhor que um que possa ser feito manualmente. Porquê? Existem vários efeitos de cache, TLBs, emparelhamento de instruções, alinhamentos, fusão de instruções (micro e macro), tamanho de microcódigo, etc, etc, etc... que o GCC toma conta pra você durante a otimização. Até mesmo manipulação de dados podem ser paralelizadas (via SSE, por exemplo) [pode ser que seja feito com as opções -ftree-vectorize ou -O3 -march=native].
  14. Observe... seu código (test), depois de compilado com o as, e o meu código (test2), abaixo. Repare que o fato de não usar uma constante calculada para o tamanho da string fez com que você pedisse ao write() para imprimir 1 caracter a menos (o '\n' não irá para stdout!). Repare também que meu código tem 16 bytes a menos... $ objdump -dM intel test | sed -nE '/_start/,$p' 00000000004000b0 <_start>: 4000b0: 48 c7 c0 01 00 00 00 mov rax,0x1 4000b7: 48 c7 c7 01 00 00 00 mov rdi,0x1 4000be: 48 c7 c6 de 00 60 00 mov rsi,0x6000de 4000c5: 48 c7 c2 0f 00 00 00 mov rdx,0xf 4000cc: 0f 05 syscall 4000ce: 48 c7 c0 3c 00 00 00 mov rax,0x3c 4000d5: 48 c7 c7 00 00 00 00 mov rdi,0x0 4000dc: 0f 05 syscall $ objdump -dM intel test2 | sed -nE '/_start/,$p' 00000000004000b0 <_start>: 4000b0: b8 01 00 00 00 mov eax,0x1 4000b5: 89 c7 mov edi,eax 4000b7: 48 8d 35 10 00 20 00 lea rsi,[rip+0x200010] # 6000ce <mensagem> 4000be: ba 10 00 00 00 mov edx,0x10 4000c3: 0f 05 syscall 4000c5: b8 3c 00 00 00 mov eax,0x3c 4000ca: 31 ff xor edi,edi 4000cc: 0f 05 syscall
  15. Algumas correções e dicas: # test.S # # $ as -o test.o test.S # $ ld -s -o test test.o # Read Only data section # Usada para conter contantes que nunca serão alteradas. .section .rodata # Label 'mensagem' com a mensagem. # Note que criei o símbolo 'msg_len' que é calculado com o tamanho da mensagem. # O símbolo especial '.' é o equivalente ao $, em outros assemblers. mensagem: .ascii "Lincoln Arantes\n" .equ msg_len, . - mensagem # Code section .section .text # O símbolo _start é usado pelo linker, automaticamente. # pode-se usar outro, mas a opção -e deve ser usada na chamada do linker. .globl _start _start: ; Para criar instruções menores, inicializar registradores de 32 bits ; automaticamente zera os 32 bits superiores dos registradores extendidos. ; Por isso, coloquei 1 em %eax. ; Ainda, copiar %eax para %edi cria uma instrução ainda menor (e zerará os ; 32 bits superiores de %edi). movl $1, %eax movl %eax, %edi ; Usando o endereçamento relativo com RIP gera instruções menores... leaq mensagem(%rip),%rsi ; O símbolo msg_len é usado como constante, daí o $. movl $msg_len, %edx ; Chama a systecall write(). syscall ; Note que zerei %edi via XOR. Usando %edi para aproveitar o zero ; automático dos 32 bits superiores. movl $60, %eax xorl %edi,%edi ; Chama a syscall exit(). syscall Outra coisa... Códigos-fonte em assembly, tipicamente têm extensão .S (maiúsculo)... a extensão .s (minúsculo) geralmente é usado para listagens geradas por outras ferramentas (gcc, por exemplo). []s Fred
  16. Os crimes cibernéticos estão crescendo tanto que seguradoras americanas estão começando a enxergar uma nova oportunidade de negócios — oferecer cobertura para caso de ataques de ransomware. De acordo com o The Register, uma seguradora da Califórnia chamada Mercury Insurance já iniciou a oferta desse tipo de cobertura para clientes no início do mês. Além da cobertura do seguro, o usuário afetado também pode obter assistência profissional de especialistas em extorsão cibernética para lidar com os ataques de ransomware. A cobertura inclui uma franquia de US$ 500 por ocorrência, podendo ser adicionado o valor anual de US$ 30 para um limite de cobertura de US$ 25 mil, e US$ 41 para um limite de cobertura de US$ 50 mil. Apesar de parecer um bom negócio, já que os ataques de ransomware estão crescendo especialmente nos Estados Unidos, especialistas colocam em dúvida se esse tipo de seguro pode ajudar a aumentar os cibercrimes. Isso porque os grandes pagamentos das seguradoras podem começar a chamar a atenção dos cibercriminosos, que até então tinham como principais alvos as empresas, por ter mais chances de receber o pagamento pelo resgate das informações. Mas caso usuários domésticos comecem a contratar esses seguros, especialistas acreditam que eles podem se tornar vítimas mais frequentes das invasões com bloqueio de dados e pedido de resgate. 🤦‍♀️
  17. Muito bom estes desafios, estou começando agora em engenharia reversa, li o livro e estou terminando o curso do CERO. Curtindo muito, parabéns pela iniciativa!! 👍🤜🤛
  18. Olá, boletim #71 no ar. Acharam que não me veriam essa semana né? Sim, agora vocês vão me ver por aqui! 🤗 O que MDR, LGPD e PCI trazem de oportunidade? 🤩 Fantástico papo com Wolmer Godoi, CTO da Cipher no Brasil, sobre carreira em segurança da informação e novas oportunidades na área com MDR, gestão de riscos, compliance, LGDPR. Notícias da Semana 📰 As notícias da semana estão incríveis, as vezes nem dá para acreditar no tanto de ataque sofremos todos os dias. macOs que eram considerados seguros são alvos de ataque tendo um aumento no Brasil, Wikipedia sofre ataque... Mas também temos notícias boas. FBI prende gangues de phishing em operação coordenada com diversos países. Vem ver todas as outras notícias, fique por dentro do que está acontecendo nesse mundo! programas em Código Assembly VS Código C (veja o assembly dos 2) 😜 O @Lincoln Arantes trouxe para vocês o debug de dois programas feitos em duas linguagens diferentes. Um exemplo simples de engenharia reversa. Veja o código no compilador Assembly Online. Clique aqui.
  19. O FBI, em parceria com autoridades do mundo todo, prendeu centenas de cibercriminosos que participavam de gangues de phishing em diversos países. Também foi recuperado o valor de US$ 3,7 milhões, segundo o próprio FBI. Cerca de 281 suspeitos foram detidos na operação, que foi denominada reWired, sendo a maior parte nos Estados Unidos. Também foram identificados criminosos na Nigéria, Turquia, Gana, França, Itália, Japão, Quênia, Malásia e Reino Unido. O principal alvo dessas gangues são funcionários de organizações com acesso à área de finanças. Os criminosos enviam e-mails cuidadosamente elaborados e também usam métodos sofisticados, como engenharia social e intrusão, para enganar as vítimas e levá-las a fazer transferências bancárias para contas que supostamente pertencem a um parceiro de negócios confiável — mas na verdade são controladas pelos atacantes. O FBI também interrompeu e recuperou transferências no valor de US$ 118 milhões, provenientes desses ataques A operação segue a WireWire, do ano passado, que teve um esforço semelhante e totalizou 74 prisões e apreensão de US$ 2,4 milhões. Este ano, 39 dos 56 escritórios de campo do FBI participaram da varredura ao lado de oficiais estaduais e locais, e agências parceiras. "Através da Operação reWired, estamos enviando uma mensagem clara aos criminosos que orquestram esses esquemas: continuaremos perseguindo você, não importa onde você esteja", disse o Diretor do FBI, Christopher Wray, em comunicado. 👮‍♂️
  20. Vamos a pequena e importante dica! Em algumas distribuições Linux já vem instalado o compilador Assembly, como no caso do Fedora 29, bastando apenas o usuário desenvolver seu código e compilar.. Nesse exemplo mando para você um código simples que fiz. Espero que goste! =================================================== .section .data mensagem: .ascii "Lincoln Arantes\n" .section .text .globl _start _start: movq $1, %rax movq $1, %rdi movq $mensagem, %rsi movq $15, %rdx syscall movq $60, %rax movq $0, %rdi syscall ================================================== Desconsidere os sinais de = (igual) Copie o código e salve com o nome hello.s Depois abra o terminal do Linux na pasta onde você salvou o arquivo e compile usando cada linha e teclando [enter] no teclado. # as hello.s -o hello.o # ld -s hello.o -o hello.x Pronto! Para executar digite: ./hello.x Autor: Lincoln César dos Reis Arantes (ADS - graduado) E-mail: lincolnsetelagoas@yahoo.com.br
  21. O Sandboxie está se transformando em uma ferramenta gratuita, e tem planos de fazer uma transição para código aberto. A novidade foi anunciada pela sua desenvolvedora, a Sophos, na semana passada. O Sandboxie é um software de isolamento de programas para Windows, o que faz com que esses programas rodem num ambiente controlado e isolado, livres de malwares, por exemplo. A Sophos deve divulgar mais informações sobre o projeto de código aberto futuramente. A princípio, o Sandboxie, que até então utilizava uma chave de licença para ativar e conceder acesso aos recursos premium apenas para clientes pagos, ganhou uma versão gratuita, atualizada e que não restringe nenhum recurso. Quem já obtém a licença também deve instalar a versão mais recente para receber as atualizações, garantindo o acesso a todos os recursos. De acordo com a Sophos, o Sandboxie nunca foi um componente significativo de seus negócios, e uma das alternativas que a desenvolvedora considerou para o futuro da ferramenta seria encerrá-la. "No entanto, amamos demais a tecnologia para vê-la desaparecer. Mais importante, nós amamos demais a comunidade Sandboxie para fazer isso. A base de usuários do Sandboxie representa alguns dos membros mais apaixonados, com visão de futuro e conhecedores da comunidade de segurança, e não queremos decepcioná-los", disse a Sophos em comunicado. O Sandboxie auxilia os usuários a manter seu computador protegido. Este vídeo demonstra um usuário do Sandboxie executando um ransomware, chamado Cryptolocker, e verificando que o ransomware afetou somente os arquivos dentro do isolamento do Sandboxie, ou seja, os arquivos gerais do computador permanecem intactos, pois o ransomware não consegue "escapar" do ambiente protegido pelo Sandboxie. É louvável o esforço de transformar um software proprietário em livre, ao invés de vê-lo morrer. Nossos parabéns aos tomadores de decisão da Sophos e à toda comunidade envolvida com o Sandboxie! 🙌👏👏👏
  22. Earlier
  23. Faz um tempinho que não escrevo por lá: https://playingwith3d.wordpress.com/ E nesse aqui também: https://projectvirtualworlds.wordpress.com/
  24. Ola, a todos que gostam de pentear bytes! Fico alegre de ver que estão visualizando meus posts. Hoje trago a vocês o debug de dois programas feitos em duas linguagens diferentes, acompanhe: Um exemplo simples de engenharia reversa. Veja o código no compilador Assembly On line: Para entender melhor, foi criado um executável no Nasm exatamente na syntax Intel: Depois debugamos o arquivo hello no edb debuger. Note que o código é o mesmo, porém nos registradores que possuem textos são colocadas outras informações. como no caso do registrador edx que é observado o hexadecimal 0xe, que significa o número decimal 14. No registrador ecx é colocado um endereço de memória que está associado à mensagem mente binaria que é mostrada na tela do programa. Agora vamos criar um executável na linguagem de programação c e comparar os dois resultados do final do post. Veja o código: ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ #include <stdio.h> int main (void){ printf("mente binaria"); return 0; } ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Note que o código é bastante simples, para que fique mais fácil de entender. Abaixo, observe o programa rodando normalmente. Agora vamos debugá - lo: Agora observe que o programa nos mostrou os códigos Assembly, note que são diferentes. Podemos concluir que ambos os programas fazem a mesma coisa, porém quando são debugados trazem códigos diferentes, isso ocorre porque eles foram compilados em compiladores diferentes. Portando é possível observar também que quando o programa é feito na linguagem Assembly, o debugue nos mostra códigos mais limpos e fáceis de ser entendidos. Se você gosta de programar, aprenda a programar em Assembly e seja um grande escovador de bytes! Autor: Lincoln César dos Reis Arantes (ADS - Graduado) E-mail: lincolnsetelagoas@yahoo.com.br
  25. Eu achei esse https://github.com/eliben/pyelftools/ Eu não testei e dei apenas uma olhada rápida no código, mas eu acho que ele pode te ajudar Tem outros também se você procurar
  26. Seria interessante estudar o código fonte dos programas que exibem a String Table. Eu percebi que tem alguns programas no github que mostram a ela Se eu tiver tempo e paciência talvez eu ajude!
  27. Na semana passada, um ataque de Negação de Serviço Distribuído (Distributed Denial of Service - DDoS) deixou a Wikipedia completamente fora do ar na Europa, África e no Oriente Médio. De acordo com o blog Naked Security, da Sophos, o ataque parece ter sido o mais disruptivo dos últimos tempos, já que derrubou o site por quase três dias. Alguns usuários de outros lugares do mundo, como Estados Unidos e Ásia, também foram afetados. A empresa ThousandEyes divulgou uma análise sobre o ataque, destacando que se tratou de uma inundação volumétrica à moda antiga projetada para sobrecarregar os servidores Web da empresa com tráfego HTTP falso. Um ataque essa magnitude também é chamado de 'remoção', um evento relativamente raro que visa interromper a operação de um site conhecido pelo maior tempo possível. A Fudação Wikimedia, dona da Wikipedia, aparentemente solicitou ajuda da Cloudflare, que oferece proteção contra esse tipo de ataque. Segundo a ThousandEyes, os servidores da Wikipedia estavam sendo "liderados" inteiramente pelo Cloudflare no último final de semana. A empresa implementa a tecnologia anti-DDoS para identificar o tráfego ruim e jogá-lo fora.
  28. Uma pesquisa da Kaspersky revelou que os ataques ao macOS são mais recorrentes do que se imagina. Segundo as estatísticas da empresa de segurança, os softwares maliciosos que afetam os dispositivos da Apple estão aumentando. No primeiro semestre de 2019, cerca de 6 milhões de ataques de phishing a usuários de macOS foram identificados, sendo que 11,8% deles tinham como alvo usuários corporativos. O Brasil 🇧🇷 foi o país que mais sofreu ataques (30,87%), seguido pela Índia (22,08%) e pela França (22,02%). A Kaspersky revelou em seu relatório, em inglês, que as ameaças de phishing direcionadas aos usuários do macOS começou a crescer a partir de 2015, saindo de um total de 852.293 ataques e ultrapassando a marca de 7,3 milhões em 2018. Apenas no primeiro semestre de 2019 foram cometidos 5.932.195 ataques, o que significa que o número poderá exceder 16 milhões até o final do ano, se a tendência atual continuar. Os truques mais comuns de phishing têm sido serviços bancários e portais de Internet globais. As redes sociais ficaram em terceiro lugar em 2019. De 2012 a 2017, o número de usuários de macOS que sofreram ataques de programas maliciosos e potencialmente indesejados também aumentou, com quase 255 mil usuários atacados por ano. A partir de 2018, o número de usuários atacados começou a diminuir e, no primeiro semestre de 2019, chegou a 87 mil. A grande maioria das ameaças detectadas este ano foram da categoria AdWare. Quanto às ameaças de malware, a família Shlayer, que se disfarça de Adobe Flash Player ou uma atualização do programa, tem sido a que mais prevalece. A empresa de segurança ressaltou que a crença de que não há ameaças para macOS está se desfazendo conforme esse sistema operacional é amplamente utilizado. Em comparação com os sistemas baseados em Windows, há muito menos ameaças já que há muito mais computadores executando Windows do que macOS. No entanto, a popularidade desta última plataforma está crescendo e o cenário de ameaças para dispositivos Apple está mudando. 👩‍💻
  1. Load more activity
×
×
  • Create New...