netlas-io/netlas-cookbookइस गाइड का लक्ष्य बहुत सरल है - साइबर सुरक्षा में रुचि रखने वाले किसी भी व्यक्ति को, उनके ज्ञान के स्तर की परवाह किए बिना, Netlas.io का अधिकतम लाभ उठाने का तरीका सिखाना।
इस गाइड का लक्ष्य साइबर सुरक्षा में रुचि रखने वाले किसी भी व्यक्ति को, उनके ज्ञान स्तर की परवाह किए बिना, Netlas Search Tools का अधिकतम लाभ उठाना सिखाना है। यह एक लंबा पाठ है। हमने जितना संभव हो सके उतने सरल उपयोग के मामले एकत्र किए हैं और दिखाया है कि उन्हें कैसे स्वचालित किया जाए।
⭐️ हमें एक स्टार दें अपनी प्रशंसा दिखाने के लिए
👁️ अपडेट के लिए सब्सक्राइब करें
Netlas एक सर्च इंजन है जो इंटरनेट पर उपलब्ध सभी IP पतों और डोमेन के बारे में जानकारी खोजने और विश्लेषण करने के लिए डिज़ाइन किया गया है। Netlas में कुछ अटैक सरफेस मैनेजमेंट सुविधाएँ हैं, लेकिन यह गाइड मुख्य रूप से Netlas Search Tools और ऑटोमेशन में उनके उपयोग पर केंद्रित है।
Netlas में कई खोज उपकरण शामिल हैं:
हम अधिकांशतः प्रतिक्रिया खोज (इंटरनेट स्कैन परिणाम) का उपयोग करेंगे, लेकिन सभी उपकरण एक ही तरह से काम करते हैं। यदि आप समझ गए हैं कि प्रतिक्रिया खोज उपकरण का उपयोग कैसे करें, तो आप किसी भी अन्य को संभाल सकते हैं।
तकनीकी विवरण में जाने से पहले, आइए कुछ सरल उदाहरणों के साथ देखें कि Netlas.io कैसे काम करता है।
Netlas.io IP/Domain जानकारी खोलें और डोमेन नाम या IP दर्ज करें। परिणामस्वरूप निम्नलिखित जानकारी प्रदर्शित की जाएगी:
यदि आपको चीनी या अन्य अंतर्राष्ट्रीयकृत डोमेन नाम खोजने की आवश्यकता है, तो उन्हें Punycode में बदलें। उदाहरण के लिए:``` domain:*.xn--fiqs8s
आप विशेष ऑनलाइन टूल्स की सहायता से ऐसा कर सकते हैं। उदाहरण के लिए - [Charset.org](https://www.charset.org/punycode)
### उन वेबसाइटों की खोज करना जिनके शीर्षक में कोई विशिष्ट शब्द हो
[Netlas.io प्रतिक्रिया खोज](https://app.netlas.io/responses/) खोलें और दर्ज करें:```
http.title:g*thub
यह उन सभी सर्वरों को ढूंढेगा जिनके HTTP शीर्षक में ऐसा शब्द है जो "g" से शुरू होता है और "thub" पर समाप्त होता है। एस्टरिस्क के उपयोग के बारे में नीचे और पढ़ें।
अब जानते हैं कि Netlas.io में खोज क्वेरी कैसे काम करती हैं।
Netlas.io Elasticsearch पर आधारित है, जो एक मुफ्त और ओपन, वितरित, RESTful सर्च इंजन है। और Netlas.io में खोज विधियाँ अन्य Elasticsearch-आधारित डेटाबेस के समान हैं।
प्रतिक्रिया, DNS, IP और प्रमाणपत्र खोज आपको खोज क्वेरी में फ़िल्टर (फ़ील्ड) का उपयोग करने की अनुमति देती है। उदाहरण के लिए:``` http.body:netlas
[Netlas में आज़माएं](https://app.netlas.io/responses/?q=http.body%3Anetlas&page=1&indices=)
आप इस क्वेरी का उपयोग उन पृष्ठों को खोजने के लिए कर सकते हैं जिनके <body> HTML टैग के अंदर "netlas" शब्द है।
प्रत्येक खोज प्रकार के लिए उपलब्ध फ़िल्टर की सूची पृष्ठ के दाईं ओर प्रदर्शित होती है।
फ़िल्टर आपको कई विभिन्न मापदंडों के आधार पर सर्वर खोजने की अनुमति देते हैं। उदाहरण के लिए:
* `domain`
* `ip`
* `protocol`
* `certificate`
* `cve`
* `geolocation` (`city`, `continent`, `country`)
और कई अन्य।
### तार्किक संचालक
आप एक ही क्वेरी में कई फ़िल्टर का उपयोग कर सकते हैं और उन्हें तार्किक संचालक `AND`, `OR`, `NOT` का उपयोग करके जोड़ सकते हैं। उदाहरण के लिए:```
http.title:netlas NOT port:443
यदि आप अपनी क्वेरी में कई शर्तों को जोड़ना चाहते हैं, तो कोष्ठक का उपयोग करें:``` http.title:(netlas OR shodan) NOT port:443
[Try in Netlas](https://nt.ls/OrFOY)
### रेंज
यदि आप किसी फ़ील्ड के मान के रूप में एक संख्यात्मक मान का उपयोग करते हैं, तो आप इसे एक मान से और तक (मान सीमा की चरम सीमाएँ) के रूप में निर्दिष्ट कर सकते हैं:```
ip:[173.194.222.0 TO 173.194.222.255]
या मान की केवल ऊपरी या केवल निचली सीमा को चिह्नित करें:``` host:"1.1.1.1" port:<=1000
[Netlas में आज़माएँ](https://app.netlas.io/responses/?q=host%3A%221.1.1.1%22%20port%3A%3C%3D1000&page=1&indices=)
### वाइल्डकार्ड
यदि आप अपनी क्वेरी में किसी निश्चित वर्ण का सटीक विवरण नहीं जानते हैं (उदाहरण के लिए, आप किसी डोमेन का सटीक ज़ोन या नाम की वर्तनी नहीं जानते हैं), तो आप इसे एक तारांकन चिह्न से बदल सकते हैं:```
domain:google.*
आप प्रश्न चिह्न का भी उपयोग कर सकते हैं:``` domain:google.?
[Netlas में आज़माएं](https://app.netlas.io/responses/?q=domain%3Agoogle.%3F&page=1&indices=)
`*` - अनेक प्रतीक, `?` - एक प्रतीक।
आप फिल्टर में तारांकन का भी उपयोग कर सकते हैं। उदाहरण:```
\*.banner:database
यह क्वेरी सभी बैनर प्रकारों पर एक साथ खोज करती है और कई फ़िल्टरों को बदल देती है: amqp.banner:, ftp.banner:, dns.banner:, telnet.banner:, आदि।
अगर आपको किसी फ़ील्ड के सटीक मान के बजाय अनुमानित मान से खोजना है (उदाहरण के लिए, ऐसे पेज जिनके शीर्षक में Joseph के समान ध्वनि वाले सभी नाम हैं), तो क्वेरी में ~ जोड़ें:```
http.title:Joseph~
[Try in Netlas](https://app.netlas.io/responses/?q=http.title%3AJoseph~&page=1&indices=)
### नियमित अभिव्यक्तियाँ
नियमित अभिव्यक्ति वर्णों का एक क्रम है जो आपको स्रोत दस्तावेज़ में पाठ के उन टुकड़ों को खोजने, प्राप्त करने और बदलने की अनुमति देता है जो कुछ पैटर्न से मेल खाते हैं। उदाहरण के लिए:
* कोई भी ईमेल पता: ```text
([a-zA-Z0–9+._-]+@[a-zA-Z0–9._-]+\.[a-zA-Z0–9_-]+)
For more information on using regular expressions, see the examples in the Netlas Cookbook (what you're reading now) and the links below:
Regex Syntax Manual in Elasticsearch documentation
How regular expressions can be useful in OSINT. Theory and some practice using Google Sheets
You can save your results (all or selected fields) in JSON and CSV format to view them in a format you like or automatically analyse them with different tools.
You can group results by different field values to speed up the search time. For example, by domain name or geolocation.
You can freely share links to search results (no registration is required to open them, unless the user has exceeded the free limit of 50 requests).
Also remember that all the queries you have made can be viewed on your profile page (link in the top right corner).
Netlas.io's most important function is to help people conduct cybersecurity research faster and more efficiently. The service has an API (application programming interface) that allows you to automate the execution of various requests.
It can be implemented both in simple Python or Bash scripts of a few lines in length and in complex multifunctional applications.
You can read more about using the Netlas API in the Netlas Cookbook (what you're reading now) or in the official documentation:
This is the very first place to start with the API. You don't even have to pay for a subscription (50 requests per day are free). Just go to profile page.
You don't have to write scripts or create applications to start using the Netlas API. You can simply test it using your favorite API client. See instructions here.
Similar to other APIs, the Netlas API response consists of headers and a response body in JSON (JavaScript Object Notation) format. JSON files contain data in key-value format and can be analysed using almost any programming language.
If you use Swagger, you can copy or download the response body and view it in any text editor or JSON analyser.
A little tip that will come in handy when writing code using the Netlas API. In order to understand the structure of a JSON file faster and find the path to get a certain value, use special tools such as:
The easiest way to automate requests to the Netlas API is to use a specially designed Python library (package).
Netlas-Python library Github repo
Let's see how it works with a simple example. All code samples from Netlas Cookbook are located in the scripts folder. You can clone this repository and run them on your device:```shell git clone https://github.com/netlas-io/netlas-cookbook
यदि आपने आज से पहले कोई Python स्क्रिप्ट नहीं चलाई है और यह नहीं जानते कि इसे कैसे करें, तो आप Gitpod में Netlas CookBook रिपॉजिटरी खोलकर शुरू कर सकते हैं।
Gitpod Ubuntu (लिनक्स वितरण) पर आधारित एक क्लाउड डेवलपमेंट वातावरण है। बस अपने ब्राउज़र में इस लिंक को खोलें (अपने Github खाते से लॉग इन करें):
[Gitpod में Netlas Cookbook चलाएं](https://gitpod.io#https://github.com/netlas-io/netlas-cookbook)
pip (Python के लिए पैकेज इंस्टॉलर) का उपयोग करके Netlas Python लाइब्रेरी स्थापित करें। कमांड लाइन में दर्ज करें:```shell
pip install netlas
स्थापना की जाँच करें। कमांड लाइन में दर्ज करें:```shell netlas --help
चलाएँ netlas_python_example.py:```shell
python3 scripts/netlas_python_example.py
और निश्चित रूप से, आप कोड को कॉपी करके फ़ाइलों में सहेज सकते हैं। यहाँ पहले उदाहरण का कोड है:```python import netlas
apikey = "YOUR API KEY"
netlas_connection = netlas.Netlas(api_key=apikey)
port:7001netlas_query = netlas_connection.query(query="port:7001")
for response in netlas_query['items']: print(f"{response['data']['ip']}:{response['data']['port']}{response['data']['path']} [{response['data']['protocol']}]")
### उपयोगी डेटा प्राप्त करने के लिए प्रतिक्रिया कुंजियों के उदाहरण
ऊपर उल्लेख किया गया है कि आपको आवश्यक डेटा प्राप्त करने के लिए API प्रतिक्रिया के JSON पैच खोजने हेतु, आप विशेष ऑनलाइन एप्लिकेशन (JSON-evaluators) का उपयोग कर सकते हैं। आपके जीवन को और भी आसान बनाने के लिए, यहाँ Python लाइब्रेरी की प्रतिक्रिया कुंजियों के कुछ उदाहरणों की एक छोटी सूची दी गई है जिनकी सबसे अधिक आवश्यकता होती है।```python
# Main domain/ip info
response['data']['uri']
response['data']['ip']
response['data']['http']['title']
response['data']['http']['meta']
response['data']['http']['body']
# Geo info
response['data']['geo']['continent']
response['data']['geo']['country']
response['data']['geo']['city']
response['data']['geo']['location']['lat']
response['data']['geo']['location']['long']
# Whois geo info
response['data']['whois']['net']['country']
response['data']['whois']['net']['address']
response['data']['whois']['net']['city']
response['data']['whois']['net']['contacts']['emails']
response['data']['whois']['net']['contacts']['phones']
# Http status and favicon ico info
response['data']['port']
response['data']['http']['status_code']
response['data']['http']['status_line']
response['data']['http']['favicon']['image']
response['data']['http']['favicon']['path']
# Basic CVE info
response['data']['cve'][0]['name']
response['data']['cve'][0]['description']
response['data']['cve'][0]['base_score']
response['data']['cve'][0]['has_exploit']
response['data']['cve'][0]['exploit_links']
Netlas Python लाइब्रेरी के साथ काम करते समय, आप जिस प्रकार का डेटा प्राप्त करना चाहते हैं उसे सही ढंग से निर्दिष्ट करना बहुत महत्वपूर्ण है। डिफ़ॉल्ट रूप से, response प्रकार वापस किया जाता है और कई Netlas CookBook उदाहरण इसका उपयोग करते हैं।
लेकिन कुछ कार्यों के लिए, जैसे किसी डोमेन के बारे में whois जानकारी प्राप्त करना या subnet में डोमेन खोजना, आपको एक अलग डेटा प्रकार का उपयोग करने की आवश्यकता होती है। उदाहरण के लिए:```python netlas_query = netlas_connection.query(query='a:"163.114.132.0/24"',datatype="domain")
यदि आपको लगता है कि कोई क्वेरी परिणाम नहीं दे रही है जबकि उसे देना चाहिए - तो बस **datatype** पैरामीटर का मान बदलने का प्रयास करें। इससे मदद मिलने की बहुत संभावना है।
उपलब्ध डेटाटाइप:
- **datatype="response"** उन परिणामों से मेल खाता है जो [Netlas Responses Search](https://app.netlas.io/responses/) में प्राप्त किए जा सकते हैं।
- **datatype="domain"** उन परिणामों से मेल खाता है जो [Netlas DNS search](https://app.netlas.io/domains/) में प्राप्त किए जा सकते हैं।
- **datatype="domain-whois"** उन परिणामों से मेल खाता है जो [Netlas Domain Whois Search](https://app.netlas.io/whois_domains/) में प्राप्त किए जा सकते हैं।
- **datatype="ip-whois"** उन परिणामों से मेल खाता है जो [Netlas IP Whois Search](https://app.netlas.io/whois_ip/) में प्राप्त किए जा सकते हैं।
- **datatype="cert"** उन परिणामों से मेल खाता है जो [Netlas Certificates Search](https://app.netlas.io/certs/) में प्राप्त किए जा सकते हैं।
### Netlas CLI उपकरण
आप Netlas Python लाइब्रेरी का उपयोग सीधे कमांड लाइन से भी कर सकते हैं। उदाहरण के लिए:```bash
netlas search "http.title:johnsmith" -f json >results.json
यह सरल कमांड उन सभी सर्वरों की खोज करता है जिनके हेडर में johnsmith शब्द है, परिणामों को JSON फ़ॉर्मेट में लौटाता है, और परिणामों को resutls.json फ़ाइल में संग्रहीत करता है।
Netlas API की अन्य सभी सुविधाओं का भी इसी तरह उपयोग किया जा सकता है। आप इसके बारे में सहायता (-h कमांड) और Netlas कुकबुक (जो आप अभी पढ़ रहे हैं) में दिए गए उदाहरणों से अधिक जान सकते हैं।``` Usage: netlas [OPTIONS] COMMAND [ARGS]...
Options: -h, --help Show this message and exit.
Commands: count Calculate count of query results. download Download data. host Host (ip or domain) information. indices Get available data indices. profile Get user profile data. savekey Save API key to the local system. search (query) Search query. stat Get statistics for query.
विभिन्न Netlas CLI Tools कमांड चलाने से पहले, सेटिंग्स में API key सहेजें:```bash
netlas savekey YOUR_API_KEY
हमारे पास एक Github रिपॉजिटरी भी है जिसमें bash script और Netlas CLI टूल्स का उपयोग करके विभिन्न कार्यों को स्वचालित करने के कुछ उदाहरण हैं:
Netlas API में कई विधियाँ हैं, लेकिन सबसे अधिक उपयोग की जाने वाली विधियाँ search और download हैं। वे एक-दूसरे से बहुत समान हैं, लेकिन फिर भी उनमें कुछ अंतर हैं।
search method एक बार में परिणामों का एक पृष्ठ (20 आइटम) लोड करता है और अधिकतम 200 पृष्ठ लोड करने की अनुमति देता है (20*200=4000 आइटम)। download method सभी परिणामों को डाउनलोड करता है (लेकिन निष्पादित करने के लिए अधिक संसाधनों की आवश्यकता होती है)।
एक host method भी है जो किसी विशेष डोमेन या IP के बारे में सबसे बुनियादी जानकारी लौटाता है (datatype (अन्य विधियों की तरह) निर्दिष्ट करने की आवश्यकता नहीं है):```bash netlas host "51.159.153.170"
### अतिरिक्त अनुरोध पैरामीटर
Netlas API आपको अतिरिक्त पैरामीटर के साथ अनुरोधों द्वारा लौटाए गए डेटा को लचीले ढंग से समायोजित करने की अनुमति देता है। उदाहरण के लिए:
* indices - एक विशिष्ट अनुक्रमण तिथि के अनुरूप id। किसी विशिष्ट तिथि के लिए id जानने के लिए, app.netlas.io खोलें, खोज क्वेरी प्रविष्टि पट्टी के दाईं ओर कैलेंडर पर क्लिक करें, अपनी रुचि की तिथि चुनें और देखें कि ब्राउज़र पता पट्टी में URL में indices पैरामीटर कैसे बदलता है।
* start - परिणाम पृष्ठ संख्या (डिफ़ॉल्ट 0)
* fields - परिणामों में शामिल किए जाने वाले फ़ील्ड के नाम (डिफ़ॉल्ट रूप से सभी फ़ील्ड)। यह बड़ी संख्या में अनुरोधों के साथ कोड को गति देने और अनुकूलित करने के लिए उपयोगी होगा।
### Python के साथ अनुरोध करें (Netlas Python Library के बिना)
आप कुछ मामलों में Netlas Python Library का उपयोग न करना आसान पा सकते हैं, बल्कि मानक Python request पैकेज का उपयोग कर सकते हैं, जो कई डेवलपर्स से परिचित है:
कमांड लाइन में दर्ज करें:```bash
python scripts/python_example.py
python_example.py का स्रोत कोड:```python import requests
response = requests.get("https://app.netlas.io/api/domains/?q=ivanov.com&source_type=include&start=0&fields=*",{'X-API-Key': 'YOUR API KEY'})
print(response.json())
लेकिन Netlas Python Library अभी भी बेहतर है क्योंकि इसे क्वेरी प्रोसेसिंग (त्रुटियाँ, लंबी प्रतीक्षा आदि) में विभिन्न समस्याओं से निपटने के लिए डिज़ाइन किया गया है।
### अन्य प्रोग्रामिंग भाषाओं के लिए उदाहरण
जबकि हम Netlas खोज को स्वचालित करने के लिए अपनी Python Library का उपयोग करने की सलाह देते हैं, यह ध्यान देने योग्य है कि Netlas API को तकनीकी स्टैक की एक विस्तृत विविधता वाले अधिकांश अनुप्रयोगों में बनाया जा सकता है। मुख्य बात यह है कि इसे **REST अनुरोध** करने और **JSON डेटा** पार्स करने में सक्षम होना चाहिए।
यहाँ विभिन्न लोकप्रिय प्रोग्रामिंग भाषाओं में कुछ उदाहरण दिए गए हैं।
#### NodeJS <!-- omit in toc -->
कमांड लाइन में दर्ज करें:```bash
node scripts/node_example.js
यदि आप Gitpod का उपयोग नहीं कर रहे हैं, तो आपके डिवाइस पर NodeJS स्थापित होना चाहिए।
nodejs_example.js का स्रोत कोड:```javascript fetch('https://app.netlas.io/api/domains/?q=ivanov.com&source_type=include&start=0&fields=*', { headers: { "X-API-Key": "YOUR_API_KEY", }, }) .then((response) => response.text()) .then((body) => { var jsonArray = JSON.parse(body); console.log(jsonArray['items'][0]); });
#### Ruby <!-- omit in toc -->
कमांड लाइन में दर्ज करें:```bash
ruby scripts/ruby_example.rb
यदि आप Gitpod का उपयोग नहीं कर रहे हैं, तो आपके डिवाइस पर Ruby स्थापित होना चाहिए।
Source code of ruby_example.rb:```ruby require 'net/http' require 'uri' require 'json'
uri = URI("https://app.netlas.io/api/domains/?q=ivanov.com&source_type=include&start=0&fields=*") req = Net::HTTP::Get.new(uri) req['X-API-Key'] = "YOUR_API_KEY"
res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') { |http| http.request(req) }
jsonArray = JSON.parse(res.body)
puts jsonArray['items'][0]['data']['domain']
#### Bash <!-- omit in toc -->
कमांड लाइन में दर्ज करें:```bash
bash scripts/bash_example.sh
bash_example.sh का स्रोत कोड:```
curl -X 'GET'
'https://app.netlas.io/api/domains/?q=ivanov.com&source_type=include&start=0&fields=*'
-H 'accept: application/json'
-H 'X-API-Key: YOUR_API_KEY' | jq .items[0].data.last_updated
### JQ उपयोगिता
ध्यान दें कि ऊपर दिए गए उदाहरण में, JSON डेटा से फ़ील्ड निकालने के लिए JQ उपयोगिता का उपयोग किया गया था।
इसे कभी-कभी "JSON डेटा के लिए sed की तरह" कहा जाता है। यह किसी भी JSON डेटा के साथ काम करने के लिए एक आश्चर्यजनक रूप से उपयोगी उपकरण है। यहाँ कुछ सिंटैक्स उदाहरण दिए गए हैं।
JSON-array का firt आइटम प्रिंट करें:```
.items[0]
JSON-array के सभी आइटम प्रिंट करें:``` .items[]
JSON-array के पहले आइटम के सभी 'data' उप-आइटम प्रिंट करें:```
.['items'][0]['data'][]
JSON-array के प्रत्येक आइटम के लिए सभी उप-उप-आइटम प्रिंट करें:``` .items[].data.technical[]
आप JQ के बारे में यहाँ और अधिक पढ़ सकते हैं (मैं डेटा फ़िल्टरिंग पर विशेष ध्यान देने की सलाह देता हूँ): [JQ उपयोगिता दस्तावेज़ीकरण](https://jqlang.github.io/jq/)
### कोड लिखने के लिए AI उपकरण
यदि आप नेटलास कुकबुक उदाहरणों को अनुकूलित करते समय किसी समस्या का सामना करते हैं, तो हम अनुशंसा करते हैं कि आप कोड में सुधार और लिखने के लिए AI उपकरणों से सहायता लें। उदाहरण के लिए:
[ChatGPT](https://chatgpt.com)
[Code Llama](https://huggingface.co/spaces/codellama/codellama-playground)
[You.com](https://you.com/)
ऐसी सेवाओं के साथ काम करते समय, आपको बस उस कार्य को शब्दों में वर्णित करना होता है जिसे आप कोड की सहायता से हल करना चाहते हैं।
### कोड जाँचकर्ता
जब आप अपने उद्देश्यों के अनुरूप नेटलास कुकबुक के उदाहरणों को पुनः काम में लेते हैं, तो आप पा सकते हैं कि कोड कुछ त्रुटियों के कारण निष्पादित नहीं होगा। विशेष ऑनलाइन उपकरण आपको उन्हें खोजने और ठीक करने में मदद कर सकते हैं:
[ExtendsClass Python Tester](https://extendsclass.com/python-tester.html)
[Snyk](https://snyk.io/code-checker/python/)
यदि आप अपने कोड को तीसरे पक्ष की सेवाओं में कॉपी नहीं करना चाहते हैं, तो आप Pylint (स्टैटिक कोड विश्लेषक) का उपयोग करके अपने डिवाइस पर त्रुटियों की जाँच कर सकते हैं:
[Pylint पायथन पैकेज](https://pypi.org/project/pylint/)
## OSINT (ओपन सोर्स इंटेलिजेंस) के लिए Netlas.io का उपयोग
Netlas.io आपको किसी डोमेन या कंपनी के बारे में डेटा एकत्र करने में मदद कर सकता है, साथ ही इंटरनेट में किसी व्यक्ति (या किसी के भी) का उल्लेख ढूंढने में भी मदद कर सकता है।
इसका उपयोग वेब पेजों के पुराने संस्करण खोजने के लिए भी किया जा सकता है (जैसे कि वेबैक मशीन का एनालॉग)।
### WHOIS संपर्कों में व्यक्ति का उपनाम या ईमेल खोजें
अक्सर WHOIS डेटा में केवल डोमेन पंजीकृत करने वाली कंपनी की संपर्क जानकारी होती है। लेकिन कभी-कभी रुचि के व्यक्तियों के व्यक्तिगत संपर्क भी हो सकते हैं। यह क्वेरी आपको उन्हें खोजने में मदद करेगी।
*इस विधि के लिए भुगतान किए गए सब्सक्रिप्शन की आवश्यकता हो सकती है।* [मूल्य निर्धारण देखें](https://netlas.io/pricing/)
**खोज क्वेरी उदाहरण**
```
whois.related_nets.contacts.emails:sweetwater
API अनुरोध उदाहरण
Netlas CLI उपकरण:```bash netlas search "whois.related_nets.contacts.emails:sweetwater*" -f json
Curl:```bash
curl -X 'GET' \
'https://app.netlas.io/api/responses/?q=whois.related_nets.contacts.emails%3Asweetwater*&fields=' \
-H 'accept: application/json' \
-H 'X-API-Key: aqkd8L4MR93Tkcaz2UXDXrRleV8Vlvbv' | jq .items[].data.uri
कोड उदाहरण (Netlas Python Library)
कमांड लाइन में चलाएँ:```bash python scripts/osint/whois_email_search.py
का स्रोत कोड scripts/osint/whois_email_search.py:```python
import netlas
apikey = "YOUR_API_KEY"
# create new connection to Netlas
netlas_connection = netlas.Netlas(api_key=apikey)
# retrieve data from responses by query `whois.related_nets.contacts.emails:sweetwater`
netlas_query = netlas_connection.query(query="whois.related_nets.contacts.emails:sweetwater*")
# iterate over data and print: URL, Country, Related nets data
for response in netlas_query['items']:
print (response['data']['uri'])
print (response['data']['geo']['country'])
print (response['data']['whois']['related_nets'])
Netlas आपको वेब पेजों के शीर्षकों और html कोड में कुछ शब्दों के उल्लेखों को खोजने की अनुमति देता है। आप शब्दों को सटीक मिलान, अनुमानित मिलान (फ़ज़ी क्वेरीज़ अनुभाग देखें) द्वारा खोज सकते हैं और जिन अक्षरों के बारे में आप निश्चित नहीं हैं, उन्हें तारांकन से बदल सकते हैं।
खोज क्वेरी उदाहरण
```
http.title:sweetwater OR http.body:sweetwater
[Netlas में आज़माएं](https://app.netlas.io/responses/?q=http.title%3Asweetwater%20OR%20http.body%3Asweetwater&page=1&indices=)
**API अनुरोध उदाहरण**
Netlas CLI Tools:```bash
netlas search "http.title:sweetwater OR http.body:sweetwater" -f json
Curl:```bash
curl -X 'GET'
'https://app.netlas.io/api/responses/?q=whois.related_nets.contacts.emails%3Asweetwater*&fields='
-H 'accept: application/json'
-H 'X-API-Key: YOUR_API_KEY' | jq .items[].data.uri
**कोड उदाहरण (Netlas Python Library)**
कमांड लाइन में चलाएँ:```bash
python scripts/osint/title_body_search.py
scripts/osint/title_body_search.py का स्रोत कोड:```python import netlas
apikey = "YOUR_API_KEY"
netlas_connection = netlas.Netlas(api_key=apikey)
http.title:sweetwater OR http.body:sweetwaternetlas_query = netlas_connection.query(query="http.title:sweetwater OR http.body:sweetwater*")
for response in netlas_query['items']: print (response['data']['ip']) print (response['data']['uri']) print (response['data']['http']['title'])
### कंपनी की वेबसाइट के उपडोमेन पर "Juicy Info Files" खोजें
Metagoofil कई वर्षों से OSINT चिकित्सकों के बीच एक लोकप्रिय उपकरण रहा है। यह कंपनी की वेबसाइट पर दस्तावेज़ फ़ाइलों (pdf, xlsx, docx आदि) के लिए Google पर खोजता है और उनके मेटाडेटा का विश्लेषण करता है।
और जो Google द्वारा इंडेक्स नहीं किया गया है, उसे Netlas के साथ खोजा जा सकता है और फिर आपके कंप्यूटर पर डाउनलोड करके [MetaDetective](https://github.com/franckferman/MetaDetective) टूल से विश्लेषण किया जा सकता है।```
uri:*lidl.* AND http.body:pdf
आप uri: फ़िल्टर को domain: और host: से बदल सकते हैं (मैं इन तीनों फ़िल्टर का उपयोग करते समय परिणामों की तुलना करने की सलाह देता हूँ)।
आप अपनी खोज के अनुसार फ़ाइल एक्सटेंशन की एक विस्तृत विविधता भी खोज सकते हैं। उदाहरण के लिए:``` http.body:xls http.body:xlsx http.body:doc http.body:docx http.body:ppt http.body:pptx http.body:mdb http.body:csv http.body:sql http.body:sqlite
**API अनुरोध उदाहरण**
Netlas CLI Tools:```bash
netlas search "uri:*lidl.* AND http.body:pdf"
Curl:```bash
curl -X 'GET'
'https://app.netlas.io/api/responses/?q=uri%3A*lidl.*%20AND%20http.body%3Apdf&source_type=include&start=0&fields=*'
-H 'accept: application/json'
-H 'X-API-Key: 'YOUR_API_KEY' | jq .items[].data.domain
**कोड उदाहरण (Netlas Python Library)**
कमांड लाइन में चलाएँ:```bash
python scripts/osint/juicyinfo_search.py
scripts/osint/juicyinfo_search.py का स्रोत कोड:```python import netlas
apikey = "YOUR_API_KEY"
netlas_connection = netlas.Netlas(api_key=apikey)
uri:*lidl.* AND http.body:pdfnetlas_query = netlas_connection.query(query='uri:lidl. AND http.body:pdf')
for response in netlas_query['items']: print (response['data']['uri']) print (response['data']['http']['body'])
वेब पेज के बॉडी से पीडीएफ दस्तावेज़ों के लिंक को स्वचालित करने के लिए आप Python [Re](https://docs.python.org/3/library/re.html) पैकेज का उपयोग कर सकते हैं।
### फ़ोन नंबर उल्लेख खोज
उपनामों और ईमेल की तरह, आप वेब पेजों के कोड या WHOIS संपर्क जानकारी में फ़ोन नंबर के उल्लेखों को भी खोज सकते हैं।
हम इस कार्य को एक अलग उदाहरण के रूप में अलग करते हैं, क्योंकि फ़ोन नंबर खोजना इस तथ्य से जटिल है कि इसे विभिन्न प्रारूपों में लिखा जा सकता है।
**खोज क्वेरी उदाहरण**
```
http.body:1?234?567?89?99 OR http.body:12345678999 OR http.body:1234?5678?999
अनुरोध करते समय, आपको उस देश में स्वीकृत फ़ोन नंबर रिकॉर्डिंग के प्रारूप को ध्यान में रखना चाहिए, जिसके पास वह फ़ोन नंबर है जिसमें आप रुचि रखते हैं।
API अनुरोध उदाहरण
Netlas CLI Tools:```bash netlas search "http.body:1?234?567?89?99 OR http.body:12345678999 OR http.body:1234?5678?999" -f json
यह मत भूलें कि आप फ़ोन नंबरों को केवल पेज के मुख्य भाग में ही नहीं, बल्कि WHOIS संपर्क जानकारी में भी खोज सकते हैं। यह फ़िल्टर **whois.related_nets.contacts.phones:** का उपयोग करके किया जा सकता है।
Curl:```bash
curl -X 'GET' \
'https://app.netlas.io/api/responses/?q=http.body%3A1%3F234%3F567%3F89%3F99%20OR%20http.body%3A12345678999%20OR%20http.body%3A1234%3F5678%3F999&source_type=include&start=0&fields=*' \
-H 'accept: application/json' \
-H 'X-API-Key: YOUR_API_KEY' jq .items[].data.uri
कोड उदाहरण (Netlas Python Library)
कमांड लाइन में चलाएँ:```bash python scripts/osint/phonenumber_search.py
scripts/osint/phonenumber_search.py का स्रोत कोड:```python
import netlas
apikey = "YOUR_API_KEY"
# create new connection to Netlas
netlas_connection = netlas.Netlas(api_key=apikey)
# retrieve data from responses by query `http.body:1?234?567?89?99 OR http.body:12345678999 OR http.body:1234?5678?999`
netlas_query = netlas_connection.query(query="http.body:1?234?567?89?99 OR http.body:12345678999 OR http.body:1234?5678?999")
# iterate over data and print: ip, url
for response in netlas_query['items']:
print (response['data']['ip'])
print (response['data']['uri'])
मान लीजिए कि आप एक संगीतकार हैं और आप उन सभी साइटों को ढूंढना चाहते हैं जहां आपके ट्रैक पोस्ट किए गए हैं। आप ऐसा उन पेजों की खोज करके कर सकते हैं जिनमें आपके नाम का उल्लेख हो और .mp3 एक्सटेंशन वाली फ़ाइलों के लिंक हों।
खोज क्वेरी उदाहरण
```
(http.title:alla OR http.body:alla) AND http.body:*.mp3
[Netlas में आज़माएं](https://nt.ls/HEhJj)
**API अनुरोध उदाहरण**
Netlas CLI टूल्स:```bash
netlas search "(http.title:alla OR http.body:alla) AND http.body:*.mp3" -f json
Curl:```bash
curl -X 'GET'
'https://app.netlas.io/api/responses/?q=(http.title%3Aalla%20OR%20http.body%3Aalla)%20AND%20http.body%3A*.mp3&source_type=include&start=0&fields=*'
-H 'accept: application/json'
-H 'X-API-Key: YOUR_API_KEY' | jq .items[].data.http.title
**कोड उदाहरण (Netlas Python Library)**
कमांड लाइन में चलाएँ:```bash
python scripts/osint/file_mentions_search.py
स्रोत कोड scripts/osint/file_mentions_search.py:```python import netlas
apikey = "YOUR_API_KEY"
netlas_connection = netlas.Netlas(api_key=apikey)
(http.title:alla OR http.body:alla) AND http.body:*.mp3netlas_query = netlas_connection.query(query="(http.title:alla OR http.body:alla) AND http.body:*.mp3")
for response in netlas_query['items']: print (response['data']['ip']) print (response['data']['uri']) print (response['data']['http']['title'])
### डोमेन WHOIS जानकारी संग्रहण
WHOIS एक विश्वव्यापी सार्वजनिक डेटाबेस है जो दुनिया में सभी पंजीकृत डोमेन के बारे में जानकारी संग्रहीत करता है।
**खोज क्वेरी उदाहरण**
उपयोग करें [WHOIS डोमेन खोज](https://app.netlas.io/whois_domains/)```
github.com
API अनुरोध उदाहरण
Netlas CLI Tools:```bash netlas host github.com -f json
Curl:```bash
curl -X 'GET' \
'https://app.netlas.io/api/whois_domains/?q=github.com&source_type=include&start=0&fields=*' \
-H 'accept: application/json' \
-H 'X-API-Key: YOUR_API_KEY' | jq .items[].data.technical.street
कोड उदाहरण (नेटलास पायथन लाइब्रेरी)
कमांड लाइन में चलाएँ:```bash python scripts/osint/whois_search.py
scripts/osint/whois_search.py का स्रोत कोड:```python
import netlas
apikey = "YOUR_API_KEY"
# create new connection to Netlas
netlas_connection = netlas.Netlas(api_key=apikey)
# retrieve data from whois for google.com domain
netlas_query = netlas_connection.query(query="google.com",datatype="whois-domain")
# iterate over data and print: owner name
for response in netlas_query['items']:
print (response['data']['technical']['name'])
<address> टैग में स्थान खोजें<address> टैग किसी वेब पेज के <head> टैग के अंदर स्थित होता है और इसमें भौतिक पते हो सकते हैं। इस टैग का उपयोग करके खोज करने पर, आप किसी विशेष सड़क, और कभी-कभी किसी विशेष भवन से जुड़ी साइटें ढूंढ सकते हैं।
खोज क्वेरी उदाहरण
```
http.contacts.address:kirby
[Netlas में आज़माएं](https://app.netlas.io/responses/?q=http.contacts.address%3Akirby&page=1&indices=)
आप http.contacts.email: का उपयोग ईमेल खोज के लिए भी कर सकते हैं।
**API अनुरोध उदाहरण**
Netlas CLI Tools:```bash
netlas search "http.contacts.address:kirby" -f json
Curl:```bash
curl -X 'GET'
'https://app.netlas.io/api/responses/?q=http.contacts.address%3Akirby&source_type=include&start=0&fields=*'
-H 'accept: application/json'
-H 'X-API-Key: 'YOUR_API_KEY' | jq .items[].data.http.contacts
**कोड उदाहरण (Netlas Python Library)**
कमांड लाइन में चलाएँ:```bash
python scripts/osint/contacts_search.py
scripts/osint/contacts_search.py का स्रोत कोड:```python import netlas
apikey = "YOUR_API_KEY"
netlas_connection = netlas.Netlas(api_key=apikey)
http.contacts.address:kirbynetlas_query = netlas_connection.query(query="http.contacts.address:kirby")
for response in netlas_query['items']: print (response['data']['uri']) print (response['data']['http']['contacts'])
### मेटा टैग में लेखक का नाम खोजें
`<meta>` टैग वेब पेज के `<head>` टैग के अंदर स्थित होते हैं और इनमें सबसे महत्वपूर्ण कीवर्ड, विवरण, विविध सेवा जानकारी और लेखक का नाम होता है।
मेटा टैग (http.meta) द्वारा उपनाम और नाम/उपनाम की खोज करने से आप पूरे html कोड (http.body) की खोज करने की तुलना में किसी विशेष व्यक्ति से जुड़ी साइटों को तेज़ी से ढूंढ सकते हैं।
**खोज क्वेरी उदाहरण**
```
http.meta:nazar
API अनुरोध उदाहरण
Netlas CLI उपकरण:```bash netlas search "http.meta:nazar" -f json
Curl:```bash
curl -X 'GET' \
'https://app.netlas.io/api/responses/?q=http.meta%3Anazar&source_type=include&start=0&fields=*' \
-H 'accept: application/json' \
-H 'X-API-Key: YOUR_API_KEY' | jq .items[].data.http.meta
कोड उदाहरण (Netlas Python Library)
कमांड लाइन में चलाएं:```bash python scripts/osint/author_meta_search.py
scripts/osint/author_meta_search.py का स्रोत कोड:```python
import netlas
apikey = "YOUR_API_KEY"
# create new connection to Netlas
netlas_connection = netlas.Netlas(api_key=apikey)
# retrieve data from responses by query `http.meta:nazar`
netlas_query = netlas_connection.query(query="http.meta:nazar")
# iterate over data and print: ip, url
for response in netlas_query['items']:
print (response['data']['uri'])
print (response['data']['http']['title'])
print (response['data']['http']['meta'])
लेखक के नाम के अलावा, मेटा टैग कई प्रकार की जानकारी रख सकते हैं: एन्कोडिंग, भाषा, सर्च इंजन रोबोट द्वारा पेज को इंडेक्स करने की अनुमति, सोशल नेटवर्क में लिंक कार्ड के लिए टेक्स्ट, OpenGraph मेटाडेटा, और भी बहुत कुछ। यहाँ कुछ और मेटा टैग के उदाहरण दिए गए हैं जो जाँच के लिए उपयोगी जानकारी रख सकते हैं:
<meta name="description"> - वेब पेज सामग्री का विवरण।<meta name="keywords"> - कीवर्ड जो वेब पेज की सामग्री का वर्णन करते हैं।<meta name="generator"> - उस टूल का नाम जिसका उपयोग पेज सामग्री उत्पन्न करने के लिए किया गया था (CMS और होस्टिंग प्लेटफ़ॉर्म की खोज के लिए उपयोगी)<meta name="copyright"> - उस व्यक्ति या कंपनी का नाम जो वेब पेज की सामग्री का कॉपीराइट रखता है।किसी व्यक्ति या कंपनी के बारे में जानकारी खोजने में एक और महत्वपूर्ण कदम FTP सर्वर बैनर के टेक्स्ट में उसका उल्लेख खोजना है। यह संभव है कि मिले सर्वरों का IP पता आपकी रुचि के व्यक्ति या कंपनी से संबंधित अन्य साइटों को खोजने की कुंजी होगा। और बहुत भाग्यशाली स्थिति में, वहाँ पोस्ट की गई फ़ाइलों में कुछ दिलचस्प मिल सकता है (यदि FTP सर्वर खुला है)।
Search query example
```
ftp.banner:"Collado"
यदि आपको FTP सर्वरों को किसी अन्य पैरामीटर (जैसे शहर या IP पता श्रेणी) द्वारा खोजने की आवश्यकता है, तो prot7:ftp फ़िल्टर का उपयोग करें।
[Netlas में प्रयास करें](https://app.netlas.io/responses/?q=ftp.banner%3A%22Collado%22%20&page=1&indices=)
**API अनुरोध उदाहरण**
Netlas CLI उपकरण:```bash
netlas search 'ftp.banner:"Collado"' -f json
ध्यान दें कि जब क्वेरी में डबल कोट्स का उपयोग किया जाता है, तो क्वेरी स्वयं सिंगल कोट्स के अंदर लिखी जाती है।
Curl:```bash
curl -X 'GET'
'https://app.netlas.io/api/responses/?q=ftp.banner%3A%22Collado%22&source_type=include&start=0&fields=*'
-H 'accept: application/json'
-H 'X-API-Key: YOUR_API_KEY' | jq .items[].data.uri
**कोड उदाहरण (Netlas Python लाइब्रेरी)**
कमांड लाइन में चलाएं:```bash
python scripts/osint/ftp_banner_search.py
scripts/osint/ftp_banner_search.py का स्रोत कोड:```python import netlas
apikey = "YOUR_API_KEY"
netlas_connection = netlas.Netlas(api_key=apikey)
ftp.banner:"Collado"netlas_query = netlas_connection.query(query='ftp.banner:"Collado"')
for response in netlas_query['items']: print (response['data']['ip']) print (response['data']['uri']) print (response['data']['ftp']['banner'])
### SSL प्रमाणपत्रों में संपर्क जानकारी खोजें
SSL प्रमाणपत्र एक डिजिटल प्रमाणपत्र है जो किसी वेबसाइट को प्रमाणित करता है और एन्क्रिप्टेड कनेक्शन के उपयोग की अनुमति देता है। इसमें इसके मालिक के बारे में जानकारी हो सकती है: संपर्क व्यक्ति का नाम, संगठन का नाम, देश और कभी-कभी पता और पिन कोड भी। आप निम्नलिखित फ़िल्टर (और कई अन्य) का उपयोग करके इस जानकारी को खोज सकते हैं:
- `certificate.issuer.email_address`
- `certificate.issuer.given_name`
- `certificate.issuer.organization`
- `certificate.issuer.postal_code`
- `certificate.issuer.street_address`
- `certificate.issuer.surname`
आइए उन IP पतों को खोजने का प्रयास करें जिनके प्रमाणपत्र में सड़क के पते में एक निश्चित शब्द है:```
certificate.issuer.street_address:*mcgill*
API अनुरोध उदाहरण
Netlas CLI उपकरण:```bash netlas search "certificate.issuer.street_address:mcgill" -f json
Curl:```bash
curl -X 'GET' \
'https://app.netlas.io/api/responses/?q=certificate.issuer.street_address%3A*mcgill*&source_type=include&start=0&fields=*' \
-H 'accept: application/json' \
-H 'X-API-Key: YOUR_API_KEY' jq .items[].data.uri
कोड उदाहरण (Netlas Python Library)
कमांड लाइन में चलाएँ:```bash python scripts/osint/certificates_search.py
scripts/osint/certificates_search.py का स्रोत कोड:```python
import netlas
apikey = "YOUR_API_KEY"
# create new connection to Netlas
netlas_connection = netlas.Netlas(api_key=apikey)
# retrieve data from responses by query `certificate.issuer.street_address:*mcgill*`
netlas_query = netlas_connection.query(query="certificate.issuer.street_address:*mcgill*")
print (type(netlas_query))
# iterate over data and print: ip, url, cetificate issuer
for response in netlas_query['items']:
print (response['data']['uri'])
print (response['data']['certificate']['issuer'])
Archive.org का उपयोग OSINT विशेषज्ञों द्वारा वेबसाइटों और सोशल मीडिया प्रोफाइल पेजों के पुराने संस्करणों को खोजने के लिए किया जाता रहा है, ताकि अब हटाए गए संपर्क और अन्य जानकारी खोजी जा सके।
लेकिन, दुर्भाग्य से, archive.org सभी साइटों की प्रतियां सहेजता नहीं है और ऐसा बहुत बार नहीं करता (कुछ साइटों के लिए साल में केवल एक-दो बार या उससे भी कम)।
लेकिन Netlas 2021 से भी साइटों के पुराने संस्करण सहेज रहा है!
साइटों की खोज के लिए अक्सर निम्नलिखित फिल्टर का उपयोग किया जाता है:``` http.title:"github.com"
domain:github.com
host:github.com
यदि आप खोज क्वेरी दर्ज करने के लिए फ़ील्ड के ठीक बगल में दाईं ओर सबसे बाहरी आइकन पर क्लिक करते हैं, तो आपको स्कैन तिथि चुनने के लिए एक मेनू दिखाई देगा। आप इसका उपयोग किसी विशिष्ट तिथि पर सहेजी गई साइटों के html कोड को फ़िल्टर करने के लिए कर सकते हैं।
यह देखने के लिए कि साइट कैसी दिखती है, किसी भी टेक्स्ट एडिटर में "body" फ़ील्ड (response टैब) की सामग्री कॉपी करें और html कोड से \t\r\n वर्ण हटा दें।
उसके बाद, कोड को किसी ऑनलाइन html व्यूअर में कॉपी करें, जैसे [Code beautify](https://codebeautify.org/htmlviewer)। या बस फ़ाइल को html प्रारूप में सहेजें और फिर इसे ब्राउज़र में खोलें।
### संबंधित वेबसाइटें खोजने के 9 तरीके
किसी व्यक्ति या कंपनी के बारे में जानकारी एकत्र करते समय, उनसे किसी तरह संबंधित अधिक से अधिक साइटों को ढूंढना महत्वपूर्ण हो सकता है। Netlas के साथ ऐसा करने के कम से कम 5 तरीके हैं।
1. विभिन्न सेवाओं (एनालिटिक्स, विज्ञापन प्रणाली, सोशल नेटवर्क और प्रकाशन प्रणालियों के साथ एकीकरण के लिए एप्लिकेशन) के लिए ID। उनका ओवरलैप यह संकेत दे सकता है कि एक ही व्यक्ति या टीम शामिल थी। कुछ उदाहरण:
Google Analytics:```
http.tracker.google_analytics:"G-X82FSVSMTV"
गूगल टैग प्रबंधक:``` http.tracker.google_analytics:"GTM-N6462KFQ"
AddThis:```
http.body:"AT-ra-500bcd681b192302"
Facebook पिक्सेल:``` http.tracker.facebook_pixel:317853189093681
Yandex Metrika```
http.tracker.yandex_metrica:89723437
Amazon प्रकाशक सेवाएँ:``` http.body:APS-XXXX
हाँ, यह सब कुछ कुछ साइटों के कोड में पाया जाता है।
और कई अन्य पहचानकर्ता जो अक्सर html कोड के शीर्ष पर पाए जा सकते हैं (लेकिन कभी-कभी पूरे कोड में)।
[Try in Netlas](https://nt.ls/BCrw9)
2. सहबद्ध कार्यक्रमों की आईडी (इसे खोजने के लिए http.body का भी उपयोग करें)। आप उन्हें सहबद्ध लिंक में पा सकते हैं जो कोई व्यक्ति अन्य साइटों या सोशल नेटवर्क पर प्रकाशित करता है। ये निम्नलिखित URL पैरामीटर (और उनके जैसे) हो सकते हैं:```
aff_fcid=
user_id=
partner_id=
ref_id=
```
"GitHub, Inc."
[Netlas में आज़माएं](https://app.netlas.io/whois_domains/?q=%22GitHub%2C%20Inc.%22&page=1&indices=)
4. DNS Netlas खोज में मेल सर्वर द्वारा खोजें
```
mx:*.parklogic.com
```
ns:ns?.parklogic.com
[Try in Netlas](https://app.netlas.io/domains/?q=mx%3A*.parklogic.com&page=1&indices=)
6. फ़ाइलें (मुख्य रूप से उपयोगकर्ता लोगो और अवतार) के उल्लेख खोजें [->](https://github.com/netlas-io/netlas-cookbook#search-file-mentions-looking-for-content-that-may-be-infringing-on-copyrights)
7. सबडोमेन खोजें [->](https://github.com/netlas-io/netlas-cookbook#search-subdomains)
8. Whois संपर्क खोजें (Netlas प्रतिक्रिया खोज में) [->](https://github.com/netlas-io/netlas-cookbook#search-persons-nickname-or-email-in-whois-contacts)
9. फ़ेविकॉन खोजें [->](https://github.com/netlas-io/netlas-cookbook#favicon-search)
## स्क्रैपिंग (वेब पेज बॉडी से डेटा निकालना)
Netlas API संपर्क और अन्य वेबसाइट डेटा एकत्र करने के लिए एक बेहतरीन उपकरण है। सबसे पहले, यह आपको जल्दी से ऐसा करने की अनुमति देता है। दूसरा, इसमें प्रॉक्सी का उपयोग करने की आवश्यकता नहीं है। तीसरा, यह आपको उन साइटों से डेटा एकत्र करने की अनुमति देता है जो वर्तमान में अनुपलब्ध हैं।
हालाँकि, कुछ कमियाँ हैं: Netlas केवल साइटों के मुख्य पृष्ठों को स्कैन करता है और कुछ दुर्लभ साइटें सुरक्षा के कारण इसके डेटाबेस में शामिल नहीं होती हैं। लेकिन फिर भी यह बहुत उपयोगी हो सकता है।
स्क्रैपिंग के तीन मुख्य दृष्टिकोण हैं: html टैग और CSS चयनकर्ताओं से जानकारी एकत्र करना, नियमित अभिव्यक्तियों का उपयोग करके डेटा निकालना, और AI स्क्रैपिंग। आइए पहले दो पर करीब से नज़र डालें।
### Beatifulsoup पैकेज
[Beatifulsoup](https://pypi.org/project/beautifulsoup4/) HTML कोड और XML फ़ाइलों को पार्स करने के लिए दुनिया के सबसे लोकप्रिय Python पैकेजों में से एक है। आइए इसे पृष्ठ शीर्षक ( \<h1> टैग से, \<title> टैग से नहीं) निकालने के लिए उपयोग करने का प्रयास करें।
सबसे पहले, पैकेज इंस्टॉल करें:```bash
pip install beautifulsoup4
और चलाएँ scripts/osint/scraping_beatifulsoup.py:```bash python scripts/osint/scraping_beatifulsoup.py
स्रोत कोड scripts/osint/scraping_beatifulsoup.py:```python
import netlas
from bs4 import BeautifulSoup
apikey = "YOUR_API_KEY"
# create new connection to Netlas
netlas_connection = netlas.Netlas(api_key=apikey)
# retrieve data from responses by query `http.body:shop`
netlas_query = netlas_connection.query(query="http.body:shop")
# iterate over data and print: URL, h1 tags from body
for response in netlas_query['items']:
print (response['data']['uri'])
soup = BeautifulSoup(response['data']['http']['body'], "html.parser")
try:
print(soup.find("h1").get_text())
except Exception:
print("no h1 tags")
pass
आप वेब पेजों के अन्य तत्वों से डेटा इसी प्रकार निकाल सकते हैं:``` soup.find("h3").get_text() soup.find("id='loginform'").get_text() soup.find("class='forms'").get_text() soup.find("href='https://example.com'").get_text()
यदि आप किसी विशेष प्रकार के सभी तत्वों को खोजना चाहते हैं तो `find_all()` विधि का उपयोग करें।
### Re पैकेज
[Re](https://docs.python.org/3/library/re.html) एक पूर्व-स्थापित Python पैकेज है जो रेगुलर एक्सप्रेशन का उपयोग करके डेटा खोजने और पुनर्प्राप्त करने के लिए है। यह वेब पेजों से संपर्क जानकारी निकालने और कई अन्य कार्यों के लिए उपयोगी है। आइए देखें कि यह कैसे काम करता है इसका एक उदाहरण।
`scripts/osint/scraping_re.py` चलाएँ:```bash
python scripts/osint/scraping_re.py
स्क्रिप्ट/osint/scraping_re.py का स्रोत कोड:```python import netlas import re
apikey = "YOUR_API_KEY"
netlas_connection = netlas.Netlas(api_key=apikey)
http.body:shopnetlas_query = netlas_connection.query(query="http.body:shop")
for response in netlas_query['items']: print (response['data']['uri']) emails = re.findall("[a-zA-Z0-9-.]+@[a-zA-Z0-9-.]+", response['data']['http']['body']) try: print(emails) except Exception: print("no emails") pass
इसी तरह, आप लिंक, फ़ोन नंबर, क्रिप्टोकरेंसी वॉलेट पते और भी बहुत कुछ निकाल सकते हैं। तैयार पैटर्न रेगुलर एक्सप्रेशन लाइब्रेरीज़ में पाए जा सकते हैं:
[Regex Lib](https://regexlib.com/)
[UI Bakery Regex Library](https://uibakery.io/regex-library)
[Regex 101](https://regex101.com/)
### स्क्रैपिंग के लिए अन्य Python पैकेज
Beaitiful soup और Re पैकेज Python का उपयोग करके वेब पेजों से डेटा स्क्रैप करने के कई टूल में से सिर्फ एक हैं। यहां ऐसे पैकेजों के कुछ और उदाहरण दिए गए हैं:
* [Scrapy](https://pypi.org/project/Scrapy/): यह मुख्य रूप से एक क्रॉलर (अन्य पृष्ठों पर मिले लिंक का उपयोग करके वेबसाइट पृष्ठों को ट्रैवर्स करने का एक उपकरण) है और इसके अलावा, इसमें वेब पृष्ठों से डेटा निकालने की व्यापक क्षमताएं हैं।
* [Selenium](https://pypi.org/project/selenium/): आपके ब्राउज़र अनुभव को स्वचालित करने का एक उपकरण। आपको JavaScript द्वारा उत्पन्न सामग्री से डेटा निकालने की अनुमति देता है।
* [Lxml](https://pypi.org/project/lxml/): XML फ़ाइलों को स्क्रैप और मान्य करने का उपकरण।
* [PDFtoText](https://pypi.org/project/pdftotext/) - PDF फ़ाइलों से टेक्स्ट सामग्री निकालने का उपकरण।
* [pyChatGPT](https://pypi.org/project/pyChatGPT/) - CHATGP के साथ इंटरैक्शन के लिए अनौपचारिक पैकेज (OpenAI API कुंजी की आवश्यकता नहीं है), जो AI के साथ टेक्स्ट जानकारी का विश्लेषण करने की अनुमति देता है।
## क्रिप्टो जांच के लिए Netlas.io का उपयोग करना
Netlas क्रिप्टोकरेंसी अपराध में विशेषज्ञता रखने वाले शोधकर्ताओं के लिए एक शानदार अवसर प्रदान करता है। सबसे पहले, इसका उपयोग वॉलेट पतों और लेन-देन संख्याओं के संदर्भ खोजने के लिए किया जा सकता है। दूसरा, इसका उपयोग कमजोर माइनिंग फार्म, नोड्स और क्रिप्टो बुनियादी ढांचे से जुड़े अन्य सर्वरों की खोज के लिए किया जा सकता है।
### माइनिंग फार्म खोजें
Antminer माइनिंग फार्म, जो पहली बार 2013 में Bitmain द्वारा जारी किए गए थे, दुनिया में माइनिंग फार्म मॉडल की सबसे लोकप्रिय श्रृंखला में से एक हैं। आप उन्हें www_authenticate हेडर में "antMiner" शब्द की उपस्थिति से ढूंढ सकते हैं।```
http.headers.www_authenticate:antMiner
आप अन्य प्रकार के माइनिंग फार्मों की भी खोज कर सकते हैं। उदाहरण के लिए:``` http.headers.www_authenticate:XMR-Stak-Miner
विभिन्न फिल्टरों को संयोजित करके प्रयोग करें, "माइनर/माइनिंग" शब्द और क्रिप्टोकरेंसी नाम।
**API अनुरोध उदाहरण**
Netlas CLI Tools:```bash
netlas search "http.headers.www_authenticate:antMiner"
Curl:```bash
curl -X 'GET'
'https://app.netlas.io/api/responses/?q=http.headers.www_authenticate%3AantMiner&source_type=include&start=0&fields=*'
-H 'accept: application/json'
-H 'X-API-Key: 'YOUR_API_KEY' | jq .items[].data.uri
**कोड उदाहरण (Netlas Python लाइब्रेरी)**
कमांड लाइन में चलाएँ:```bash
python scripts/crypto/mining_farms_search.py
scripts/crypto/mining_farms_search.py का स्रोत कोड:```python import netlas
apikey = "YOUR_API_KEY"
netlas_connection = netlas.Netlas(api_key=apikey)
http.headers.www_authenticate:antMinernetlas_query = netlas_connection.query(query='http.headers.www_authenticate:antMiner')
for response in netlas_query['items']: print (response['data']['uri']) print (response['data']['http']['headers'])
### क्रिप्टोमाइनर्स से संक्रमित वेबसाइटों की खोज करें
Coinhive, एक सेवा जो वेबसाइटों (अधिकतर हैक की गई) को अपने आगंतुकों के कंप्यूटर का उपयोग करके क्रिप्टोकरेंसी माइन करने की अनुमति देती है, 2019 में बंद हो रही है। लेकिन फिर भी, इसके लिंक अभी भी दुनिया भर की कई साइटों में एम्बेडेड हैं। आइए उन्हें खोजने का प्रयास करें:```
http.body:coinhive.min.js domain:*
ध्यान दें कि हम विशेष रूप से साइटों को खोजने के लिए domain:* फ़िल्टर का उपयोग करते हैं, सभी उपकरणों का नहीं।
इसी प्रकार, आप अन्य क्रिप्टोमाइनर्स (साथ ही उपयोगकर्ता की ओर से निष्पादित होने वाले अन्य दुर्भावनापूर्ण कोड) से संक्रमित साइटों की खोज कर सकते हैं।
API अनुरोध उदाहरण
Netlas CLI Tools:```bash netlas search "http.body:coinhive.min.js domain:*"
Curl:```bash
curl -X 'GET' \
'https://app.netlas.io/api/responses/?q=http.body%3Acoinhive.min.js%20domain%3A*&source_type=include&start=0&fields=*' \
-H 'accept: application/json' \
-H 'X-API-Key: 'YOUR_API_KEY' | jq .items[].data.uri
कोड उदाहरण (Netlas Python लाइब्रेरी)
कमांड लाइन में चलाएँ:```bash python scripts/crypto/search_sites_injected_with_miners.py
स्रोत कोड:```python
import netlas
apikey = "YOUR_API_KEY"
# create new connection to Netlas
netlas_connection = netlas.Netlas(api_key=apikey)
# retrieve data from responses by query `http.body:coinhive.min.js domain:*`
netlas_query = netlas_connection.query(query='http.body:coinhive.min.js domain:*')
# iterate over data and print: uri
for response in netlas_query['items']:
print (response['data']['uri'])
बिटकॉइन नोड्स TCP कनेक्शन के लिए पोर्ट 8333 का उपयोग करते हैं। इसलिए, "port:" खोज फ़िल्टर का उपयोग करके उन्हें ढूंढना आसान है।``` port:8333 cve:*
ध्यान दें कि हम भेद्यता वाले सर्वरों की खोज के लिए "cve:*" फ़िल्टर का उपयोग करते हैं।
**API अनुरोध उदाहरण**
Netlas CLI Tools:```bash
netlas search "port:8333 cve:*"
Curl:```bash
curl -X 'GET'
'https://app.netlas.io/api/responses/?q=port%3A8333%20cve%3A*&source_type=include&start=0&fields=*'
-H 'accept: application/json'
-H 'X-API-Key: 'YOUR_API_KEY' | jq .items[].data.uri
**कोड उदाहरण (Netlas Python Library)**
कमांड लाइन में चलाएँ:```bash
python scripts/crypto/search_bitcoin_nodes.py
scripts/crypto/search_bitcoin_nodes.py का स्रोत कोड:```python import netlas
apikey = "YOUR_API_KEY"
netlas_connection = netlas.Netlas(api_key=apikey)
port:8333 cve:*netlas_query = netlas_connection.query(query='port:8333 cve:*')
for response in netlas_query['items']: print (response['data']['uri']) print (response['data']['cve'][0]['name']) print (response['data']['cve'][0]['description'])
## पेंटेस्ट के लिए Neltas का उपयोग
Netlas.io आपको विभिन्न प्रकार की कमजोरियों वाली साइटों की खोज करने की अनुमति देता है। यह कमजोरी संख्या (CVE-...), सर्वर पर स्थापित सॉफ्टवेयर का नाम, पेज हेडर में कुछ शब्दों और अन्य मापदंडों द्वारा किया जा सकता है।
आप इन साइटों पर हाल ही में प्रकाशित CVEs (Common Vulnerabilities and Exposures) को ट्रैक कर सकते हैं:
* [CVE Details](https://www.cvedetails.com/)
* [VulDB](https://vuldb.com/)
* [OpenCVE](https://www.opencve.io/)
हम अपने [Twitter](https://twitter.com/Netlas_io), [Telegram](https://t.me/netlas) और [Discord](https://nt.ls/discord) फीड्स के साथ-साथ [Netlas Dorks](https://github.com/netlas-io/netlas-dorks) Github रिपॉजिटरी पर भी कमजोर उपकरणों और सॉफ्टवेयर की खोज के लिए सबसे प्रासंगिक क्वेरी नियमित रूप से पोस्ट करते हैं।
इस अनुभाग में, हम कमजोरियों वाली साइटों और सर्वरों की खोज के सामान्य सिद्धांतों को कवर करेंगे।
### उपडोमेन खोज
खोज क्वेरी में तारांकन चिह्नों का उपयोग करके, आप विभिन्न स्तरों के सभी उपडोमेन (जिनका नाम किसी विशेष प्रथम-स्तरीय डोमेन (.com) या द्वितीय-स्तरीय डोमेन (google.com) के नाम पर समाप्त होता है) पा सकते हैं।
**खोज क्वेरी उदाहरण**
```
domain:*.github.com OR host:*.github.com
API अनुरोध उदाहरण
नेटलास CLI उपकरण:```bash netlas search "domain:.github.com OR host:.github.com" -f json
Curl:```bash
curl -X 'GET' \
'https://app.netlas.io/api/responses/?q=domain%3A*.github.com%20OR%20host%3A*.github.com&source_type=include&start=0&fields=*' \
-H 'accept: application/json' \
-H 'X-API-Key: YOUR_API_KEY' | jq .items[].data.uri
कोड उदाहरण (Netlas Python Library)
कमांड लाइन में चलाएँ:```bash python scripts/pentest/subdomain_search.py
scripts/pentest/subdomain_search.py का स्रोत कोड:```python
import netlas
apikey = "YOUR_API_KEY"
# create new connection to Netlas
netlas_connection = netlas.Netlas(api_key=apikey)
# retrieve data from responses by query `domain:*.github.com OR host:*.github.com`
netlas_query = netlas_connection.query(query="domain:*.github.com OR host:*.github.com")
# iterate over data and print: ip, url
for response in netlas_query['items']:
print (response['data']['ip'])
print (response['data']['uri'])
खोज क्वेरी उदाहरण
```
cve.name:CVE-2022-22965
[नेटलास में आज़माएं](https://app.netlas.io/responses/?q=cve.name%3ACVE-2022-22965&page=1&indices=)
**API अनुरोध उदाहरण**
नेटलास CLI उपकरण:```bash
netlas search "cve.name:CVE-2022-22965" -f json
CVE-2022-22965 - Spring MVC या Spring WebFlux एप्लिकेशन जो JDK 9+ पर चल रहा है, डेटा बाइंडिंग के माध्यम से रिमोट कोड निष्पादन (RCE) के लिए संवेदनशील हो सकता है। विवरण
Curl:```bash
curl -X 'GET'
'https://app.netlas.io/api/responses/?q=http.body%3A1%3F234%3F567%3F89%3F99%20OR%20http.body%3A12345678999%20OR%20http.body%3A1234%3F5678%3F999&source_type=include&start=0&fields=*'
-H 'accept: application/json'
-H 'X-API-Key: YOUR_API_KEY' jq .items[].data.uri
**कोड उदाहरण (Netlas Python Library)**
कमांड लाइन में चलाएँ:```bash
python scripts/pentest/cve_search.py
scripts/pentest/cve_search.py का स्रोत कोड:```python import netlas
apikey = "YOUR_API_KEY"
netlas_connection = netlas.Netlas(api_key=apikey)
cve.name:CVE-2022-22965netlas_query = netlas_connection.query(query="cve.name:CVE-2022-22965")
for response in netlas_query['items']: print (response['data']['ip']) print (response['data']['uri'])
### उन साइट्स की खोज करें जिनमें कमजोरियाँ हैं और जिनके विवरण में एक निश्चित शब्द शामिल है
यदि आपको किसी विशिष्ट प्रकार की कमजोरी वाले सर्वरों की जांच करने की आवश्यकता नहीं है, बल्कि केवल किसी विशेष समूह (जैसे Oracle WebLogic Server या WordPress साइट्स) में कमजोर सर्वर देखना चाहते हैं, तो आप कीवर्ड और cve.description: फ़िल्टर का उपयोग करके उन्हें खोज सकते हैं।
कमजोरियों के लिए प्रकाशित एक्सप्लॉइट वाली साइट्स को फ़िल्टर करने के लिए, cve.has_exploit:true का उपयोग करें।
**खोज क्वेरी उदाहरण**
```
cve.description:weblogic AND cve.has_exploit:true
API अनुरोध उदाहरण
Netlas CLI Tools:```bash netlas search "cve.description:weblogic AND cve.has_exploit:true" -f json
Curl:
``````bash
curl -X 'GET' \
'https://app.netlas.io/api/responses/?q=cve.description%3Aweblogic%20AND%20cve.has_exploit%3Atrue&source_type=include&start=0&fields=*' \
-H 'accept: application/json' \
-H 'X-API-Key: YOUR_API_KEY | jq .items[].data.uri
कोड उदाहरण (Netlas Python Library)
कमांड लाइन में चलाएँ:```bash python scripts/pentest/cve_description_search.py
scripts/pentest/cve_description_search.py का स्रोत कोड:```python
import netlas
apikey = "YOUR_API_KEY"
# create new connection to Netlas
netlas_connection = netlas.Netlas(api_key=apikey)
# retrieve data from responses by query `cve.description:weblogic AND cve.has_exploit:true`
netlas_query = netlas_connection.query(query="cve.description:weblogic AND cve.has_exploit:true")
# iterate over data and print: url, first CVE name first CVE description
for response in netlas_query['items']:
print (response['data']['uri'])
print (response['data']['cve'][0]['name'])
print (response['data']['cve'][0]['description'])
यह विधि आपको किसी विशिष्ट कंपनी द्वारा निर्मित उपकरणों को खोजने की अनुमति देती है।
खोज क्वेरी उदाहरण
```
http.headers.server:"yawcam"
YawCam वेब कैमरों की खोज करें।
[Netlas में आज़माएं](https://app.netlas.io/responses/?q=http.headers.server%3A%22yawcam%22&page=1&indices=)
**API अनुरोध उदाहरण**
Netlas CLI उपकरण:```bash
netlas search 'http.headers.server:"yawcam"' -f json
ध्यान दें कि जब प्रश्नों में डबल कोट्स का उपयोग किया जाता है, तो क्वेरी स्वयं सिंगल कोट्स के अंदर लिखी जाती है।
Curl:```bash
curl -X 'GET'
'https://app.netlas.io/api/responses/?q=http.headers.server%3A%22yawcam%22&source_type=include&start=0&fields=*'
-H 'accept: application/json'
-H 'X-API-Key: YOUR_API_KEY' | jq .items[].data.uri
**कोड उदाहरण (Netlas Python लाइब्रेरी)**
कमांड लाइन में चलाएँ:```bash
python scripts/pentest/server_name_search.py
scripts/pentest/server_name_search.py का स्रोत कोड:```python import netlas
apikey = "YOUR_API_KEY"
netlas_connection = netlas.Netlas(api_key=apikey)
http.headers.server:"yawcam"netlas_query = netlas_connection.query(query='http.headers.server:"yawcam"')
for response in netlas_query['items']: print (response['data']['ip']) print (response['data']['http']['headers']['server'])
#### डिफ़ॉल्ट लॉगिन और पासवर्ड <!-- omit in toc -->
सर्वर हेडर में सॉफ़्टवेयर नाम से खोज करने का एक व्यावहारिक अनुप्रयोग किसी विशेष विक्रेता के उपकरणों की खोज करना है। यह तब आवश्यक हो सकता है जब विशिष्ट कमजोरियों वाले उपकरणों की खोज की जाए और साथ ही मानक लॉगिन और पासवर्ड वाले उपकरणों की भी खोज की जाए।
विभिन्न डिवाइस मॉडलों के मानक लॉगिन और पासवर्ड विशेष सूचियों में पाए जा सकते हैं। उदाहरण के लिए:
* [शीर्ष राउटर मॉडलों के लिए डिफ़ॉल्ट राउटर लॉगिन पासवर्ड (2023 सूची)](https://www.softwaretestinghelp.com/default-router-username-and-password-list/)
* [सुरक्षा कैमरों के लिए डिफ़ॉल्ट उपयोगकर्ता नाम – पासवर्ड – आईपी पता](https://www.a1securitycameras.com/blog/default-username-passwords-ip-addresses-for-surveillance-cameras/)
* [लगभग हर आईपी कैमरे के डिफ़ॉल्ट पासवर्ड](https://www.hackers-arise.com/post/the-default-passwords-of-nearly-every-ip-camera)
* [डेटारिकवरी से डिफ़ॉल्ट पासवर्ड की सूची](https://datarecovery.com/rd/default-passwords/)
याद रखें कि दूसरों के सिस्टम में लॉग इन करने के लिए मानक लॉगिन और पासवर्ड का उपयोग करना नैतिकता नियमों का उल्लंघन करता है और आपके देश में अवैध हो सकता है।
### फ़ेविकॉन हैश द्वारा कमजोर सर्वरों की खोज करें
किसी विशेष वेब सर्वर सॉफ़्टवेयर के फ़ेविकॉन आइको की खोज करके किसी विशेष कमजोरी के संपर्क में आने वाले वेब सर्वरों को खोजने का एक तरीका है।
**खोज क्वेरी उदाहरण**
```
http.favicon.hash_sha256:ebaaed8ab7c21856f888117edaf342f6bc10335106ed907f95787b69878d9d9e
यह क्वेरी SecurePoint फ़ेविकॉन (CVE-2023-22620) को खोजती है।
API अनुरोध उदाहरण
Netlas CLI उपकरण:```bash netlas search "http.favicon.hash_sha256:ebaaed8ab7c21856f888117edaf342f6bc10335106ed907f95787b69878d9d9e" -f json
Curl:```bash
curl -X 'GET' \
'https://app.netlas.io/api/responses/?q=http.favicon.hash_sha256%3Aebaaed8ab7c21856f888117edaf342f6bc10335106ed907f95787b69878d9d9e&source_type=include&start=0&fields=*' \
-H 'accept: application/json' \
-H 'X-API-Key: YOUR_API_KEY' | jq .items[].data.uri
कोड उदाहरण (Netlas Python Library)
कमांड लाइन में चलाएँ:```bash python scripts/pentest/favicon_hash_search.py
scripts/pentest/favicon_hash_search.py का स्रोत कोड:```python
import netlas
apikey = "YOUR_API_KEY"
# create new connection to Netlas
netlas_connection = netlas.Netlas(api_key=apikey)
# retrieve data from responses by query `http.favicon.hash_sha256:ebaaed8ab7c21856f888117edaf342f6bc10335106ed907f95787b69878d9d9e`
netlas_query = netlas_connection.query(query="http.favicon.hash_sha256:ebaaed8ab7c21856f888117edaf342f6bc10335106ed907f95787b69878d9d9e")
# iterate over data and print: IP,URL,web page title
for response in netlas_query['items']:
print (response['data']['ip'])
print (response['data']['uri'])
print (response['data']['http']['title'])
विभिन्न सॉफ्टवेयर चलाने वाले सर्वरों में खोज को सरल बनाने के लिए, Netlas स्वचालित रूप से खोज परिणामों को विशिष्ट टैग से टैग करता है।
टैग के उदाहरण:
आप "tag.name:" फ़िल्टर का उपयोग करके टैग द्वारा खोज सकते हैं। आप "tag.category:" फ़िल्टर का उपयोग करके टैग श्रेणी द्वारा भी खोज सकते हैं। Netlas होमपेज पर खोज क्वेरी प्रविष्टि बॉक्स के दाईं ओर आइकन पर क्लिक करने पर सभी उपलब्ध टैग और श्रेणियों की एक सूची प्रदर्शित होती है।
नोट: सभी मूल्य निर्धारण योजनाएं टैग के उपयोग का समर्थन नहीं करती हैं।
खोज क्वेरी उदाहरण
```
tag.name:"adobe_coldfusion"
यह क्वेरी Adobe ColdFusion (CVE-2023-26359) को खोजती है।
[Try in Netlas](https://app.netlas.io/responses/?q=tag.name%3A%22adobe_coldfusion%22&page=1&indices=)
**API अनुरोध उदाहरण**
Netlas CLI उपकरण:```bash
netlas search 'tag.name:"adobe_coldfusion"' -f json
ध्यान दें कि जब क्वेरी में डबल कोट्स का उपयोग किया जाता है, तो क्वेरी स्वयं सिंगल कोट्स के अंदर लिखी जाती है।
Curl:```bash
curl -X 'GET'
'https://app.netlas.io/api/responses/?q=tag.name%3A%22adobe_coldfusion%22&source_type=include&start=0&fields=*'
-H 'accept: application/json'
-H 'X-API-Key: YOUR_API_KEY' | jq .items[].data.uri
**कोड उदाहरण (Netlas Python Library)**
कमांड लाइन में चलाएँ:```bash
python scripts/pentest/search_tag_name.py
scripts/pentest/search_tag_name.py का स्रोत कोड:```python import netlas
apikey = "YOUR_API_KEY"
netlas_connection = netlas.Netlas(api_key=apikey)
tag.name:"adobe_coldfusion"netlas_query = netlas_connection.query(query='tag.name:"adobe_coldfusion"')
for response in netlas_query['items']: print (response['data']['ip']) print (response['data']['uri'])
### अपने आस-पास (या किसी अन्य स्थान पर) संवेदनशील सर्वर और उपकरणों की खोज करें
क्या आप जानना चाहते हैं कि आपके आस-पास कितनी संवेदनशील साइटें और उपकरण हैं? बस उन सभी IP पतों की खोज करें जिनमें किसी विशिष्ट भौगोलिक स्थान में CVE फ़ील्ड भरी हुई है।```
geo.city:London AND cve:*
आप अन्य भू-स्थान फ़िल्टर का भी उपयोग कर सकते हैं।
geo.continentgeo.countrygeo.locationAPI अनुरोध उदाहरण
Netlas CLI उपकरण:``` geo.city:London AND cve:*
Curl:```bash
curl -X 'GET' \
'https://app.netlas.io/api/responses/?q=geo.city%3ALondon%20AND%20cve%3A*&source_type=include&start=0&fields=*' \
-H 'accept: application/json' \
-H 'X-API-Key: 'YOUR_API_KEY' | jq .items[].data.domain
कोड उदाहरण (Netlas Python Library)
कमांड लाइन में चलाएँ:```bash python scripts/pentest/cve_location_search.py
स्रोत कोड scripts/pentest/cve_location_search.py:```python
import netlas
apikey = "YOUR_API_KEY"
# create new connection to Netlas
netlas_connection = netlas.Netlas(api_key=apikey)
# retrieve data from responses by query `geo.city:London AND cve:*`
netlas_query = netlas_connection.query(query='geo.city:London AND cve:*')
# iterate over data and print: uri, cve name, location
for response in netlas_query['items']:
print (response['data']['uri'])
print (response['data']['cve'][0]['name'])
print (response['data']['geo']['city'])
कई साइटों और सर्वरों में लॉगिन और पासवर्ड वेब पेज होते हैं जिनका उपयोग साइट या सर्वर पर पूर्ण नियंत्रण प्राप्त करने के लिए किया जा सकता है (डिफ़ॉल्ट पासवर्ड, ब्रूटफोर्स, या कमजोरियों के शोषण के माध्यम से)।
आप इन्हें uri: और/या http.title फ़िल्टर का उपयोग करके पा सकते हैं:```
uri:login.php
uri:login.aspx
uri:user http.title:login
uri:admin http.title:login
http.title:admin http.title:panel
इतने सारे संयोजन हैं। केवल कमजोर सर्वरों के पैनल खोजने के लिए फ़िल्टर `cve:*` का उपयोग करें।
साथ ही, यह न भूलें कि आप टैग का उपयोग करके इंस्टॉल किए गए सॉफ़्टवेयर द्वारा सर्वरों को फ़िल्टर कर सकते हैं। उदाहरण के लिए:```
tag.1c_bitrix:*
tag.Cisco:
tag.amazon_s3:*
tag.drupal:*
tag.wordpress:*
आइए कमजोर phpMyAdmin एडमिन पैनल खोजने का प्रयास करें (MySQL डेटाबेस प्रबंधन के लिए सबसे लोकप्रिय सॉफ़्टवेयर में से एक):``` http.title:phpMyAdmin cve:*
और यहाँ अन्य लोकप्रिय डेटाबेस प्रशासन उपकरणों के कुछ उदाहरण हैं:
[Adminer](https://www.adminer.org/):```
http.title:adminer http.title:login cve:*
PostgreSQL``` http.title:(phpPgAdmin OR pgadmin) cve:*
आप विभिन्न डेटाबेसों के लिए स्थापित सॉफ़्टवेयर वाले सर्वरों को टैग या विशेष फ़िल्टर का उपयोग करके भी खोज सकते हैं:```
tag.adminer:*
tag.phpMyAdmin:*
tag.elastic:*
mongodb:*
mssql:*
mysql:*
django:*
इस तरह से मिलने वाले सर्वरों के एडमिन पैनल खोजना सबसे आसान काम नहीं हो सकता, क्योंकि साइट प्रशासक अक्सर मानक लिंक को अधिक सुरक्षित लिंक में बदल देते हैं।
SQL इंजेक्शन एक प्रकार की कमजोरी है जो URL पैरामीटर में हेरफेर करके डेटाबेस क्वेरी करने की अनुमति देती है (यह गलत कॉन्फ़िगरेशन और खराब गुणवत्ता वाले कोड के कारण संभव हो सकता है)।
SQL इंजेक्शन के प्रति संभावित रूप से संवेदनशील पृष्ठों को खोजने की सबसे पुरानी तकनीकों में से एक है Google Dorks का उपयोग करके उन पृष्ठों को खोजना जिनमें MySQL क्वेरी में त्रुटि संदेश प्रदर्शन सक्षम है।
Netlas में भी ऐसी ही खोज की जा सकती है:``` http.body:mysql_fetch_array http.body:warning
[Netlas में आज़माएं](https://app.netlas.io/responses/?q=http.body%3Amysql_fetch_array%20http.body%3Awarning&page=1&indices=)
कुछ अन्य उदाहरण:```
http.body:mysql_num_rows http.body:warning
http.body:mysql_connect http.body:denied
http.body:mysql_query http.body:warning