Skip to content
KitploitKITPLOIT
उपकरणब्लॉग
जमा करें
उपकरणब्लॉग
जमा करें

हैकिंग, पेनटेस्ट और साइबर सुरक्षा उपकरण आपके सुरक्षा शस्त्रागार के लिए!

Kitploit हैकिंग, साइबर सुरक्षा और पेंटेस्टिंग टूल्स की एक निर्देशिका है। कमजोरियों को खोजने, सिस्टम का विश्लेषण करने, परीक्षण को स्वचालित करने और अपनी सुरक्षा को मजबूत करने के लिए नवीनतम प्रोजेक्ट अपडेट खोजें।

··फ़ीड·संपर्क·गोपनीयता·© 2026 Kitploit

टूल निर्देशिका

श्रेणियाँ

सभी श्रेणियाँ देखें
Loading categories
Zerodapi — 0dAPI आधिकारिक दस्तावेज़ | Kitploit
उपकरण/GitHubGitHub/0dai-ml/zerodapi
OSINT (खुला स्रोत खुफिया)भेद्यता स्कैनरशोषण फ्रेमवर्कपेलोड जनरेशनवेब सुरक्षापेनिट्रेशन टेस्टिंगलर्निंग और शिक्षाAI सुरक्षा
GitHub0dai-ml/zerodapi

Zerodapi

0dAPI आधिकारिक दस्तावेज़

रिपॉजिटरी देखें
12 साल पहलेअभी तक समीक्षित नहीं

सबसे लोकप्रिय

सभी देखें →

हमारे समुदाय द्वारा सबसे अधिक उपयोग किए जाने वाले उपकरण खोजें।

सभी उपकरण खोजें

हमारे उपकरणों का संग्रह ब्राउज़ करें

सभी उपकरण देखें →
साझा करें

Zerodai दस्तावेज़ीकरण

शुरू करें!

root@kitploit:~
pip install zerodai==0.0.0.20
root@kitploit:~
export zerodapi_key="TU_API_KEY"

अपनी API कुंजी प्राप्त करें https://zerodai.com सरल संवादी चैट - बिना मेमोरी

root@kitploit:~

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 एक साइबर सुरक्षा-उन्मुख प्राकृतिक भाषा प्रसंस्करण लाइब्रेरी है जो मानव सूचना प्रसंस्करण, तर्क, योजना और निष्पादन पर आधारित प्रक्रियाओं को आंशिक रूप से स्वचालित करना चाहती है। हम निम्नलिखित क्षमताओं के साथ साइबर सुरक्षा के लिए एक एजेंट फ्रेमवर्क बनाना चाहते हैं:

क्षमताएँ

  • मॉड्यूलरिटी और अनुकूलनशीलता: हम चाहते हैं कि यह लाइब्रेरी लागू करने में आसान हो और अन्य सॉफ्टवेयर टुकड़ों के साथ एकीकृत करने में आसान हो।
  • सरलीकरण: हम किसी प्रक्रिया के अंत में उपयोगकर्ता द्वारा प्राप्त सभी जानकारी को अधिक मानवीय प्रारूप में सरल बनाना चाहते हैं।

अनुमान (Inferences)

यह मॉडल के साथ बातचीत का मूल तरीका है और इसमें निम्नलिखित पैरामीटर हैं। यह महत्वपूर्ण है कि इन पैरामीटरों को अच्छी तरह से सीखा और समझा जाए, क्योंकि ये लाइब्रेरी का आधार हैं।

