elazarl/goproxyUna 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.
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 e 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 del certificato CA del proxy, per evitare qualsiasi problema di certificato nei client.
host specifici, con un semplice confronto di uguaglianza o con la valutazione di espressioni regexrichieste e risposte prima di inviarle al browserhttp.Transport personalizzato per effettuare richieste al server di destinazionecache dei certificati MITM, per riutilizzarli successivamente per altre richieste allo stesso host, risparmiando così CPU. Non abilitata di default, ma dovresti usarla in produzione!handler personalizzato, quando la destinazione è un percorso relativo (es. /ping)Loggerdisabilitare la canonicalizzazione degli header delle richieste HTTP, impostando PreventCanonicalization su trueLa 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.
Se hai bisogno di integrare GoProxy nel tuo progetto, o hai bisogno di alcune funzionalità personalizzate da mantenere nel tuo fork, puoi contattare Erik (l'attuale maintainer) via e-mail, e potete discutere insieme come può aiutarti come consulente indipendente a pagamento.
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.
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.
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:
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.
Per avere un assaggio di goproxy, ecco un proxy HTTP/HTTPS di base che si limita a inoltrare i dati alla destinazione:
package main
import (
"log"
"net/http"
"github.com/elazarl/goproxy"
)
func main() {
proxy := goproxy.NewProxyHttpServer()
proxy.Verbose = true
log.Fatal(http.ListenAndServe(":8080", proxy))
}
Questa riga aggiungerà l'header X-GoProxy: yxorPoG-X a tutte le richieste inviate attraverso il proxy, prima di inviarle alla destinazione:
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.
Rifiuta le connessioni a www.reddit.com tra le 8 e le 17 nel fuso orario locale del server:
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!".
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!
Ci sono 3 diversi tipi di handler per manipolare il comportamento del proxy, come segue:
// 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:
// 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:
// 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())
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
})
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.
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).
