0dai-ml/zerodapi0dAPI Offizielle Dokumentation
Los geht's!
pip install zerodai==0.0.0.20
export zerodapi_key="TU_API_KEY"
Erhalten Sie Ihren API-Schlüssel unter https://zerodai.com Einfache konversationelle Chat – ohne Gedächtnis
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 un asistente de ciberseguridad cuya unica función es..."})
zerodai.inference(model="0dai70b", messages=messages, temperature=0.7, stream=True)
Zerodai ist eine auf Cybersicherheit ausgerichtete Bibliothek zur Verarbeitung natürlicher Sprache, die darauf abzielt, Prozesse, die auf menschlicher Informationsverarbeitung, Argumentation, Planung und Ausführung basieren, teilweise zu automatisieren. Wir wollen ein Agenten-Framework für Cybersicherheit mit den folgenden Fähigkeiten schaffen:
Dies ist die grundlegende Methode zur Interaktion mit dem Modell und verfügt über die folgenden Parameter. Es ist wichtig, dass diese Parameter gelernt und gut verstanden werden, da sie das Fundament der Bibliothek bilden.
model: Das zu verwendende Sprachmodell. Die verfügbaren Modelle sind:
0dai7b: Basismodell mit unbegrenzter Nutzung, schnell und perfekt für einfache Gespräche und Programmierhilfe. Verteidigt gut in der Cybersicherheit.
0dai8x7b: Flexibles Modell mit einem großen Kontextfenster, GPT-4-Niveau im Code, gut für komplexe Fragen und Skripte in der Cybersicherheit.
0daifn: Empfohlenes Modell für Funktionsaufrufe, das beste für Funktionsaufrufe mit viel Kontext, leichter als 0dai70b, und auf dem Niveau des besten GPT bei mehrstufigen Funktionsaufrufen.
0dai70b (Empfohlen): Derzeit SOTA in der Cybersicherheit, fähig zu komplexen logischen Schlussfolgerungen auf Basis großer Kontextmengen und zur semiautonomen Lösung von Pentest-Aufgaben. Verfügt über Funktionsaufrufe und kann in strukturierten Nachrichten antworten. Es ist das langsamste, bietet aber einen großen Qualitätssprung.
messages: Die Nachrichten, die an das Modell gesendet werden. Hier müssen wir 3 Rollen verstehen:
Die Nachrichten müssen in diesem Format sein:
messages = [
{"role": "system", "content": """Eres 0dAI tu función es..."""},
{"role": "user", "content": "0dAI escribe un exploit en C"},
]
functions: Die Funktionen, die während der Interaktion aufgerufen werden können. Wir werden im Abschnitt fn_c näher auf die Funktionen eingehen. In diesem Fall liefert es uns einfach das JSON.
Eine Funktion wird wie folgt deklariert:
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: Steuert die Zufälligkeit der Modellantworten. Höhere Temperatur bedeutet mehr Zufälligkeit, niedrigere Temperatur weniger.
stream (bool): Ob die Antwort in Echtzeit übertragen werden soll.
from zerodai import zerodai
messages = []
messages.append({"role": "user", "content": prompt})
messages.append({"role": "system", "content": "Eres 0dAI un asistente de ciberseguridad cuya unica función es..."})
zerodai.inference(model="0dai70b", messages=messages, temperature=0.7, stream=True)
Basierend auf einer Funktion oder einer Liste von Funktionen im Parameter function ist das Modell in der Lage, eine strukturierte Antwort zu generieren, die uns nach einer Inferenz eine strukturierte Antwort liefern kann: Basis-Funktion
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
}
}
}, ]
Modellantwort basierend auf dieser Funktion
[
{
"tool_name": "shodan_dork",
"parameters": {
"dork": "hacked-router-help-sos"
}
}
]
Diese Funktionen können mehrstufig oder nicht sein – das wird durch die Anzahl der Positionen im JSON definiert. Eine mehrstufige Antwort sieht so aus:
[
{
"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"
}
}
]
Es kann auch eine rekursive Logik existieren, bei der Inferenz und Funktion sich gegenseitig speisen – stellen wir uns diesen Fall vor:
Funktion Subdomains
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
}
}
}, ]
Funktion 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
}
}
}, ]
Eingabe:
Ich muss die Subdomains von openai.com und omegaai.io abrufen
Ausgabe 1. Funktion:
[
{
"tool_name": "subdomains",
"parameters": {
"domain": "openai.com"
}
},
{
"tool_name": "subdomains",
"parameters": {
"domain": "omegaai.io"
}
},
]
Nachdem wir die Subdomains aus der Eingabe extrahiert haben, wenden wir unsere Ausführungslogik an, um die Subdomains zu erhalten...
subdomain1.openai.com
subdomain2.openai.com
subdomain3.openai.com
subdomain1.omegaai.io
subdomain2.omegaai.io
subdomain3.omegaai.io
Nachdem dies an die Crawler-Funktion übergeben wurde, würde es etwa so aussehen:
Ausgabe 2. Funktion:
[
{
"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 erlaubt es uns, die Parameter und den Tool-Namen direkt zu sammeln, ohne diese Logik des Filterns des JSON durchlaufen zu müssen.
from zerodai import zerodai
zerodai.api_auth("TU_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"])
Hinweis: Der Standard für Funktionen ist normalerweise OpenAI; dazu haben wir eine Funktion entwickelt, die OpenAI-Funktionen in unser eigenes Format konvertiert, Beispiel:
tool_name, parameters = cls.fn_c(model_fn=model_fn_call, messages=messages, functions=OpenAI2CommandR(osint_funcs), stream=stream, multistep=False)
Zerodai enthält ein Agentensystem, das durch Funktionen und ein Ausführungsmodul erweitert werden kann.
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
Dieser Code muss mit den verwendeten Funktionen einhergehen:
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
}
}
}, ]
Dies ermöglicht dynamische, mehrstufige und multi-Tool-Agenten.
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 um anzugeben, ob wir ein Ausführungsmodul verwenden möchten (Wenn wir True setzen und kein Ausführungsmodul angeben, wird ein Standardmodul ausgeführt)
exec_module Ausführungsmodul
functions Funktionen entsprechend dem Ausführungsmodul
multistep Ob mehrere Schritte bei jeder Iteration des Funktionsaufruf-Modells ausgeführt werden sollen
Diese API enthält Integrationen von Shodan, verschiedenen Datendiensten, Censys und vielem mehr – diese Dienste benötigen nur die 0dAI-API:
zerodai.Osint(prompt)
prompt – Einfache Nachricht in natürlicher Sprache, damit das LLM eine Suche in unseren privaten Datenleckquellen durchführt und Ihnen die Leaks eines Benutzers liefert.
zerodai.Osint(prompt)
prompt – Einfache Nachricht in natürlicher Sprache, damit das LLM eine Suche bei Shodan durchführt und Ihnen die Ergebnisse direkt liefert.
zerodai.rubberducky_gen(prompt)
prompt – Einfache Nachricht in natürlicher Sprache, damit das LLM ein gültiges Rubber Ducky-Payload erstellt.
Diese API wurde vollständig von Luijait (Luis Javier Navarrete Lozano) unter 0dAI entwickelt. Wenn die hier beschriebenen Kenntnisse in einer anderen Arbeit verwendet werden, ist es erforderlich, den Autor zu nennen, zuerst Luijait und dann 0dAI.