A Inteligência Artificial refere-se à ampla disciplina da ciência da computação dedicada à criação de sistemas capazes de realizar tarefas que normalmente requerem inteligência humana. Dentro desse campo, os Modelos de Linguagem Grande são uma classe especializada de sistemas estatísticos de IA treinados em corpora de texto massivos para prever e gerar linguagem coerente. Exemplos notáveis incluem ChatGPT, Grok xAI, Claude e Gemini, que se destacam em tradução, resumo e funções conversacionais, mas operam por meio de correspondência de padrões, em vez de compreensão genuína.
Os críticos argumentam que confundir IA com LLMs ignora a diversidade da investigação em IA, que também abrange áreas como visão computacional, robótica, sistemas especializados e tomada de decisão autónoma.
Não estamos aqui para discutir a ciência da IA ou dos LLMs, mas sim para nos concentrarmos no que a IA pode ser utilizada na defesa cibernética.
Os tópicos desta seção incluem o seguinte:
- Diferentes tipos de utilização da IA: Prompting, RAG e ajuste fino
- Configurar uma API de IA
- Prompting de IA
Diferentes tipos de utilização da IA: Prompting, RAG e ajuste fino
Contexto e objetivo
O nosso objetivo é analisar publicações em fóruns de cibercrime para identificar quais discutem vendas de acesso inicial (IABs). As publicações são classificadas como:
- Publicações positivas: venda direta de acesso não autorizado a uma empresa (por exemplo, «Acesso inicial ao RBC Bank disponível»).
- Publicações neutras: ofertas gerais de ferramentas, exploits ou malware sem nomear um alvo específico.
- Postagens negativas: serviços fora do tópico ou não relacionados, como hospedagem, ferramentas de spam ou vendas genéricas de VPS.
Prompting de IA
O prompting usa APIs pré-treinadas (por exemplo, OpenAI, xAI, Anthropic) enviando prompts criados e recebendo respostas não modificadas.
Custos e sobrecarga técnica
-
As chamadas de API de terceiros variam de baixo (GPT-3.5 a ~$0,002 por 1.000 tokens) a médio (GPT-4 a ~$0,03–0,06 por 1.000 tokens).
-
A hospedagem própria incorre em custos de hardware (servidores GPU a $2–3/hora) e taxas de licença para modelos abertos.
-
Infraestrutura mínima além do armazenamento seguro para registos de prompts e chaves API.
Armazenamento de dados Apenas modelos de prompts, registos e metadados de publicações; normalmente alguns megabytes por dia.
Considerações sobre privacidade O envio de informações confidenciais sobre ameaças para APIs externas pode violar a confidencialidade. Os modelos locais melhoram a privacidade, mas aumentam os custos de infraestrutura e formação.
Facilidade de adoção O prompt é a maneira mais rápida de começar a usar CTI, sem necessidade de treinamento de modelo e com configuração mínima.
Geração aumentada por recuperação (RAG)
O RAG combina um armazenamento de documentos de dados CTI com um LLM. Ele recupera passagens relevantes (por exemplo, de relatórios de malware ou arquivos de vazamentos) para aumentar o contexto do prompt.
Componentes principais e custos
- Armazenamento de vetores (por exemplo, FAISS, Pinecone)
- Modelo de incorporação (incorporações OpenAI ou alternativas de código aberto)
- LLM
- LLMs líderes na nuvem: GPT-4, Claude 2
- Modelos auto-hospedados: Llama 2-70B, Mistral Instruct
Os custos de inferência na nuvem incluem chamadas de incorporação e chamadas de geração (semelhantes ao prompt). A auto-hospedagem requer GPUs (A100 ou equivalente), com 40-80 GB de VRAM para modelos grandes.
Custos técnicos A configuração de um pipeline de recuperação, a indexação de documentos e a manutenção de bases de dados vetoriais requerem competências técnicas.
Armazenamento de dados Armazenamento de corpus (dezenas a centenas de gigabytes) mais índices vetoriais (aproximadamente 2 a 5 vezes o tamanho do corpus).
Requisitos de computação
-
Incorporamento: alguns segundos por documento na GPU
-
Geração: depende do tamanho do modelo; modelos GPT-4 ou 70 B-parameter precisam de GPUs de última geração para inferência de baixa latência.
Ajuste fino
O ajuste fino adapta um LLM ao CTI por meio de treinamento em exemplos rotulados (por exemplo, classificações de publicações ou resumos de relatórios de ameaças).
Melhores LLMs de raciocínio e necessidades de computação
- Nuvem†: ajuste fino do GPT-3.5 e GPT-4 (requer computação mínima do lado do utilizador).
- Auto-hospedado: Mistral 7B/13B, variantes Llama 2, série Falcon.
- O ajuste fino de modelos grandes (30 B+ parâmetros) exige várias GPUs A100 e pode levar de horas a dias.
Custos e despesas técnicas
- Nuvem: taxas de ajuste baseadas em tokens (~$0,03–0,12 por 1 000 tokens) mais armazenamento para o modelo ajustado.
- No local: aluguer de clusters de GPU ($3–10/hora por GPU), pipelines de pré-processamento de dados, manutenção da infraestrutura de formação.
Armazenamento de dados Conjuntos de dados de treino (até vários gigabytes) mais pontos de verificação do modelo final (10–200 GB, dependendo do tamanho).
Para começar com o ajuste fino, aqui está um exemplo de conjunto de dados que pode usar:
https://github.com/0xHamy/minimal_scraper/tree/main/datasets
Para gerar mais dados semelhantes, pode usar APIs de parágrafos.
Resumo comparativo
| Aspecto | Prompting | RAG | Afinação | |----------------------|-------------------------------|---------------------------------------------|--------------------------------------| | Privacidade | Baixa (API pública) ou alta (local) | Média (corpus local, LLM público) | Alta (modelo local) | | Tempo de configuração | Minutos | Horas a dias | Dias a semanas | | Infraestrutura | Mínima | Moderada (banco de dados vetorial, servidor de recuperação) | Extensa (frota de GPUs, pilha de treinamento) | | Perfil de custo | Baixo a médio | Médio a alto | Alto | | Armazenamento de dados | Registos e metadados | Documentos + índices | Dados de treino + pontos de verificação do modelo | | Raciocínio do modelo | Limitado ao design do prompt | Aprimorado pela recuperação de contexto | Melhor alinhamento de domínio | | Curva de aprendizagem | Mais fácil | Intermediária | Íngreme |
Configurar uma API de IA
Como mencionado anteriormente, o prompt é a maneira mais simples de começar. Mas como selecionar os modelos certos para as nossas tarefas?
Os fornecedores de IA listados abaixo oferecem uma variedade de modelos além dos mencionados. Recomendo que explore as ofertas e compreenda as capacidades. Observe que as assinaturas de IA (por exemplo, para ChatGPT ou Claude) diferem das APIs de IA, que exigem a compra de créditos de API. Normalmente, elas custam a partir de US$ 5 e têm duração considerável.
Anthropic
O Claude 3.5 Sonnet da Anthropic é um modelo que utilizo com frequência. Ele se destaca no raciocínio e possui proteções robustas, tornando-o ideal para identificar publicações relacionadas a vendas de acesso inicial, discurso de ódio ou cyberbullying. Além disso, ele tem um bom desempenho em reconhecimento óptico de caracteres (OCR), especialmente para resolver CAPTCHAs, extraindo texto de imagens de forma eficaz.
Comece agora:
xAI
O Grok 3 da xAI é excepcional para escrever e analisar grandes bases de código, lidando com até 2.000 linhas de código. Embora seja adequado para análise de malware, é menos eficaz em tarefas de raciocínio, como debates, onde tem dificuldade em gerar argumentos únicos. O Claude 3.5 Sonnet supera o Grok 3 em raciocínio geral e debates, mas o Grok 3 lidera em tarefas de codificação.
Comece agora:
OpenAI
A OpenAI fornece vários modelos, com o o1 se destacando para depuração de código e resolução de erros. Este modelo tem sido inestimável para solucionar problemas em grandes bases de código. À medida que desenvolve plataformas CTI extensas, irá encontrar inúmeros erros, e o o1 é uma ferramenta fiável para encontrar soluções.
Comece agora:
Prompting de IA
Os fornecedores de API de IA mencionados anteriormente oferecem documentação abrangente detalhando como interagir com as suas APIs usando linguagens de programação como Python ou JavaScript. Nesta seção, vou me aprofundar e explicar como aproveitar a IA da Anthropic para casos de uso específicos, como distinguir publicações que discutem vendas de acesso inicial daquelas que não o fazem.
Identificar uma venda de acesso inicial com Claude
Para identificar vendas de acesso inicial com Claude, podemos solicitar a inferência da IA. Para começar, configure um ambiente virtual Python:
mkdir ai_prompting && cd ai_prompting
python3 -m venv venv
source venv/bin/activate
pip install anthropic
touch iab_identifier.py
Abra iab_identifier.py e cole o seguinte código:
from anthropic import Anthropic
import json
def claude_classify(
api_key: str,
model_name: str,
post_content: str,
max_tokens: int = 100,
temperature: float = 0.1
) -> dict:
"""
Classify a post using Claude (e.g., Sonnet) to determine if it discusses selling initial access,
unrelated items, or warnings/complaints.
Args:
api_key (str): Anthropic API key.
model_name (str): Claude model name (e.g., 'claude-3-5-sonnet-20241022').
post_content (str): Post text to classify.
max_tokens (int, optional): Max output tokens. Defaults to 100.
temperature (float, optional): Sampling temperature. Defaults to 0.1.
Returns:
dict: JSON with classification, scores, and error (if any).
"""
client = Anthropic(api_key=api_key)
prompt_template = """
Does this post discuss selling initial access to a company (e.g., RDP, VPN, admin access), selling unrelated items (e.g., accounts, tools), or warnings/complaints? Classify it as:
- Positive Posts: direct sale of unauthorized access to a company, this usually include the target's name.
- Neutral Posts: general offers for tools, exploits or malware without naming a specific target.
- Negative Posts: off-topic or unrelated services such as hosting, spam tools or generic VPS sales.
The content must be specifically about selling access to a company or business whose name is mentioned in the post.
Return **only** a JSON object with:
- `classification`: "Positive", "Neutral", or "Negative".
- `scores`: Probabilities for `positive`, `neutral`, `negative` (summing to 1).
Wrap the JSON in ```json
{
...
}
``` to ensure proper formatting. Do not include any reasoning or extra text.
Post:
```markdown
{{POST}}
```
"""
prompt = prompt_template.replace("{{POST}}", post_content)
try:
message = client.messages.create(
model=model_name,
max_tokens=max_tokens,
temperature=temperature,
messages=[
{"role": "user", "content": prompt}
]
)
content = message.content[0].text
# Extract JSON between ```json and ```
start = content.index("```json\n") + 7
end = content.index("\n```", start)
result = json.loads(content[start:end])
return result
except Exception as e:
return {"error": f"Failed to classify post: {str(e)}", "classification": None, "scores": None}
# Example usage
if __name__ == "__main__":
API_KEY = ""
MODEL_NAME = "claude-3-7-sonnet-20250219"
sample_post = """Selling access to Horizon Logistics\nRevenue: $1.2B\nAccess: RDP with DA\nPrice: 0.8 BTC\nDM for details"""
result = claude_classify(
api_key=API_KEY,
model_name=MODEL_NAME,
post_content=sample_post,
max_tokens=100,
temperature=0.1
)
print("API response:")
print(json.dumps(result, indent=4))
Isso é chamado de string de documentação da função:
"""
Classify a post using Claude (e.g., Sonnet) to determine if it discusses selling initial access,
unrelated items, or warnings/complaints.
Args:
api_key (str): Anthropic API key.
model_name (str): Claude model name (e.g., 'claude-3-5-sonnet-20241022').
post_content (str): Post text to classify.
max_tokens (int, optional): Max output tokens. Defaults to 100.
temperature (float, optional): Sampling temperature. Defaults to 0.1.
Returns:
dict: JSON with classification, scores, and error (if any).
"""
Docstrings são usados para documentar como o código funciona.
Este código também pode ser usado como um módulo. Por exemplo, pode importar claude_classify de iab_identifier.py, passar os argumentos necessários e utilizá-lo.
Aqui, definimos uma instrução condicional, if __name__ == “__main__”:, para verificar se o programa está a ser executado como um script. Se for o caso, o código dentro do bloco condicional é executado.
Para usar isso, defina a sua chave API na variável API_KEY e especifique o nome do modelo na variável MODEL_NAME. Para sample_post, pode fornecer uma única publicação ou uma lista de publicações e iterar sobre elas.
Abaixo está um exemplo usando três publicações, como positive, neutral e negative, provenientes do seguinte conjunto de dados:
https://github.com/0xHamy/minimal_scraper/blob/main/datasets/base.csv
# Example usage
if __name__ == "__main__":
API_KEY = "sk-ant-apixxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
MODEL_NAME = "claude-3-5-sonnet-20241022"
sample_posts = ["Selling access to Capital Freight Co. (Texas-based logistics) \nRevenue: ~$900M \nAccess: Full RDP, domain admin via svc_x backup creds \nExtras: Internal invoices, mapped drives, Outlook web creds \nEDR: minimal – Defender only \nPrice: 0.6 BTC firm, BTC only, DM me quick",
"Private obfuscator for Python tools \nRandom junk + encryption \nFUD for most stealers \n0.012 BTC",
"Selling 150k+ Netflix logins from Latin America \nMost accounts active, pulled from private stealer logs \nNo warranty – buy at your own risk \n0.02 BTC per 1k – discounts on bulk \nDM for sample"
]
for idx, post in enumerate(sample_posts, start=1):
result = claude_classify(
api_key=API_KEY,
model_name=MODEL_NAME,
post_content=post,
max_tokens=100,
temperature=0.1
)
print(f"API response for post number {idx}:\n")
print(json.dumps(result, indent=4))
print(60 * '*')
Here is the output:
-> % python3 iab_identifier.py
API response for post number 1:
{
"classification": "Positive",
"scores": {
"positive": 0.95,
"neutral": 0.04,
"negative": 0.01
}
}
************************************************************
API response for post number 2:
{
"classification": "Neutral",
"scores": {
"positive": 0.05,
"neutral": 0.85,
"negative": 0.1
}
}
************************************************************
API response for post number 3:
{
"classification": "Negative",
"scores": {
"positive": 0.05,
"neutral": 0.15,
"negative": 0.8
}
}
************************************************************
Esta abordagem é altamente eficaz e executa a tarefa rapidamente. Embora as APIs possam ocasionalmente classificar erroneamente publicações «neutras» e «negativas», elas identificam consistentemente as publicações «positivas» com precisão, o que é fundamental. As atividades gerais de cibercrime geralmente se enquadram nas categorias «negativas» ou «neutras», mas as vendas de acesso inicial sempre podem ser distinguidas de forma confiável.