Skip to content
KitploitKITPLOIT
StrumentiExploitsBlog
Log in
Invia
StrumentiExploitsBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

FeedContattoPrivacy© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
goproxy — Una libreria proxy HTTP/HTTPS personalizzabile per Go che supporta l'inoltro standard, il tunneling CONNECT, l'intercettazione TLS MITM e la modifica programmatica di richieste/risposte. | Kitploit
Strumenti/GitHubGitHub/elazarl/goproxy
Utilità GenericheProxy Web e IntercettazioneSicurezza WebSicurezza di ReteTop in Proxy Web e Intercettazione n.5
GitHubelazarl/goproxy

goproxy

Una libreria proxy HTTP/HTTPS personalizzabile per Go che supporta l'inoltro standard, il tunneling CONNECT, l'intercettazione TLS MITM e la modifica programmatica di richieste/risposte.

Vedi Repository
6.8k1.2k1436 giorni faRevisionato da Kitploit
Condividi
# GoProxy

![Status](https://github.com/elazarl/goproxy/workflows/Go/badge.svg)
[![GoDoc](https://pkg.go.dev/badge/github.com/elazarl/goproxy)](https://pkg.go.dev/github.com/elazarl/goproxy)
[![Go Report](https://goreportcard.com/badge/github.com/elazarl/goproxy)](https://goreportcard.com/report/github.com/elazarl/goproxy)
[![BSD-3 License](https://img.shields.io/badge/License-BSD%203--Clause-orange.svg)](https://opensource.org/licenses/BSD-3-Clause)
[![Pull Requests](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](https://makeapullrequest.com)
[![Awesome Go](https://awesome.re/mentioned-badge.svg)](https://github.com/avelino/awesome-go?tab=readme-ov-file#networking)

GoProxy è una libreria per creare un `proxy server` HTTP/HTTPS `personalizzato` utilizzando Go (aka Golang), con diverse impostazioni configurabili.
L'obiettivo di questo progetto è offrire un server proxy `ottimizzato`, utilizzabile con una quantità ragionevole di traffico, ma anche `personalizzabile` e `programmabile`.

Il proxy stesso è semplicemente un handler `net/http`, quindi puoi aggiungere più middleware (panic recover, logging, compressione, ecc.) sopra di esso. Può essere facilmente integrato con qualsiasi altra libreria di rete HTTP.

Per utilizzare goproxy, bisogna impostare il proprio browser (o qualsiasi altro client) per usare goproxy come proxy HTTP.
Ecco come fare in [Chrome](https://www.wikihow.com/Connect-to-a-Proxy-Server) e in [Firefox](http://www.wikihow.com/Enter-Proxy-Settings-in-Firefox).
Se decidi di iniziare con l'esempio `base`, l'URL da usare come proxy è `localhost:8080`, che è quello predefinito nel nostro esempio.
Devi anche [fidarti](https://github.com/elazarl/goproxy/blob/master/examples/customca/README.md) del certificato CA del proxy, per evitare qualsiasi problema di certificato nei client.

> [✈️ Gruppo Telegram](https://telegram.me/goproxygroup)
>
> [🎁 Diventa uno Sponsor](https://opencollective.com/goproxy)

## Funzionalità
- Esegui determinate azioni solo su `host specifici`, con un semplice confronto di uguaglianza o con la valutazione di espressioni regex
- Manipola `richieste` e `risposte` prima di inviarle al browser
- Utilizza un `http.Transport` personalizzato per effettuare richieste al server di destinazione
- Puoi specificare una `cache dei certificati MITM`, per riutilizzarli successivamente per altre richieste allo stesso host, risparmiando così CPU. Non abilitata di default, ma dovresti usarla in produzione!
- Reindirizza il normale traffico HTTP a un `handler personalizzato`, quando la destinazione è un `percorso relativo` (es. `/ping`)
- Puoi scegliere il logger da utilizzare, implementando l'interfaccia `Logger`
- Puoi `disabilitare` la `canonicalizzazione` degli header delle richieste HTTP, impostando `PreventCanonicalization` su true

## Modalità del proxy
1. Proxy HTTP regolare
2. HTTPS tramite CONNECT
3. Server proxy HTTPS MITM ("Man in the Middle"), in cui il server genera certificati TLS per analizzare i dati di richiesta/risposta ed eseguire azioni su di essi
4. Connessione proxy "hijacked", in cui l'handler configurato può accedere ai dati grezzi di net.Conn

## Sponsor
La tua azienda usa GoProxy? Aiutaci a mantenere il progetto attivo e in salute!
Sostenere GoProxy ci permette di dedicare più tempo alla correzione di bug e a nuove funzionalità.
In cambio, se scegli un piano Gold Supporter o Enterprise, mostreremo con orgoglio il logo della tua azienda qui.

> [Diventa uno Sponsor](https://opencollective.com/goproxy)

[![Gold Supporters](https://opencollective.com/goproxy/tiers/gold-sponsor.svg?width=890)](https://opencollective.com/goproxy)
[![Enterprise Supporters](https://opencollective.com/goproxy/tiers/enterprise.svg?width=890)](https://opencollective.com/goproxy)

## Maintainer
- [Elazar Leibovich](https://github.com/elazarl): Creatore del progetto, Ingegnere del software
- [Erik Pellizzon](https://github.com/ErikPelli): Maintainer, Freelancer (aperto a collaborazioni!)

Se hai bisogno di integrare GoProxy nel tuo progetto, o hai bisogno di alcune funzionalità personalizzate da mantenere nel tuo fork, puoi contattare [Erik](mailto:[email protected]) (l'attuale maintainer) via e-mail, e potete discutere insieme come può aiutarti come consulente indipendente a pagamento.

## Contributi
Se hai problemi, suggerimenti, o se trovi un bug, sentiti libero di contattarci aprendo una `issue` su GitHub.
Questo è un progetto `open source` gestito da volontari, e siamo felici di discutere qualsiasi cosa possa migliorarlo.

Assicurati di spiegare tutto, inclusa la ragione alla base della issue e cosa vuoi cambiare, per rendere il problema più facile da comprendere.
Puoi anche aprire direttamente una `Pull Request`, se si tratta di una piccola modifica al codice, ma devi spiegare tutto nella descrizione.
Se apri una pull request chiamata `refactoring` con `5.000` righe modificate, non la uniremo... `:D`

Il codice di questo progetto è rilasciato sotto la licenza `BSD 3-Clause`, rendendolo utile anche per usi `commerciali`.

### Invia il tuo caso di studio
Quindi, hai introdotto e integrato GoProxy in uno dei tuoi progetti personali o in un progetto all'interno dell'azienda per cui lavori.

Siamo felici di conoscere nuove `soluzioni creative` realizzate con questa libreria, quindi sentiti libero di `contattare` il maintainer elencato sopra via e-mail, per spiegare perché hai trovato questo progetto utile per le tue esigenze.

Se hai firmato un `accordo di non divulgazione` con l'azienda, puoi proporre loro di scrivere un `post sul blog` sul loro sito web ufficiale su questo argomento, così queste informazioni saranno pubbliche per loro scelta, e puoi `condividere il link` del post del blog con noi :)

Lo scopo dei casi di studio è condividere con la `comunità` perché tutti i `contributori` di questo progetto stanno `migliorando` il mondo con il loro aiuto e cosa le persone stanno costruendo usandolo.

### Linter
Il codebase utilizza un controllo lint automatico sul codice della tua Pull Request.
Prima di aprirla, dovresti verificare che le tue modifiche lo rispettino, eseguendo il linter sulla tua macchina locale, così non avrai sorprese.

Per installare il linter:
```sh
go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest
```

Questo creerà un eseguibile nella tua cartella `$GOPATH/bin` (`$GOPATH` è una variabile d'ambiente, di solito il suo valore è equivalente a `~/go`, controlla il suo valore sulla tua macchina se non ne sei sicuro).
Assicurati di includere la cartella bin nel path della tua shell, per poter usare direttamente il comando `golangci-lint run`.

## Un assaggio di GoProxy

Per avere un assaggio di `goproxy`, ecco un proxy HTTP/HTTPS di base che si limita a inoltrare i dati alla destinazione:

```go
package main

import (
    "log"
    "net/http"

    "github.com/elazarl/goproxy"
)

func main() {
    proxy := goproxy.NewProxyHttpServer()
    proxy.Verbose = true
    log.Fatal(http.ListenAndServe(":8080", proxy))
}
```

### Handler delle richieste
Questa riga aggiungerà l'header `X-GoProxy: yxorPoG-X` a tutte le richieste inviate attraverso il proxy, prima di inviarle alla destinazione:

```go
proxy.OnRequest().DoFunc(
    func(r *http.Request,ctx *goproxy.ProxyCtx)(*http.Request,*http.Response) {
        r.Header.Set("X-GoProxy","yxorPoG-X")
        return r,nil
    })
```

Quando l'input di `OnRequest()` è vuoto, la funzione specificata in `DoFunc` elaborerà tutte le richieste in arrivo al proxy. In questo caso, aggiungerà un header alla richiesta e la restituirà al chiamante.
Il proxy invierà la richiesta modificata alla destinazione.
Puoi anche usare `Do` invece di `DoFunc`, se implementi l'interfaccia specificata nel tuo tipo.

> ⚠️ Nota che abbiamo restituito un valore nil come risposta.
> Se la risposta restituita non è nil, goproxy scarterà la richiesta e invierà la risposta specificata al client.

### Handler condizionale delle richieste
Rifiuta le connessioni a www.reddit.com tra le 8 e le 17 nel fuso orario locale del server:

```go
proxy.OnRequest(goproxy.DstHostIs("www.reddit.com")).DoFunc(
    func(req *http.Request,ctx *goproxy.ProxyCtx)(*http.Request,*http.Response) {
        if h,_,_ := time.Now().Clock(); h >= 8 && h <= 17 {
			resp := goproxy.NewResponse(req, goproxy.ContentTypeText, http.StatusForbidden, "Don't waste your time!")
            return req, resp
        }
        return req, nil
})
```

`DstHostIs` restituisce una `ReqCondition`, che è una funzione che riceve un `*http.Request` e restituisce un booleano che verifica se la richiesta soddisfa la condizione (e che verrà elaborata).
`DstHostIs("www.reddit.com")` restituirà una `ReqCondition` che restituisce true quando la richiesta è diretta a "www.reddit.com".
Il controllo di uguaglianza dell'host è `case-insensitive`, per rispecchiare il comportamento dei resolver DNS, quindi anche se l'utente digita "www.rEdDit.com", il confronto soddisferà la condizione.
Quando l'ora è tra le 8:00 e le 17:59, restituiamo direttamente una risposta in `DoFunc()`, quindi la destinazione remota non riceverà la richiesta e il client riceverà la risposta `"Don't waste your time!"`.

### Iniziamo
```go
import "github.com/elazarl/goproxy"
```

Ci sono alcuni esempi di utilizzo del proxy nella cartella `examples`, che coprono i casi più comuni. Dai un'occhiata e buona fortuna!

## Manipolazione di Richieste e Risposte

Ci sono 3 diversi tipi di handler per manipolare il comportamento del proxy, come segue:

```go
// handler called after receiving HTTP CONNECT from the client, and
// before proxy establishes connection with the destination host
httpsHandlers   []HttpsHandler

// handler called before proxy sends HTTP request to destination host
reqHandlers     []ReqHandler 

// handler called after proxy receives HTTP Response from destination host,
// and before proxy forwards the Response to the client
respHandlers    []RespHandler 
```

A seconda di ciò che vuoi manipolare, i modi per aggiungere handler a ciascuna delle liste precedenti sono:

```go
// Add handlers to httpsHandlers 
proxy.OnRequest(some ReqConditions).HandleConnect(YourHandlerFunc())

// Add handlers to reqHandlers
proxy.OnRequest(some ReqConditions).Do(YourReqHandlerFunc())

// Add handlers to respHandlers
proxy.OnResponse(some RespConditions).Do(YourRespHandlerFunc())
```

Esempio:

```go
// This rejects the HTTPS request to *.reddit.com during HTTP CONNECT phase.
// Reddit URL check is case-insensitive because of (?i), so the block will work also if the user types something like rEdDit.com.
proxy.OnRequest(goproxy.ReqHostMatches(regexp.MustCompile("(?i)reddit.*:443$"))).HandleConnect(goproxy.AlwaysReject)

// Be careful about this example! It shows you a common error that you
// need to avoid.
// This will NOT reject the HTTPS request with URL ending with .gif because,
// if the scheme is HTTPS, the proxy will receive only URL.Hostname
// and URL.Port during the HTTP CONNECT phase.
proxy.OnRequest(goproxy.UrlMatches(regexp.MustCompile(`.*gif$`))).HandleConnect(goproxy.AlwaysReject)

// To fix the previous example, here there is the correct way to manipulate
// an HTTP request using URL.Path (target path) as a condition.
proxy.OnRequest(goproxy.UrlMatches(regexp.MustCompile(`.*gif$`))).Do(YourReqHandlerFunc())
```

## Gestione degli errori
### Errore generico
Se si verifica un errore durante la gestione di una richiesta attraverso il proxy, di default il proxy restituisce l'errore HTTP `500` (Internal Server Error) con il `messaggio di errore` come contenuto del `body`.

Se vuoi sovrascrivere questo comportamento, puoi definire il tuo `RespHandler` che modifica la risposta di errore.
Tra i parametri del contesto, `ctx.Error` contiene l'`errore` verificatosi, se presente, o il valore `nil`, se non si è verificato alcun errore.

Puoi gestirlo come preferisci, incluso restituire un JSON personalizzato come body.
Esempio di un gestore di errori:
```
proxy.OnResponse().DoFunc(func(resp *http.Response, ctx *goproxy.ProxyCtx) *http.Response {
	var dnsError *net.DNSError
	if errors.As(ctx.Error, &dnsError) {
		// Do not leak our DNS server's address
		dnsError.Server = "<server-redacted>"
		return goproxy.NewResponse(ctx.Req, goproxy.ContentTypeText, http.StatusBadGateway, dnsError.Error())
	}
	return resp
})
```

### Errore di connessione
Se si verifica un errore durante l'invio dei dati al server remoto di destinazione (o al client del proxy), viene chiamato `proxy.ConnectionErrHandler` per gestire l'errore, se presente, altrimenti verrà utilizzato un `handler predefinito`.
L'errore viene passato come `parametro di funzione` e non all'interno del contesto del proxy, quindi non devi controllare il campo ctx.Error in questo handler.

In questo handler hai accesso alla connessione grezza con il client del proxy (come `io.Writer`), quindi potresti inviare qualsiasi dato HTTP su di essa, se necessario, contenente i dati dell'errore.
Non c'è garanzia che la connessione non sia già stata chiusa, quindi `Write()` potrebbe restituire un errore.

La `connessione` verrà `chiusa automaticamente` dalla libreria del proxy dopo la chiamata all'handler di errore, quindi non devi preoccupartene.

## Stato del progetto
Questo progetto è stato creato `10 anni` fa e ha raggiunto uno stadio di `maturità`. Può essere utilizzato in sicurezza in `produzione`, e molti progetti lo fanno già.

Se in futuro ci sarà qualche `breaking change` (modifica incompatibile), verrà rilasciata una `nuova versione` del modulo Go (es. v2).

## Considerato affidabile, come dipendenza diretta, da:
<p align="left">
<a href="https://github.com/stripe/goproxy" target="_blank" rel="noreferrer"> <img src="https://assets.kitploit.com/production/public/readmes/50732/64d9d4a11b59a2883beada1d0e2d5e574327f693a7b84f0905510f865248f63e/649c74ea103584e65478fd86f61a32c4651855d53efb8b8d9b9011b42e39c4ee-display-v1.webp" alt="Stripe" title="Stripe" /> </a>
<a href="https://github.com/dependabot/goproxy" target="_blank" rel="noreferrer"> <img src="https://assets.kitploit.com/production/public/readmes/50732/537c51643f1d6066d041dba12f4bcae952c41490dcf6e6a1143a2e2b15d82199/ec116e30794b65255c125251a815dc4dd376fbdd76a6919fe1d2decae4c8429d-display-v1.webp" alt="Dependabot" title="Dependabot" /> </a>
<a href="https://github.com/go-git/go-git" target="_blank" rel="noreferrer"> <img src="https://assets.kitploit.com/production/public/readmes/50732/141e8059d0f465d80548bbe9af30697989ed963c30581830b97bc57ef15da0d5/fd51665ff118904f4eefb78cfd2774c195fdf100cffaa6c03e4b8467584c42bd-display-v1.webp" alt="Go Git" title="Go Git" /> </a>
<a href="https://github.com/google/oss-rebuild" target="_blank" rel="noreferrer"> <img src="https://assets.kitploit.com/production/public/readmes/50732/3cdb183f5b49d7315445abe5fd1e1dac0665db8ad88ef05062eea726ae908031/1957e79f54e85ce7afc6febabb41556f30f81b172a0c63688094ca62515817a1-display-v1.webp" alt="Google" title="Google" /> </a>
<a href="https://github.com/grafana/grafana-plugin-sdk-go" target="_blank" rel="noreferrer"> <img src="https://assets.kitploit.com/production/public/readmes/50732/801cf1f9b90012f77d2cdbac224be8b5d7def3b5b97483bedaeca069dad28790/c68471eb91d68e700faf0b225cb7f5eb55b88e520068ede25e660bfcca0f7681-display-v1.webp" alt="Grafana" title="Grafana" /> </a>
<a href="https://github.com/superfly/tokenizer" target="_blank" rel="noreferrer"> <img src="https://assets.kitploit.com/production/public/readmes/50732/fc6176b4a42fa9a431e616d58461b2b6d9fcc84ac214f1f1d321527a6445ee12/b10213639c5ce30276ff67a0f4609737b8c6a65b76b2d99d23805892a99e79d6-display-v1.webp" alt="Fly.io" title="Fly.io" /> </a>
<a href="https://github.com/kubernetes/minikube" target="_blank" rel="noreferrer"> <img src="https://assets.kitploit.com/production/public/readmes/50732/3ea12262ac6217219b5cffb4fbc2b06d415dcee86a86e9ff620fa3369a64ae36/0ef3dfd53535365fca209291742bdd27099f430199526b20ba59f56c180fcc7e-display-v1.webp" alt="Kubernetes / Minikube" title="Kubernetes / Minikube" /> </a>
<a href="https://github.com/newrelic/newrelic-client-go" target="_blank" rel="noreferrer"> <img src="https://assets.kitploit.com/production/public/readmes/50732/e3060fc9e303c90a833c7a6e01c4977d237a503215c5d6da66817881de9298c3/36b33aedf9fdd68f8e3ff5e8e9274cad40fb63d874187000c2dd29edc533d02f-display-v1.webp" alt="New Relic" title="New Relic" /> </a>
</p>
Scarica lo strumento

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

Nessun dato di popolarità ancora.

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →