Em construção...
## Sequências
### Simples e complexas
Algumas sequências podem ser simples como uma variável, como posso ter uma sequência completa.
```Markdown
# Lista simples
valor="Lista Simples"
# Lista Complexa
valor_complexo=['L',41,30]
```
### Mutáveis e Imutáveis
Listas de Objetos que não se modificam ao decorrer do tempo de execução ou o contrário.
```Markdown
# Sequencias Mutáveis
Lista (list), Dicionário (dict)
# Exemplo
lista_letras = ['A','B','C']
```
```Markdown
# Sequencias Imutáveis
String (str), Tupla (tuple) e Fronzenset
# Exemplo
>>> nome = "ooclaar"
>>> print(nome)
>>> Leonardo
>>> id(nome)
>>> 3420943209432
>>> nome = "NewOoclaar"
>>> print(nome)
>>> NewOoclaar
>>> id(nome)
>>> 342094344434
```
## Tipos de Dados
### Lista
Em Python, uma lista é uma estrutura de dados que permite armazenar uma coleção ordenada e mutável de itens. As listas são definidas usando colchetes [] e os elementos são separados por vírgulas.
Características principais das listas em Python:
1. Mutável: você pode adicionar, remover ou modificar elementos após a criação
2. Ordenada: os elementos mantêm a ordem em que foram inseridos
3. Indexada: você pode acessar elementos pelo índice (começando do 0)
4. Permite elementos duplicados
5. Permite diferentes tipos de dados em uma mesma lista
Exemplo básico de lista:
```Markdown
minha_lista = [1, 2, 3, 4, 5]
lista_mista = ["texto", 10, True, 3.14]
```
Operações com listas:
```Markdown
# Acessar elemento por índice
primeiro_elemento = minha_lista[0] # Retorna 1
# Adicionar elemento ao final
minha_lista.append(6) # [1, 2, 3, 4, 5, 6]
# Inserir elemento em posição específica
minha_lista.insert(2, 10) # [1, 2, 10, 3, 4, 5, 6]
# Remover elemento
minha_lista.remove(10) # [1, 2, 3, 4, 5, 6]
# Comprimento da lista
tamanho = len(minha_lista) # 6
```
### Tuplas
[[Tuplas]] em Python são sequências imutáveis e ordenadas de elementos. Características principais:
- São criadas com parênteses: `(1, 2, 3)` ou sem parênteses: `1, 2, 3`
- Imutáveis: não podem ser alteradas após criação
- Permitem elementos de tipos diferentes: `(1, "texto", True)`
- Suportam indexação: `tupla[0]`
- Mais eficientes em memória que listas
- Úteis para dados que não devem mudar
```Markdown
coordenadas = (10, 20)
nome_completo = ("João", "Silva")
mista = (1, "abc", True, [1, 2, 3])
```
### Conjuntos (Sets)
Conjuntos (sets) em Python são coleções não ordenadas de elementos únicos. Características principais:
- Criados com chaves: `{1, 2, 3}` ou função `set()`
- Não permitem elementos duplicados
- Não são indexáveis
- Mutáveis (modificáveis)
- Armazenam apenas objetos imutáveis (não aceitam listas ou dicionários)
- Eficientes para verificar pertencimento (operação `in`)
Suportam operações matemáticas de conjuntos:
```Markdown
a = {1, 2, 3}
b = {3, 4, 5}
união = a | b # {1, 2, 3, 4, 5}
interseção = a & b # {3}
diferença = a - b # {1, 2}
```
Úteis para eliminar duplicatas e realizar operações de conjunto.
# Comparação: Listas, Tuplas e Conjuntos em Python
| Característica | Listas | Tuplas | Conjuntos |
| ---------------------------- | -------------------------------------------- | --------------------------------------------- | --------------------------------------------------------- |
| Sintaxe | `[1, 2, 3]` | `(1, 2, 3)` | `{1, 2, 3}` |
| Mutabilidade | Mutável | Imutável | Mutável |
| Ordenação | Ordenada | Ordenada | Não ordenada |
| Elementos duplicados | Permitidos | Permitidos | Não permitidos |
| Indexação | `lista[0]` | `tupla[0]` | Não suporta |
| Tipos de elementos | Qualquer tipo | Qualquer tipo | Apenas imutáveis |
| Uso de memória | Maior | Menor | Médio |
| Velocidade | Média | Rápida | Rápida para operações de conjunto |
| Casos de uso | Sequências que precisam ser modificadas | Dados que não devem mudar; retorno de funções | Remoção de duplicatas; operações matemáticas de conjuntos |
| Método de criação | `[]` ou `list()` | `()` ou sem parênteses | `{}` ou `set()` |
| Métodos principais | `append()`, `insert()`, `remove()`, `sort()` | `count()`, `index()` | `add()`, `remove()`, `union()`, `intersection()` |
| Pode ser chave em dicionário | Não | Sim | Não |
| Exemplo de uso | `números = [1, 2, 3]` | `coordenadas = (10, 20)` | `cores_únicas = {"vermelho", "azul"}` |
| Operações especiais | Fatiamento, concatenação | Fatiamento, concatenação | União (` |
### Comandos Hackers
```
# Gerar 15 A consecutivos.
>>> 'A' * 15
# Saber quanto é 0x41 (hexa) em decimal.
>>> 0x41
# Saber quanto é 65 (Decimal) em hexa.
>>> hex(65)
# Saber quanto é 0x41 (hexa) em ASCI.
>>> print("\x41")
# Saber quanto é A (ASCI) em Decimal.
>>> ord('A')
```
### Scripts Uteis.
Gerar uma lista de caracteres de 1..253 em hexa.
```python
#!/usr/bin/python3
for num in range(0, 253):
print(hex(num).replace('0x','\\x'), end="")
```
```
\x0\x1\x2\x3\x4\x5\x6\x7\x8\x9\xa\xb\xc\xd\xe\xf\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f\x20\x21\x22\x23\x24\x25\x26\x27\x28\x29\x2a\x2b\x2c\x2d\x2e\x2f\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\x3a\x3b\x3c\x3d\x3e\x3f\x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x4a\x4b\x4c\x4d\x4e\x4f\x50\x51\x52\x53\x54\x55\x56\x57\x58\x59\x5a\x5b\x5c\x5d\x5e\x5f\x60\x61\x62\x63\x64\x65\x66\x67\x68\x69\x6a\x6b\x6c\x6d\x6e\x6f\x70\x71\x72\x73\x74\x75\x76\x77\x78\x79\x7a\x7b\x7c\x7d\x7e\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc
```
Como gerar um bytecode (script compilado):
```shell
python3 -c "import py_compile; py_compile.compile('maps_api_scanner.py')"
```
```shell
ls -lsa __pycache__
total 40
0 drwxr-xr-x@ 3 ooclaar staff 96 3 Mar 19:43 .
0 drwxr-xr-x 13 ooclaar staff 416 3 Mar 19:43 ..
40 -rwxr-xr-x@ 1 ooclaar staff 18626 3 Mar 19:43 maps_api_scanner.cpython-312.pyc
```
Como extrair áudio de um vídeo:
```python
$ pip3 install moviepy
file=moviepy.VideoFileClip("exemplo.mp4")
audio=file.audio
audio.write_audiofile("exemplo.mp3")
audio.close()
file.close()
```
Como editar o áudio usando CLI:
```python
$ apt install ffmpeg
import pydub
audio = pydub.AudioSegment.from_file("Extreme_Train.mp3")
leftaudio = audio.split_to_mono()[0]
leftaudio.export("Extreme_Train_left.mp3", format="mp3")
file.audio.close()
audio.close()
```
Como disassemblar um binário com Python mostrando a sua stack:
```python
#!/usr/bin/env python3
"""
Script para descompilar shellcode x86/x64 usando Capstone.
"""
from capstone import *
import sys
def disassemble_shellcode(shellcode_path, arch=CS_ARCH_X86, mode=CS_MODE_32):
"""
Descompila shellcode usando Capstone.
Args:
shellcode_path: Caminho para o arquivo binário do shellcode
arch: Arquitetura (padrão: x86)
mode: Modo (padrão: 32-bit)
"""
# Ler shellcode
with open(shellcode_path, 'rb') as f:
code = f.read()
print(f"{'='*80}")
print(f"ANÁLISE DE SHELLCODE - {len(code)} bytes")
print(f"{'='*80}\n")
# Tentar descompilar em 32-bit
print(f"[*] Descompilando como x86 32-bit:\n")
print(f"{'Offset':<10} {'Bytes':<30} {'Instrução':<40}")
print(f"{'-'*80}")
md = Cs(CS_ARCH_X86, CS_MODE_32)
md.detail = True
instructions = []
for i in md.disasm(code, 0x0):
bytes_hex = ' '.join([f'{b:02x}' for b in i.bytes])
line = f"0x{i.address:08x} {bytes_hex:<28} {i.mnemonic} {i.op_str}"
print(line)
instructions.append({
'address': i.address,
'mnemonic': i.mnemonic,
'op_str': i.op_str,
'bytes': i.bytes
})
print(f"\n{'='*80}")
print(f"[*] Total de instruções: {len(instructions)}")
print(f"{'='*80}\n")
# Análise de comportamento
print("[*] ANÁLISE DE COMPORTAMENTO:\n")
# Verificar padrões comuns
has_push_sequence = False
push_count = 0
call_instructions = []
for inst in instructions:
if inst['mnemonic'] == 'push':
push_count += 1
if push_count > 5:
has_push_sequence = True
elif inst['mnemonic'] == 'call':
call_instructions.append(inst)
if has_push_sequence:
print(" [+] Detectado: Sequência de PUSH (possível construção de string na stack)")
if call_instructions:
print(f" [+] Detectado: {len(call_instructions)} instrução(ões) CALL")
# Verificar se há valores ASCII nos pushes
print("\n[*] ANÁLISE DE STRINGS NA STACK:\n")
ascii_values = []
for inst in instructions:
if inst['mnemonic'] == 'push' and len(inst['bytes']) >= 5:
# Extrair valor de 4 bytes do push
value_bytes = inst['bytes'][1:5]
# Tentar decodificar como ASCII
try:
decoded = value_bytes.decode('ascii', errors='ignore')
if all(32 <= ord(c) <= 126 or c == '\x00' for c in decoded):
ascii_values.append(decoded[::-1]) # Reverter por causa da ordem little-endian
print(f" 0x{inst['address']:08x}: push 0x{value_bytes.hex()} -> '{decoded[::-1]}'")
except:
pass
if ascii_values:
reconstructed = ''.join(ascii_values).replace('\x00', '')
print(f"\n [+] String reconstruída: '{reconstructed}'")
# Salvar resultado em arquivo
with open('/home/ubuntu/shellcode_disassembly.txt', 'w') as f:
f.write(f"{'='*80}\n")
f.write(f"ANÁLISE DE SHELLCODE - {len(code)} bytes\n")
f.write(f"{'='*80}\n\n")
f.write(f"{'Offset':<10} {'Bytes':<30} {'Instrução':<40}\n")
f.write(f"{'-'*80}\n")
md = Cs(CS_ARCH_X86, CS_MODE_32)
for i in md.disasm(code, 0x0):
bytes_hex = ' '.join([f'{b:02x}' for b in i.bytes])
line = f"0x{i.address:08x} {bytes_hex:<28} {i.mnemonic} {i.op_str}\n"
f.write(line)
if ascii_values:
f.write(f"\n\nString reconstruída: '{reconstructed}'\n")
print(f"\n[*] Descompilação salva em: /home/ubuntu/shellcode_disassembly.txt")
if __name__ == '__main__':
disassemble_shellcode('/home/ubuntu/shellcode.bin')
```