اوسینت یوزرنیم چیست و چطور از یک نام کاربری به ردپای دیجیتال برسیم؟

"""Controlled Sherlock 0.16.0 teaching fixture; no public username searches.

Run in an isolated environment with sherlock-project==0.16.0 installed.
The target catalogue is supplied directly and contains loopback URLs only.
This intentionally incomplete custom rule is NOT an upstream-site defect test.
"""
import hashlib
import importlib.metadata
import inspect
import json
import threading
from datetime import datetime, timezone
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path
from urllib.parse import urlparse

import requests
from sherlock_project.notify import QueryNotify
from sherlock_project.sherlock import sherlock

request_log = []

class Fixture(BaseHTTPRequestHandler):
    def answer(self, body=True):
        if self.path.startswith('/present/'):
            status, text = 200, 'Fictional demonstration profile'
        elif self.path.startswith('/soft-missing/'):
            status, text = 200, 'Profile not found'
        else:
            status, text = 404, 'Profile not found'
        request_log.append({'method': self.command, 'path': self.path, 'status': status})
        data = text.encode()
        self.send_response(status)
        self.send_header('Content-Type', 'text/plain; charset=utf-8')
        self.send_header('Content-Length', str(len(data)))
        self.end_headers()
        if body:
            self.wfile.write(data)
    def do_GET(self): self.answer()
    def do_HEAD(self): self.answer(False)
    def log_message(self, *args): pass

server = ThreadingHTTPServer(('127.0.0.1', 0), Fixture)
thread = threading.Thread(target=server.serve_forever, daemon=True)
thread.start()
origin = 'http://127.0.0.1:' + str(server.server_port)

original_send = requests.Session.send
def local_only(self, request, **kwargs):
    parsed = urlparse(request.url)
    if parsed.scheme != 'http' or parsed.hostname != '127.0.0.1' or parsed.port != server.server_port:
        raise RuntimeError('This lab permits only its own loopback fixture')
    kwargs['proxies'] = {}
    return original_send(self, request, **kwargs)
requests.Session.send = local_only

def rule(path, kind='status_code'):
    return {'urlMain': origin, 'url': origin + '/' + path + '/{}',
            'errorType': kind, 'errorMsg': 'Profile not found'}

catalogue = {
    'present_status': rule('present'),
    'missing_status': rule('missing'),
    'soft_missing_status': rule('soft-missing'),
    'soft_missing_message': rule('soft-missing', 'message'),
}
try:
    results = sherlock('osintjet_fixture_20260907', catalogue, QueryNotify(), timeout=5)
    observed = {key: {'status': row['status'].status.name,
                      'http_status': row['http_status']}
                for key, row in results.items()}
finally:
    requests.Session.send = original_send
    server.shutdown()
    server.server_close()
    thread.join(timeout=5)

expected = {'present_status': 'CLAIMED', 'missing_status': 'AVAILABLE',
            'soft_missing_status': 'CLAIMED', 'soft_missing_message': 'AVAILABLE'}
assert {key: row['status'] for key, row in observed.items()} == expected, observed
source = Path(inspect.getsourcefile(sherlock))
report = {'observed_at': datetime.now(timezone.utc).isoformat(),
          'sherlock_version': importlib.metadata.version('sherlock-project'),
          'library_source_sha256': hashlib.sha256(source.read_bytes()).hexdigest(),
          'scope': 'Four custom rules against three localhost fixtures; no external account lookup',
          'limitation': 'No upstream platform configuration, identity attribution or accuracy benchmark tested',
          'results': observed, 'request_log': request_log, 'assertions_passed': True}
Path(__file__).with_name('sherlock-local-results.json').write_text(json.dumps(report, indent=2), encoding='utf-8')
print(json.dumps(report, indent=2))