पैरामीटर

  • model: उपयोग करने के लिए भाषा मॉडल। उपलब्ध मॉडल हैं:

    • 0dai7b: असीमित उपयोग के साथ बुनियादी मॉडल, तेज़ और सरल संवादों और प्रोग्रामिंग सहायता के लिए एकदम सही। साइबर सुरक्षा में अच्छी तरह से बचाव करता है।

      • 16k संदर्भ
      • 16 बिट्स
      • कोई फंक्शन कॉल नहीं
    • 0dai8x7b: बड़े संदर्भ विंडो वाला लचीला मॉडल, कोड के मामले में GPT-4 स्तर, जटिल साइबर सुरक्षा प्रश्नों और स्क्रिप्ट के लिए अच्छा।

      • 32k संदर्भ
      • 8 बिट्स
      • कोई फंक्शन कॉल नहीं
    • 0daifn: फंक्शन कॉल के लिए अनुशंसित मॉडल, फंक्शन कॉल में सर्वश्रेष्ठ, बहुत अधिक संदर्भ, 0dai70b से हल्का, इसके अलावा मल्टीस्टेप फंक्शन कॉल के स्तर पर सर्वश्रेष्ठ gpt के बराबर है।

      • 64k संदर्भ
      • 16 बिट्स
      • फंक्शन कॉल क्षमता
    • 0dai70b (अनुशंसित): वर्तमान में साइबर सुरक्षा में SOTA, बहुत अधिक संदर्भ के आधार पर जटिल तार्किक तर्क करने और अर्ध-स्वायत्त रूप से पेंटेस्टिंग परीक्षणों को हल करने में सक्षम। इसमें फंक्शन कॉल हैं और संरचित संदेशों में उत्तर दे सकता है। यह सबसे धीमा है लेकिन गुणवत्ता में एक बड़ी छलांग प्रदान करता है।

      • 64k संदर्भ
      • 16 बिट्स
      • फंक्शन कॉल क्षमता
  • messages: मॉडल को भेजे जाने वाले संदेश। यहाँ हमें 3 भूमिकाओं को समझना होगा:

    • system: पालन करने के निर्देशों के साथ प्रॉम्प्ट।
    • user: कार्य या प्रश्न।
    • assistant: सहायक का उत्तर।

    संदेश इस प्रारूप में होने चाहिए:

root@kitploit:~
  messages = [
{"role": "system", "content": """Eres 0dAI tu función es..."""},
{"role": "user", "content": "0dAI escribe un exploit en C"},
]
  • functions: वे फ़ंक्शन जिन्हें बातचीत के दौरान कॉल किया जा सकता है। हम fn_c में फ़ंक्शन के बारे में अधिक विस्तार से जानेंगे। इस मामले में, यह केवल हमें JSON देगा।

    एक फ़ंक्शन इस प्रकार घोषित किया जाता है:

root@kitploit:~
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: मॉडल के उत्तरों की यादृच्छिकता को नियंत्रित करता है। अधिक तापमान का अर्थ है अधिक यादृच्छिकता; कम तापमान का अर्थ है कम यादृच्छिकता।

  • stream (bool): क्या उत्तर को वास्तविक समय में प्रसारित किया जाना चाहिए।

उपयोग:

root@kitploit:~
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)

फंक्शन कॉल्स (fn_c)

एक फ़ंक्शन या फ़ंक्शनों की सूची के आधार पर function पैरामीटर में, मॉडल एक अनुमान के बाद एक संरचित उत्तर उत्पन्न करने में सक्षम होगा जो हमें एक संरचित उत्तर प्रदान कर सके: बेस फ़ंक्शन

root@kitploit:~
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
      }
    }
  }, ]

इस फ़ंक्शन के आधार पर मॉडल का उत्तर

root@kitploit:~
[
    {
        "tool_name": "shodan_dork",
        "parameters": {
            "dork": "hacked-router-help-sos"
        }
    }
]

ये फ़ंक्शन मल्टीस्टेप हो सकते हैं या नहीं, यह JSON की स्थितियों की संख्या से परिभाषित होगा, एक मल्टीस्टेप उत्तर इस प्रकार दिखता है

root@kitploit:~
[
    {
        "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"
        }
     }
   ]

एक पुनरावर्ती तर्क भी हो सकता है जहां अनुमान और फ़ंक्शन एक दूसरे को फीडबैक देते हैं, आइए इस मामले की कल्पना करें

सबडोमेन फ़ंक्शन

root@kitploit:~
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
      }
    }
  }, ]

क्रॉलर फ़ंक्शन

root@kitploit:~
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
      }
    }
  }, ]

इनपुट:

मुझे openai.com और omegaai.io के सबडोमेन प्राप्त करने की आवश्यकता है

आउटपुट 1. फ़ंक्शन:

