## Screenshot

<div align="center">

### Pagina iniziale
<img src="https://assets.kitploit.com/production/public/readmes/7467/e00ec4ba8b3e5460ae1e03360cf6540e58d92acc5522c8693445512b591fed29.png" alt="Pagina dei risultati di SeekYou" width="800" />


### Pagina dei risultati
<img src="https://assets.kitploit.com/production/public/readmes/7467/09b165feca9927ad4cd50c3ebd28c72e09a0355d72b9ca14d795bf1d04448c92.png" alt="Pagina iniziale di SeekYou" width="800" />

### Demo
<a href="https://www.youtube.com/watch?v=b86tAUUqd34">
  <img src="https://assets.kitploit.com/production/public/readmes/7467/8762e8b464816b9a69d929514441f8c7ee9f9ee9719f95b9c5e33ac1672575f8.jpg" alt="Demo di SeekYou" width="800" />
</a>

</div>

---

## Indice

- [SeekYou](#seekyou)
  - [Screenshot](#screenshots)
    - [Pagina iniziale](#landing-page)
    - [Pagina dei risultati](#results-page)
    - [Demo](#demo)
  - [Indice](#table-of-contents)
  - [Cosa fa SeekYou](#what-seekyou-does)
  - [Casi d'uso](#use-cases)
  - [Politica di utilizzo lecito](#lawful-use-policy)
  - [Strumenti correlati](#related-tools)
  - [Panoramica dell'architettura](#architecture-overview)
  - [Modello di esecuzione](#execution-model)
  - [Fonti dei dati](#data-sources)
  - [Struttura del progetto](#project-structure)
  - [Decisioni progettuali chiave](#key-design-decisions)
    - [Edge-first, senza Node.js](#edge-first-no-nodejs)
    - [Esecuzione parallela a strati](#layered-parallel-execution)
    - [Degradazione graduale](#graceful-degradation)
    - [Storage D1 + KV separato](#split-d1--kv-storage)
    - [Ottimizzazione per il piano gratuito](#free-tier-optimization)
    - [Scritture D1 fire-and-forget](#fire-and-forget-d1-writes)
  - [Strategia di caching](#caching-strategy)
  - [Rate limiting](#rate-limiting)
  - [Circuit breaker](#circuit-breakers)
  - [Rotazione delle chiavi — GrayHatWarfare](#key-rotation--grayhatwarfare)
  - [Persistenza D1](#d1-persistence)
    - [Schema (`schema.sql`)](#schema-schemasql)
    - [Applicare lo schema](#apply-schema)
    - [Funzioni helper](#helper-functions)
  - [Worker cron](#cron-worker)
    - [Diff tipizzato (`lib/diff.ts`)](#typed-diff-libdiffts)
    - [Payload del webhook](#webhook-payload)
  - [Configurazione di sviluppo](#development-setup)
    - [Prerequisiti](#prerequisites)
    - [Sviluppo locale](#local-development)
    - [Creare le risorse Cloudflare (prima volta)](#create-cloudflare-resources-first-time)
  - [Distribuzione](#deployment)
    - [Build e deploy](#build-and-deploy)
    - [Configurazione di Wrangler (`wrangler.toml`)](#wrangler-configuration-wranglertoml)
  - [Segreti e variabili d'ambiente](#secrets-and-environment-variables)
    - [Segreti richiesti](#required-secrets)
    - [`.env.example` (solo sviluppo locale)](#envexample-local-dev-only)
  - [Licenza](#license)
  - [Autore](#author)
  - [Ringraziamenti](#acknowledgments)

---

## Cosa fa SeekYou

SeekYou è uno **strumento di intelligence sugli host** — incolla un indirizzo IP, un nome di dominio o un ASN e ottieni un report unificato che copre:

| Categoria | Cosa ottieni |
|---|---|
| Rete | Porte aperte, CPE, prefissi BGP, upstream, peer, RIR |
| Identità | Registrazione RDAP, contatti, registrar, nameserver |
| Geo | Paese, città, ISP, flag proxy / hosting / mobile |
| Certificati | Storico crt.sh, SAN, catena dell'emittente |
| DNS | Record DNS passivi, DNS inverso/diretto di Robtex |
| Minacce | URLhaus, ThreatFox, MalwareBazaar, Feodo, SSLBL |
| CVE | Arricchimento NVD + CIRCL per ogni CVE ID segnalato da InternetDB |
| Ricognizione | Bucket esposti di GrayHatWarfare, snapshot Wayback CDX |

Ogni fonte viene interrogata in parallelo. Una fonte che fallisce degrada a un badge "non disponibile" — non rompe mai la pagina.

---

## Casi d'uso

**Operazioni di sicurezza** — Profila rapidamente IP sospetti dai log, correla gli IOC, identifica servizi esposti e CVE, traccia domini dannosi.

**Operazioni di rete** — Ispeziona il routing BGP, i dati di allocazione RDAP/WHOIS, i record DNS storici, le modifiche ai certificati SSL.

**Test di penetrazione** — Enumera porte/servizi/CPE, scopri bucket esposti, pagine archiviate, sottodomini e relazioni ASN.

**Threat intelligence** — Verifica l'infrastruttura C2 contro cinque feed di minacce in un'unica query.

**Compliance e rischio** — Profila l'infrastruttura dei fornitori, rileva storage cloud esposti, identifica lo shadow IT.

---

## Politica di utilizzo lecito

SeekYou è progettato per **ricerca di sicurezza lecita, operazioni di rete e threat intelligence**. Utilizzando questo strumento, accetti:

**Usi consentiti:**
- Operazioni di sicurezza e incident response su reti di tua proprietà o che sei autorizzato a monitorare
- Ricerca di threat intelligence e correlazione degli IOC
- Risoluzione dei problemi di rete e audit dell'infrastruttura all'interno della tua organizzazione
- Test di penetrazione con autorizzazione scritta esplicita dell'organizzazione target
- Ricerca accademica e formazione in cybersecurity
- Audit di conformità e valutazioni del rischio dei fornitori con la dovuta autorizzazione

**Usi vietati:**
- Accesso non autorizzato, ricognizione o attacchi contro sistemi che non possiedi o che non hai il permesso esplicito di testare
- Molestie, stalking o violazioni della privacy contro individui o organizzazioni
- Agevolare attività illegali, incluse frodi, furto d'identità o cybercrimine
- Eludere i controlli di sicurezza o le restrizioni di accesso senza autorizzazione
- Violare le leggi applicabili, inclusi CFAA (USA), Computer Misuse Act (Regno Unito), GDPR (UE), o la legislazione equivalente nella tua giurisdizione

**Le tue responsabilità:**
- Assicurati di avere la dovuta autorizzazione prima di interrogare infrastrutture che non possiedi
- Rispetta i rate limit e non abusare del servizio o delle fonti dati upstream
- Rispetta tutte le leggi e i regolamenti applicabili nella tua giurisdizione
- Usa i dati in modo responsabile e non trasformare i risultati in armi senza una divulgazione coordinata
- Comprendi che interrogare un host non concede il permesso di accedervi o sfruttarlo

**Esclusione di responsabilità:**
L'autore e i collaboratori non si assumono alcuna responsabilità per l'uso improprio di questo strumento. Gli utenti sono gli unici responsabili di garantire che le proprie attività rispettino le leggi applicabili. I dati aggregati da fonti pubbliche possono essere incompleti, obsoleti o imprecisi — verifica sempre i risultati attraverso canali autorevoli prima di agire.

Se scopri una vulnerabilità tramite SeekYou, segui le pratiche di divulgazione responsabile e informa la parte interessata prima della divulgazione pubblica.

---

## Strumenti correlati

SeekYou fa parte di un toolkit di sicurezza incentrato sulla privacy. Esplora l'intera suite:

| Strumento | Descrizione | URL |
|---|---|---|
| **TimeSeal** | Servizio di marcatura temporale crittografica — dimostra l'esistenza di un documento in un momento specifico senza rivelarne il contenuto | [timeseal.online](https://timeseal.online) |
| **SanctumVault** | Cassaforte crittografata zero-knowledge — crittografia lato client per l'archiviazione di dati sensibili | [sanctumvault.online](https://sanctumvault.online) |
| **GhostChat** | Messaggistica crittografata effimera — conversazioni autodistruggenti senza log server | [ghost-chat.pages.dev](https://ghost-chat.pages.dev) |
| **XMRProof** | Verifica dei pagamenti Monero — genera prove crittografiche delle transazioni XMR | [xmrproof.pages.dev](https://xmrproof.pages.dev) |
| **GhostReceipt** | Generazione di ricevute anonime — crea registrazioni di transazioni verificabili senza esporre l'identità | [ghostreceipt.pages.dev](https://ghostreceipt.pages.dev) |
| **SeekYou** | Aggregatore di intelligence sugli host — OSINT unificato su 15 fonti per IP, domini e ASN | [seekyou.seekyou.workers.dev](https://seekyou.seekyou.workers.dev) |
| **HoneypotScan** | Servizio di rilevamento honeypot — identifica i sistemi esca ed evita falsi positivi nella ricerca di sicurezza | [honeypotscan.pages.dev](https://honeypotscan.pages.dev) |

Tutti gli strumenti girano sulla rete edge di Cloudflare con principi di progettazione privacy-first.

---

## Panoramica dell'architettura```
Browser / curl
     │
     ▼
┌─────────────────────────────────────┐
│  Cloudflare Pages                   │
│  Next.js App Router (SSR)           │
│                                     │
│  app/page.tsx          search form  │
│  app/host/[query]/page.tsx          │
│    └─ streams /api/stream?q=…       │
│  app/api/recent/route.ts            │
│    └─ recent searches for homepage  │
│  app/targets/page.tsx               │
│    └─ monitoring dashboard          │
│  app/api/targets/route.ts           │
│    └─ saved targets CRUD            │
│        returns riskScore + lastDiff │
└──────────────┬──────────────────────┘
               │
               ▼
┌─────────────────────────────────────┐
│  app/api/lookup/route.ts            │
│  (Workers runtime via opennextjs)   │
│  • input validation                 │
│  • per-IP rate limiting (KV)        │
│  • ctx.waitUntil(recordSearch())    │
└──────────────┬──────────────────────┘
               │ runLookup()
               ▼
┌─────────────────────────────────────┐
│  worker/lookup.ts  — orchestrator   │
│  4-layer Promise.allSettled         │
└──┬──────────────────────────────────┘
   │
   ├─► Layer 1+2 (parallel, 12 sources):
   │     InternetDB · IPinfo · RIPE stat · RDAP · crt.sh · HackerTarget · Robtex
   │     URLhaus · ThreatFox · MalwareBazaar · Feodo · SSLBL
   ├─► Layer 3 (after L1): NVD CVE enrichment (only if vulns found, batched 10-at-a-time)
   └─► Layer 4 (parallel): GrayHatWarfare · Wayback (domain queries only)
               │
               ▼
┌──────────────────────┐   ┌──────────────────────┐
│ D1                   │   │ KV                   │
│ source response cache│   │ rate limiting        │
│ (TTL per source)     │   │ circuit breakers     │
│ searches             │   │ concurrency counters │
│ saved_targets        │   │                      │
└──────────────────────┘   └──────────────────────┘
               │
               ▼
┌─────────────────────────────────────┐
│  seekyou-cron (Worker)            │
│  wrangler.cron.toml                 │
│  • hourly blocklist refresh         │
│  • hourly saved-target re-query     │
│    + typed diff (lib/diff.ts)       │
│    + webhook on hasChanges          │
└─────────────────────────────────────┘

---

## Decisioni progettuali chiave

### Edge-first, senza Node.js
Il runtime di Workers tramite `@opennextjs/cloudflare` — nessuna esportazione `runtime = 'edge'` necessaria. Solo Web API pure ovunque. Cold start sotto i 50 ms a livello globale.

### Esecuzione parallela a livelli
I livelli 1+2 vengono eseguiti insieme (12 sorgenti). Il livello 3 (arricchimento CVE) viene eseguito solo se InternetDB trova vulnerabilità, in batch da 10 alla volta. Il livello 4 (GHW + Wayback) viene eseguito in parallelo al livello 3, ma viene saltato del tutto per le query IP/ASN. Il tempo totale è ≈ quello della sorgente più lenta di ogni ondata, non la somma di tutte le sorgenti.

### Degradazione graduale
Ogni sorgente è incapsulata in un circuit breaker + try/catch. Una sorgente in errore diventa un badge `{ status: 'error' }`. La pagina viene sempre renderizzata.

### Storage D1 + KV separato
Le cache delle risposte delle sorgenti risiedono in **D1** (non in KV) — i valori vengono scritti una volta, letti occasionalmente e sono abbastanza grandi da far lievitare rapidamente il costo della quota di scrittura di KV. **KV** è riservato esclusivamente ai contatori hot-path: rate limiting, circuit breaker e tracciamento della concorrenza in-flight. Ogni sorgente ha il proprio TTL (30 giorni per le CVE, 24h per BGP/RDAP, 1h per geo/porte principali, 30m per abuse.ch). `?refresh=1` propaga `forceRefresh: true` attraverso ogni fetcher per bypassare la cache D1 on demand.

### Ottimizzazione per il piano gratuito
GrayHatWarfare ha una rotazione su 18 chiavi (1.800 richieste/giorno). NVD usa il batching delle richieste (massimo 10 in parallelo). Feodo/SSLBL vengono recuperate come elenchi in blocco dal cron worker e messe in cache in KV — zero costi upstream per ogni query.

### Scritture D1 fire-and-forget
`recordSearch()` viene chiamato all'interno di `ctx.waitUntil()` — non aggiunge alcuna latenza alla risposta API. Le scritture D1 avvengono dopo il flush della risposta.

---

## Strategia di caching

Le risposte delle sorgenti vengono messe in cache in **D1** con un TTL manuale applicato tramite una colonna `expires_at`. KV non viene usato per il caching delle risposte — è riservato al rate limiting, ai circuit breaker e ai contatori di concorrenza in-flight, dove contano gli incrementi atomici a bassa latenza.```typescript
// lib/cache.ts
export async function cacheGet<T>(
  db: D1Database,
  key: string,
  bypass?: boolean,        // true when ?refresh=1
): Promise<T | null>

export async function cachePut<T>(
  db: D1Database,
  key: string,
  value: T,
  ttl: number,             // seconds
): Promise<void>

In caso di esaurimento, l'API restituisce `429` con `Retry-After`.

---

## Interruttori di circuito

Ogni sorgente ha un interruttore di circuito tracciato in KV. Se una sorgente supera il **50% di tasso di errore** in una finestra di 5 minuti (minimo 4 richieste), l'interruttore si apre e la sorgente viene saltata (restituisce `{ status: 'skipped' }`) per **15 minuti**, poi si ripristina automaticamente.

Lo stato attuale di ogni interruttore è incluso in `meta.circuitBreakers` in ogni risposta API.

Per resettare manualmente un interruttore in produzione:```bash
curl -X POST https://seekyou.seekyou.workers.dev/api/admin/reset-breaker \
  -H "Authorization: Bearer $ADMIN_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"source": "nvd"}'

Le chiavi sono denominate da `GRAYHATWARFARE_API_KEY_1` a `GRAYHATWARFARE_API_KEY_18` e memorizzate come segreti Wrangler.

---

## Persistenza D1

### Schema (`schema.sql`)```sql
CREATE TABLE IF NOT EXISTS searches (
  id          TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(8)))),
  query       TEXT NOT NULL,
  query_type  TEXT NOT NULL CHECK (query_type IN ('ip','domain','asn')),
  result_json TEXT NOT NULL,
  duration_ms INTEGER,
  created_at  INTEGER NOT NULL DEFAULT (unixepoch())
);

CREATE INDEX IF NOT EXISTS idx_searches_query
  ON searches (query, created_at DESC);

CREATE TABLE IF NOT EXISTS saved_targets (
  id          TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(8)))),
  query       TEXT NOT NULL UNIQUE,
  label       TEXT,
  notes       TEXT,
  result_json TEXT,       -- snapshot of last cron lookup
  checked_at  INTEGER,    -- unix seconds — when cron last re-queried
  created_at  INTEGER NOT NULL DEFAULT (unixepoch())
);

CREATE INDEX IF NOT EXISTS idx_saved_targets_created
  ON saved_targets (created_at DESC);

### Funzioni helper

**`lib/searches.ts`** — cronologia delle ricerche:```typescript
// Write a search row (fire-and-forget safe)
await recordSearch(db, query, queryType, resultJson, durationMs)

// Read last N distinct queries for the homepage (default 5)
const recent = await getRecentSearches(db, 5)
// → [{ query: '1.1.1.1', query_type: 'ip', created_at: 1716912000 }, ...]

---

## Worker cron

Un Worker standalone (`worker/cron.ts`) viene distribuito separatamente tramite `wrangler.cron.toml`. Viene eseguito con un **trigger orario** e svolge due attività:

1. **Aggiornamento blocklist** — verifica se le liste di massa Feodo/SSLBL sono obsolete e le riscarica se necessario.
2. **Scansione dei target salvati** — ri-interroga ogni target salvato, calcola un `TargetDiff` tipizzato, salva lo snapshot aggiornato su D1 e invia tramite POST un payload webhook quando vengono rilevate modifiche.

### Diff tipizzato (`lib/diff.ts`)

Dopo ogni nuova interrogazione, `diffHostResults(prev, next)` produce un `TargetDiff` strutturato che copre:

| Segnale | Cosa rileva |
|---|---|
| `ports` | Porte aperte / chiuse (direzione per porta) |
| `cves` | CVE comparse / risolte, con gravità e punteggio CVSS |
| `threats` | Modifiche ai feed URLhaus, Feodo, SSLBL, ThreatFox |
| `geo` | Modifiche a paese, ASN o hostname principale |
| `certExpiry` | Certificati in scadenza entro 30 giorni o appena scaduti (scatta una volta per certificato) |
| `risk` | Delta del punteggio di rischio — compare in `hasChanges` solo quando Δ ≥ 5 punti |

`summariseDiff(diff, query)` converte la struttura in una stringa leggibile per i log e l'inoltro webhook.

### Payload del webhook

Quando `diff.hasChanges` è true e `WEBHOOK_URL` è impostato, il cron effettua il POST di:```json
{
  "sentAt": 1716912000,
  "events": [
    {
      "targetId": "abc123",
      "query": "1.2.3.4",
      "checkedAt": 1716912000,
      "summary": "1.2.3.4:\n  port 3389 opened\n  CVE-2021-44228 appeared [CRITICAL 10]",
      "diff": {
        "diffedAt": 1716912000,
        "hasChanges": true,
        "ports": [{ "port": 3389, "direction": "opened" }],
        "cves": [{ "id": "CVE-2021-44228", "direction": "appeared", "severity": "CRITICAL", "score": 10 }],
        "threats": [],
        "geo": [],
        "certExpiry": [],
        "risk": { "prev": 20, "next": 55, "delta": 35 }
      }
    }
  ]
}

I segreti per il worker cron sono impostati separatamente:```bash
wrangler secret put NVD_KEY     --config wrangler.cron.toml
wrangler secret put ABUSECH_KEY --config wrangler.cron.toml
wrangler secret put WEBHOOK_URL --config wrangler.cron.toml  # optional — fires on any hasChanges

L'app è disponibile all'indirizzo `http://localhost:3000`. In sviluppo locale, KV e D1 utilizzano l'emulazione locale basata su SQLite di Wrangler — non è necessario l'accesso a un account Cloudflare per i test di base.

### Crea le risorse Cloudflare (prima volta)```bash
# Create KV namespace — copy the ID into wrangler.toml
wrangler kv namespace create KV

# Create D1 database — copy the ID into wrangler.toml
wrangler d1 create seekyou

# Apply schema
wrangler d1 execute seekyou --file=schema.sql

Lo script esegue `opennextjs-cloudflare build`, prepara la directory di output di Pages e chiama `wrangler pages deploy .open-next`. Non usare `npm run deploy` o il semplice `wrangler deploy` — queste destinano la runtime Workers (non Pages) e falliranno.

Per distribuire il cron worker separatamente:```bash
wrangler deploy --config wrangler.cron.toml

---

## Segreti e variabili d'ambiente

Tutti i segreti sono memorizzati come segreti Wrangler — mai nel codice sorgente o in `.env`.

### Segreti richiesti```bash
wrangler secret put NVD_KEY             # NVD API key (optional — higher rate limits)
wrangler secret put ABUSECH_KEY         # abuse.ch API key (URLhaus/ThreatFox/MalwareBazaar)
wrangler secret put ADMIN_TOKEN         # Bearer token for /api/admin/* endpoints

# GrayHatWarfare — repeat for each key you have (1–18)
wrangler secret put GRAYHATWARFARE_API_KEY_1
wrangler secret put GRAYHATWARFARE_API_KEY_2
# ... up to GRAYHATWARFARE_API_KEY_18

> **Nota di sicurezza:** Non committare mai `.env`. È in `.gitignore`. Se dei segreti sono stati committati, ruota tutte le chiavi e ripulisci la cronologia git con BFG (`bfg --delete-files .env`).

---

## Licenza

**Business Source License 1.1 (BSL)**

Copyright © 2026 Teycir Ben Soltane <[email protected]>

Consentito: uso personale, ricerca, istruzione, progetti non commerciali, strumenti aziendali interni.  
Limitato: offerte SaaS commerciali, rivendita come servizio, prodotti concorrenti.

Dopo 4 anni dalla data di rilascio, questo software passa ad Apache 2.0.

Consulta [docs/LICENSE.md](https://github.com/teycir/seekyou/blob/master/docs/LICENSE.md) per i termini completi.

---

## Autore

**Teycir Ben Soltane**  
Email: [email protected]  
GitHub: [@Teycir](https://github.com/Teycir)

---

## Riconoscimenti

- [InternetDB](https://internetdb.shodan.io) (Shodan)
- [IPinfo](https://ipinfo.io)
- [RIPE stat](https://stat.ripe.net)
- [RDAP](https://rdap.org)
- [crt.sh](https://crt.sh)
- [HackerTarget](https://hackertarget.com)
- [Robtex](https://www.robtex.com)
- [abuse.ch](https://abuse.ch) — URLhaus, ThreatFox, MalwareBazaar, Feodo, SSLBL
- [NVD](https://nvd.nist.gov) (NIST)
- [CIRCL](https://www.circl.lu/services/cve-search/)
- [OSV.dev](https://osv.dev)
- [GrayHatWarfare](https://grayhatwarfare.com)
- [Internet Archive](https://web.archive.org) (Wayback Machine)

---

## 🌐 Progetti Correlati

Scopri altri strumenti incentrati sulla privacy e sulla sicurezza:

### Privacy e Crittografia
- **[Timeseal](https://github.com/Teycir/Timeseal)** - Archivio crittografato con blocco temporale e Dead Man's Switch. Crittografia AES-256 a chiave divisa, sigilli effimeri.
- **[Sanctum](https://github.com/Teycir/Sanctum)** - Archivio crittografato zero-trust con negazione plausibile crittografica. XChaCha20-Poly1305, Argon2id.
- **[GhostChat](https://github.com/Teycir/GhostChat)** - Chat crittografata P2P reale tramite WebRTC. Nessun server, nessuno storage, messaggi autodistruggenti.
- **[xmrproof](https://github.com/Teycir/xmrproof)** - Verifica dei pagamenti Monero, 100% lato client.
- **[GhostReceipt](https://github.com/Teycir/GhostReceipt)** - Generazione di ricevute anonime con prove a conoscenza zero.

### Strumenti di Sicurezza
- **[BurpAPISecuritySuite](https://github.com/Teycir/BurpAPISecuritySuite)** - Estensione Burp Suite per il test di sicurezza delle API. 15 tipi di attacco, 108+ payload, rilevamento BOLA/IDOR.
- **[Mcpwn](https://github.com/Teycir/Mcpwn)** - Scanner di sicurezza automatizzato per server Model Context Protocol. Rileva RCE, path traversal, prompt injection.
- **[DiffCatcher](https://github.com/Teycir/DiffCatcher)** - Scoperta di repository Git, acquisizione di diff, estrazione di elementi di codice.
- **[HoneypotScan](https://github.com/Teycir/HoneypotScan)** - Servizio di rilevamento honeypot per la ricerca sulla sicurezza.
- **[CheckAPI](https://github.com/Teycir/CheckAPI)** - Validatore di chiavi API LLM per più provider. Privacy-first, validazione lato client.

### Server di Sicurezza MCP
- **[burp-mcp-server](https://github.com/Teycir/burp-mcp-server)** - Server MCP per Burp Suite Professional. Scansione delle vulnerabilità tramite assistenti AI.
- **[nuclei-mcp](https://github.com/Teycir/nuclei-mcp)** - Server MCP per Nuclei. Scansione multi-target, filtraggio per gravità.
- **[nmap-mcp](https://github.com/Teycir/nmap-mcp)** - Server MCP per Nmap. Ricognizione stealth, scansione vulnerabilità/NSE.
- **[frida-mcp](https://github.com/Teycir/frida-mcp)** - Server MCP per Frida. Strumentazione dinamica, bypass del certificate pinning SSL.

---

## 💼 Servizi Offerti

- 🔒 **Sviluppo Privacy-First** - Applicazioni P2P, comunicazione crittografata, sistemi a conoscenza zero
- 🚀 **Sviluppo di Applicazioni Web** - Sviluppo full-stack con Next.js, React, TypeScript
- 🔧 **Soluzioni Edge Computing** - Cloudflare Workers, Pages, D1, KV, Durable Objects
- 🛡️ **Sviluppo di Strumenti di Sicurezza** - Estensioni Burp, strumenti di penetration testing, framework di automazione
- 🤖 **Integrazione AI** - Applicazioni basate su LLM, automazione intelligente, soluzioni AI personalizzate
- 🔍 **OSINT e Threat Intelligence** - Strumenti di ricognizione personalizzati, aggregazione di threat feed, correlazione IOC

**Contattami**: [teycirbensoltane.tn](https://teycirbensoltane.tn) | Disponibile per progetti freelance e consulenza

---

<div align="center">

**Creato con 💚 da [Teycir Ben Soltane](https://teycirbensoltane.tn)**

</div>