0dai-ml/zerodapiDocumentação Oficial da 0dAPI
Comece!
pip install zerodai==0.0.0.20
export zerodapi_key="TU_API_KEY"
Obtenha sua api key https://zerodai.com Chat Conversacional Simples - Sem memória
from zerodai import zerodai
import os
zerodai.api_auth(os.getenv("zerodapi_key"))
messages = []
while True:
prompt = input("> ")
if prompt == "exit":
break
messages.append({"role": "user", "content": prompt})
messages.append({"role": "system", "content": "Eres 0dAI um assistente de cibersegurança cuja única função é..."})
zerodai.inference(model="0dai70b", messages=messages, temperature=0.7, stream=True)
Zerodai é uma biblioteca de processamento de linguagem natural orientada à cibersegurança que busca automatizar parcialmente processos baseados no processamento humano de informações, raciocínio, planejamento e execução. Buscamos criar um framework de agentes para cibersegurança com as seguintes capacidades:
É o método base de interação com o modelo e conta com os seguintes parâmetros. É importante que estes parâmetros sejam aprendidos e compreendidos bem, pois são a base da biblioteca.
model: O modelo de linguagem a ser utilizado. Os modelos disponíveis são:
0dai7b: Modelo básico com uso ilimitado, rápido e perfeito para conversas simples e assistência em programação. Defende bem em cibersegurança.
0dai8x7b: Modelo flexível com uma janela de contexto grande, nível GPT-4 em termos de código, bom para perguntas e scripts complexos de cibersegurança.
0daifn: Modelo recomendado para function calls, o melhor em function calls, muito contexto, mais leve que 0dai70b, além disso, em nível de function calls multipasso está ao nível do melhor gpt
0dai70b (Recomendado): Atualmente SOTA em cibersegurança, capaz de fazer complexos raciocínios lógicos com base em muito contexto e resolver testes de pentesting de forma semiautônoma. Conta com function calls e pode responder em mensagens estruturadas. É o mais lento, mas oferece um grande salto de qualidade.
messages: As mensagens que serão enviadas ao modelo. Aqui temos que entender 3 papéis:
As mensagens devem seguir este formato:
messages = [
{"role": "system", "content": """Você é 0dAI, sua função é..."""},
{"role": "user", "content": "0dAI escreva um exploit em C"},
]
functions: As funções que podem ser chamadas durante a interação. Iremos detalhar mais sobre as funções em fn_c. Neste caso, simplesmente nos dará o JSON.
Uma função é declarada assim:
function_shodan = [ {
"name": "shodan_dork",
"description": "This tools is used to generate a shodan query",
"parameter_definitions": {
"dork": {
"type": "string",
"description": "The shodan dork",
"required": True
}
}
}, ]
temperature: Controla a aleatoriedade das respostas do modelo. Quanto maior a temperatura, mais aleatoriedade; quanto menor a temperatura, menos aleatoriedade.
stream (bool): Se deve transmitir a resposta em tempo real.
from zerodai import zerodai
messages = []
messages.append({"role": "user", "content": prompt})
messages.append({"role": "system", "content": "Você é 0dAI, um assistente de cibersegurança cuja única função é..."})
zerodai.inference(model="0dai70b", messages=messages, temperature=0.7, stream=True)
Com base em uma função ou uma lista de funções no parâmetro function, o Modelo será capaz de gerar uma resposta estruturada que nos possa servir após uma inferência: Função base
function_shodan = [ {
"name": "shodan_dork",
"description": "This tools is used to generate a shodan query",
"parameter_definitions": {
"dork": {
"type": "string",
"description": "The shodan dork",
"required": True
}
}
}, ]
Resposta do modelo com base nesta função
[
{
"tool_name": "shodan_dork",
"parameters": {
"dork": "hacked-router-help-sos"
}
}
]
Estas funções podem ser multipasso ou não, isso será definido pelo número de posições do JSON. Uma resposta multipasso se parece com isso
[
{
"tool_name": "shodan_dork",
"parameters": {
"dork": "hacked-router-help-sos"
}
},
{
"tool_name": "shodan_dork",
"parameters": {
"dork": "\"smb\" \"authentication: disabled\""
}
},
{
"tool_name": "shodan_dork",
"parameters": {
"dork": ".docuword_exploited.txt"
}
}
]
Também pode existir uma lógica recursiva em inferência - função que se retroalimentam. Imaginemos este caso:
Função subdomínios
funcion_subdomains = [ {
"name": "subdominios",
"description": "This tools is used to collect domains to extract subdomains",
"parameter_definitions": {
"domain": {
"type": "string",
"description": "The domain",
"required": True
}
}
}, ]
Função crawler
crawler_endpoints = [ {
"name": "crawler",
"description": "This tools is used to crawle ndpoints for a host",
"parameter_definitions": {
"host": {
"type": "string",
"description": "The domain",
"required": True
}
}
}, ]
Input:
Preciso obter os subdomínios de openai.com e omegaai.io
Output 1. Função:
[
{
"tool_name": "subdomains",
"parameters": {
"domain": "openai.com"
}
},
{
"tool_name": "subdomains",
"parameters": {
"domain": "omegaai.io"
}
},
]
Após extrair os subdomínios do input, aplicamos nossa lógica de execução, que seria obter os subdomínios...
subdomain1.openai.com
subdomain2.openai.com
subdomain3.openai.com
subdomain1.omegaai.io
subdomain2.omegaai.io
subdomain3.omegaai.io
Após passar isso para a função do crawler, seria algo como:
Output 2. Função:
[
{
"tool_name": "crawler",
"parameters": {
"domain": "subdominio1.openai.com"
}
},
{
"tool_name": "crawler",
"parameters": {
"domain": "subdominio1.omegaai.io"
}
},
{
"tool_name": "crawler",
"parameters": {
"domain": "subdominio2.openai.com"
}
},
{
"tool_name": "crawler",
"parameters": {
"domain": "subdominio2.omegaai.io"
}
},
{
"tool_name": "crawler",
"parameters": {
"domain": "subdominio3.openai.com"
}
},
{
"tool_name": "crawler",
"parameters": {
"domain": "subdominio3.omegaai.io"
}
},
]
fn_c O que nos permite é coletar os parâmetros e o nome da tool diretamente sem ter que passar por essa lógica de filtrar o JSON em si.
from zerodai import zerodai
zerodai.api_auth("SUA_API_KEY")
tool_name, parameters = zerodai.fn_c(model_fn=model_fn_call, messages=messages, functions=subdomain_functions, stream=stream, multistep=False)
print(tool_name)
print(parameters)
print(parameters["domain"])
Nota: O padrão de funções geralmente é o OpenAI, para isso projetamos uma função que converte as funções do OpenAI para nosso formato próprio. Exemplo:
tool_name, parameters = cls.fn_c(model_fn=model_fn_call, messages=messages, functions=OpenAI2CommandR(osint_funcs), stream=stream, multistep=False)
Zerodai inclui um sistema de agentes que pode ser estendido mediante funções e um módulo de execução
def exec_module(tool, arguments, multitool=True):
output = ""
if tool == "Shodan":
process = subprocess.Popen(["nmap", "-Pn", next(iter(arguments.values()))], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
for line in iter(process.stdout.readline, b''):
output += line.decode('utf-8').strip()
print(line.decode('utf-8').strip())
elif tool == "XSS-Scanner" or tool == "nuclei-http":
try:
process = subprocess.Popen(["nuclei", "-t", "dns", next(iter(arguments.values()))], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, cwd="/home/omegaleitatadmin/exllamav2/0dAPI/nuclei-templates/nuclei-templates-9.8.6/")
for line in iter(process.stdout.readline, b''):
output += line.decode('utf-8').strip()
print(line.decode('utf-8').strip())
except:
pass
elif tool == "WAF-tool":
process = subprocess.Popen(["python3", "whatwaf", "-u", "https://" + next(iter(arguments.values()))], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, cwd="/home/omegaleitatadmin/exllamav2/0dAPI/WhatWaf")
for line in iter(process.stdout.readline, b''):
output += line.decode('utf-8').strip()
print(line.decode('utf-8').strip())
elif tool == "Attack":
process = subprocess.Popen(["nmap", "-Pn", next(iter(arguments.values()))], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
for line in iter(process.stdout.readline, b''):
output += line.decode('utf-8').strip()
print(line.decode('utf-8').strip())
elif tool == "OSINT":
ZeroDAI.Osint(next(iter(arguments.values())))
return output
Este código deve acompanhar as funções usadas
python_functions = [ {
"name": "Shodan",
"description": "tool for shodan",
"parameter_definitions": {
"ip": {
"type": "string",
"description": "The ip",
"required": True
}
}
},
{
"name": "nuclei-http",
"description": "This tools is use for nuclei",
"parameter_definitions": {
"target": {
"type": "string",
"description": "The domain",
"required": True
}
}
},
{
"name": "WAF-tool",
"description": "This tools is used for waf",
"parameter_definitions": {
"webapp": {
"type": "string",
"description": "The webapp",
"required": True
}
}
},
{
"name": "Attack",
"description": "This tools is used to attack a host",
"parameter_definitions": {
"host": {
"type": "string",
"description": "The domain",
"required": True
}
}
}, ]
Isso permite criar agentes dinâmicos multipasso e multi-ferramenta
zerodai.agent(model="0dai70b",
messages=messages,
model_fn_call="0daifn",
temperature=0.7,
functions=python_functions,
exec_module=exec_module,
exec_module_bool=True,
multistep=True)
exec_module-bool para indicar se queremos usar um módulo de execução (Se colocarmos True e não um módulo de execução, executará um por padrão)
exec_module módulo de execução
functions Funções de acordo com o módulo de execução
multistep Se queremos que vários passos sejam executados em cada iteração do modelo de function calls
Esta API vem com integrações de shodan, vários serviços de dados, censys e muito mais. Estes serviços requerem apenas a API da 0dAI:
zerodai.Osint(prompt)
prompt - Mensagem simples em linguagem natural para que o LLM realize uma busca em fontes de vazamentos de dados privadas nossas e forneça os vazamentos de um usuário
zerodai.Osint(prompt)
prompt - Mensagem simples em linguagem natural para que o LLM realize uma busca no shodan e forneça os resultados diretamente
zerodai.rubberducky_gen(prompt)
prompt - Mensagem simples em linguagem natural para que o LLM crie um payload válido de rubber ducky
Esta API foi desenvolvida em sua totalidade por Luijait (Luis Javier Navarrete Lozano) sob 0dAI. Se os conhecimentos descritos aqui forem usados em outro paper, é necessário dar créditos ao autor, como primeiro nome Luijait e como segundo 0dAI