root@kitploit:~
[
    {
        "tool_name": "subdomains",
        "parameters": {
            "domain": "openai.com"
        }
    },
    {
        "tool_name": "subdomains",
        "parameters": {
            "domain": "omegaai.io"
        }
    },
]

इनपुट से सबडोमेन निकालने के बाद हम अपना निष्पादन तर्क लागू करते हैं जो सबडोमेन प्राप्त करना होगा...

root@kitploit:~
subdomain1.openai.com
subdomain2.openai.com
subdomain3.openai.com
subdomain1.omegaai.io
subdomain2.omegaai.io
subdomain3.omegaai.io

इसे क्रॉलर फ़ंक्शन में पास करने के बाद यह कुछ इस प्रकार होगा

आउटपुट 2. फ़ंक्शन:

root@kitploit:~
[
    {
        "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 हमें JSON को स्वयं फ़िल्टर करने के उस तर्क से गुज़रे बिना सीधे पैरामीटर और टूल का नाम एकत्र करने की अनुमति देता है

###उपयोग

root@kitploit:~
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"])

नोट: फ़ंक्शन का मानक आमतौर पर OpenAI होता है, इसके लिए हमने एक फ़ंक्शन डिज़ाइन किया है जो OpenAI फ़ंक्शन को हमारे अपने प्रारूप में परिवर्तित करता है, उदाहरण:

root@kitploit:~
tool_name, parameters = cls.fn_c(model_fn=model_fn_call, messages=messages, functions=OpenAI2CommandR(osint_funcs), stream=stream, multistep=False)

एजेंट

Zerodai में एक एजेंट सिस्टम शामिल है जिसे फ़ंक्शन और एक निष्पादन मॉड्यूल के माध्यम से बढ़ाया जा सकता है

root@kitploit:~
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

यह कोड उपयोग किए गए फ़ंक्शन के साथ-साथ चलना चाहिए

root@kitploit:~
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
      }
    }
  }, ]

यह गतिशील मल्टीस्टेप और मल्टीटूल एजेंट बनाने की अनुमति देता है

###उपयोग

root@kitploit:~
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 यह इंगित करने के लिए कि क्या हम एक निष्पादन मॉड्यूल का उपयोग करना चाहते हैं (यदि हम True डालते हैं और कोई निष्पादन मॉड्यूल नहीं है तो यह डिफ़ॉल्ट एक को निष्पादित करेगा)

exec_module निष्पादन मॉड्यूल

functions निष्पादन मॉड्यूल के अनुरूप फ़ंक्शन

multistep यदि हम चाहते हैं कि फंक्शन कॉल मॉडल के प्रत्येक पुनरावृत्ति में कई चरण निष्पादित हों

##अवधारणा का प्रमाण

4. डेटा लीक PoC

DarkGPT-Osint

5. मल्टीस्टेप-एजेंट PoC

DarkGPT-Osint

यह API shodan, विभिन्न डेटा सेवाओं, censys और बहुत कुछ के साथ एकीकरण के साथ आता है, इन सेवाओं के लिए केवल 0dAI API की आवश्यकता है:

डेटा लीक

zerodai.Osint(prompt)

prompt - LLM के लिए सरल प्राकृतिक भाषा संदेश ताकि वह हमारे निजी डेटा लीक स्रोतों में खोज करे और आपको किसी उपयोगकर्ता के लीक दे

Shodan

zerodai.Osint(prompt)

prompt - LLM के लिए सरल प्राकृतिक भाषा संदेश ताकि वह shodan में खोज करे और आपको सीधे परिणाम दे

Rubber ducky

zerodai.rubberducky_gen(prompt)

prompt - LLM के लिए सरल प्राकृतिक भाषा संदेश ताकि वह एक मान्य rubber ducky पेलोड बनाए

यह API पूरी तरह से Luijait (Luis Javier Navarrete Lozano) द्वारा 0dAI के तहत विकसित की गई है, यदि यहाँ वर्णित ज्ञान का उपयोग किसी अन्य पेपर में किया जाता है तो लेखक को श्रेय देना आवश्यक है, पहले नाम के रूप में Luijait और दूसरे के रूप में 0dAI

टूल डाउनलोड करें