Skip to content
KitploitKITPLOIT
ToolsExploitsBlog
Log in
Einreichen
ToolsExploitsBlog
Einreichen

Hacking-, PenTest- und Cybersicherheits-Tools für Ihr Sicherheitsarsenal!

Kitploit ist ein Verzeichnis von Hacking-, Cybersicherheits- und Pentesting-Tools. Entdecken Sie die neuesten Projekt-Updates, um Schwachstellen zu finden, Systeme zu analysieren, Tests zu automatisieren und Ihre Sicherheit zu stärken.

FeedsKontaktDatenschutz© 2026 Kitploit

Tool-Verzeichnis

Kategorien

Alle Kategorien anzeigen
Loading categories
goproxy — Eine anpassbare HTTP/HTTPS-Proxy-Bibliothek für Go mit Unterstützung für reguläres Forwarding, CONNECT-Tunneling, MITM-TLS-Interception und programmatische Anfrage-/Antwort-Modifikation. | Kitploit
Tools/GitHubGitHub/elazarl/goproxy
Allgemeine DienstprogrammeWeb-Proxys & AbfangenWebsicherheitNetzwerksicherheitTop in Web-Proxys & Abfangen Nr.5
GitHubelazarl/goproxy

goproxy

Eine anpassbare HTTP/HTTPS-Proxy-Bibliothek für Go mit Unterstützung für reguläres Forwarding, CONNECT-Tunneling, MITM-TLS-Interception und programmatische Anfrage-/Antwort-Modifikation.

Repository anzeigen
6.8k1.2k143vor 6 TagenVon Kitploit geprüft
Teilen
# 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 ist eine Bibliothek zur Erstellung eines `angepassten` HTTP/HTTPS-`Proxy-Servers` mit Go (auch Golang genannt) und mehreren konfigurierbaren Einstellungen.
Das Ziel dieses Projekts ist es, einen `optimierten` Proxy-Server anzubieten, der bei einer angemessenen Menge an Datenverkehr nutzbar ist und dennoch `anpassbar` und `programmierbar` bleibt.

Der Proxy selbst ist einfach ein `net/http`-Handler, sodass du mehrere Middlewares (Panic-Recovery, Logging, Komprimierung usw.) darüber hinzufügen kannst. Er lässt sich problemlos in jede andere HTTP-Netzwerkbibliothek integrieren.

Um goproxy zu verwenden, sollte man den Browser (oder einen anderen Client) so einstellen, dass goproxy als HTTP-Proxy verwendet wird.
So machst du das in [Chrome](https://www.wikihow.com/Connect-to-a-Proxy-Server) und in [Firefox](http://www.wikihow.com/Enter-Proxy-Settings-in-Firefox).
Wenn du mit dem `base`-Beispiel beginnen möchtest, ist die URL, die du als Proxy verwenden solltest, `localhost:8080`, die Standard-URL in unserem Beispiel.
Du musst außerdem das [Zertifikat der Proxy-CA vertrauen](https://github.com/elazarl/goproxy/blob/master/examples/customca/README.md), um Zertifikatsprobleme bei den Clients zu vermeiden.

> [✈️ Telegram-Gruppe](https://telegram.me/goproxygroup)
>
> [🎁 Werde Sponsor](https://opencollective.com/goproxy)

## Funktionen
- Bestimmte Aktionen nur für `bestimmte Hosts` ausführen, mit einem einfachen Gleichheitsvergleich oder mit Regex-Auswertung
- `Requests` und `Responses` manipulieren, bevor sie an den Browser gesendet werden
- Einen `benutzerdefinierten http.Transport` verwenden, um Requests an den Zielserver zu senden
- Einen `MITM-Zertifikats-Cache` angeben, um sie später für andere Requests an denselben Host wiederzuverwenden und so CPU zu sparen. Standardmäßig nicht aktiviert, aber du solltest ihn in der Produktion verwenden!
- Normalen HTTP-Datenverkehr an einen `benutzerdefinierten Handler` umleiten, wenn das Ziel ein `relativer Pfad` ist (z. B. `/ping`)
- Den zu verwendenden Logger wählen, indem du das `Logger`-Interface implementierst
- Die `Kanonisierung` der HTTP-Request-Header `deaktivieren`, indem du `PreventCanonicalization` auf true setzt

## Proxy-Modi
1. Regulärer HTTP-Proxy
2. HTTPS über CONNECT
3. HTTPS-MITM-Proxy-Server („Man in the Middle"), bei dem der Server TLS-Zertifikate generiert, um Request-/Response-Daten zu analysieren und Aktionen auf ihnen auszuführen
4. „Gekaperte" Proxy-Verbindung, bei der der konfigurierte Handler auf die rohen net.Conn-Daten zugreifen kann

## Sponsoren
Nutzt dein Unternehmen GoProxy? Hilf uns, das Projekt gewartet und gesund zu halten!
Die Unterstützung von GoProxy erlaubt es uns, mehr Zeit für Fehlerbehebungen und neue Funktionen aufzuwenden.
Im Gegenzug zeigen wir dein Firmenlogo hier stolz an, wenn du einen Gold-Supporter- oder Enterprise-Plan wählst.

> [Werde 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)

## Betreuer
- [Elazar Leibovich](https://github.com/elazarl): Projektgründer, Softwareentwickler
- [Erik Pellizzon](https://github.com/ErikPelli): Betreuer, Freiberufler (offen für Kooperationen!)

Wenn du GoProxy in dein Projekt integrieren musst oder benutzerdefinierte Funktionen benötigst, die du in deinem Fork pflegen möchtest, kannst du [Erik](mailto:[email protected]) (den derzeitigen Betreuer) per E-Mail kontaktieren und gemeinsam besprechen, wie er dir als bezahlter unabhängiger Berater helfen kann.

## Beiträge
Wenn du Probleme hast, Vorschläge hast oder einen Fehler findest, zögere nicht, ein GitHub-`Issue` zu eröffnen.
Dies ist ein von Freiwilligen verwaltetes `Open-Source`-Projekt, und wir freuen uns, über alles zu diskutieren, was es verbessern kann.

Erkläre alles genau, einschließlich des Grundes für das Issue und was du ändern möchtest, um das Problem verständlicher zu machen.
Du kannst auch direkt einen `Pull Request` eröffnen, wenn es sich um eine kleine Codeänderung handelt, aber du musst in der Beschreibung alles erklären.
Wenn du einen Pull Request mit dem Namen `refactoring` und `5.000` geänderten Zeilen eröffnest, werden wir ihn nicht mergen ... `:D`

Der Code für dieses Projekt wird unter der `BSD-3-Clause`-Lizenz veröffentlicht, was ihn auch für `kommerzielle` Zwecke nutzbar macht.

### Reiche deine Fallstudie ein
Du hast GoProxy also in eines deiner persönlichen Projekte oder in ein Projekt des Unternehmens, für das du arbeitest, eingeführt und integriert.

Wir freuen uns über neue `kreative Lösungen`, die mit dieser Bibliothek erstellt wurden. Zögere also nicht, den oben genannten Betreuer per E-Mail zu `kontaktieren` und zu erklären, warum du dieses Projekt für deine Bedürfnisse nützlich fandest.

Wenn du eine `Geheimhaltungsvereinbarung` mit dem Unternehmen unterzeichnet hast, kannst du vorschlagen, dass sie einen `Blogbeitrag` zu diesem Thema auf ihrer offiziellen Website schreiben. So werden diese Informationen öffentlich, und du kannst uns den `Link des Blogbeitrags` mitteilen :)

Der Zweck von Fallstudien ist es, mit der `Community` zu teilen, warum alle `Beitragenden` zu diesem Projekt mit ihrer Hilfe die Welt `verbessern` und was Menschen damit bauen.

### Linter
Die Codebasis führt bei deinem Pull-Request-Code eine automatische Lint-Prüfung durch.
Bevor du ihn eröffnest, solltest du prüfen, ob deine Änderungen diese einhalten, indem du den Linter auf deinem lokalen Rechner ausführst, damit es keine Überraschungen gibt.

So installierst du den Linter:
```sh
go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest
```

Dadurch wird eine ausführbare Datei in deinem `$GOPATH/bin`-Ordner erstellt
(`$GOPATH` ist eine Umgebungsvariable, normalerweise
entspricht ihr Wert `~/go`; überprüfe den Wert auf deinem Rechner, wenn du
dir nicht sicher bist).
Stelle sicher, dass der bin-Ordner im Pfad deiner Shell enthalten ist, um den Befehl `golangci-lint run` direkt verwenden zu können.

## Ein Vorgeschmack auf GoProxy

Um einen Vorgeschmack auf `goproxy` zu bekommen, hier ist ein einfacher HTTP/HTTPS-Proxy, der Daten einfach an das Ziel weiterleitet:

```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))
}
```

### Request-Handler
Diese Zeile fügt allen Requests, die über den Proxy gesendet werden, den Header `X-GoProxy: yxorPoG-X` hinzu, bevor sie an das Ziel gesendet werden:

```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
    })
```

Wenn die Eingabe von `OnRequest()` leer ist, verarbeitet die in `DoFunc` angegebene Funktion alle eingehenden Requests an den Proxy. In diesem Fall fügt sie dem Request einen Header hinzu und gibt ihn an den Aufrufer zurück.
Der Proxy sendet den modifizierten Request an das Ziel.
Du kannst auch `Do` anstelle von `DoFunc` verwenden, wenn du das angegebene Interface in deinem Typ implementierst.

> ⚠️ Beachte, dass wir als Response einen nil-Wert zurückgegeben haben.
> Wenn die zurückgegebene Response nicht nil ist, verwirft goproxy den Request
> und sendet die angegebene Response an den Client.

### Bedingter Request-Handler
Verbindungen zu www.reddit.com zwischen 8 und 17 Uhr in der lokalen Zeitzone des Servers ablehnen:

```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` gibt eine `ReqCondition` zurück, eine Funktion, die einen `*http.Request` empfängt und einen booleschen Wert zurückgibt, der prüft, ob der Request die Bedingung erfüllt (und der dann verarbeitet wird).
`DstHostIs("www.reddit.com")` gibt eine `ReqCondition` zurück, die true liefert, wenn der Request an „www.reddit.com" gerichtet ist.
Der Host-Gleichheitscheck ist `case-insensitiv`, um das Verhalten von DNS-Auflösern widerzuspiegeln. Selbst wenn der Benutzer also „www.rEdDit.com" eingibt, erfüllt der Vergleich die Bedingung.
Wenn die Stunde zwischen 8:00 und 17:59 Uhr liegt, geben wir in `DoFunc()` direkt eine Response zurück, sodass das entfernte Ziel den Request nicht erhält und der Client die Antwort `"Don't waste your time!"` bekommt.

### Los geht's
```go
import "github.com/elazarl/goproxy"
```

Im Ordner `examples` gibt es einige Beispiele für die Proxy-Nutzung, die die häufigsten Fälle abdecken. Wirf einen Blick darauf und viel Glück!

## Request- & Response-Manipulation

Es gibt 3 verschiedene Arten von Handlern, um das Verhalten des Proxys zu manipulieren, wie folgt:

```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 
```

Je nachdem, was du manipulieren möchtest, gibt es folgende Möglichkeiten, Handler zu jeder der vorherigen Listen hinzuzufügen:

```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())
```

Beispiel:

```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())
```

## Fehlerbehandlung
### Allgemeiner Fehler
Wenn beim Verarbeiten eines Requests durch den Proxy ein Fehler auftritt, gibt der Proxy standardmäßig den HTTP-Fehler `500` (Internal Server Error) mit der `Fehlermeldung` als `Body`-Inhalt zurück.

Wenn du dieses Verhalten überschreiben möchtest, kannst du deinen eigenen `RespHandler` definieren, der die Fehlerantwort ändert.
Unter den Kontextparametern enthält `ctx.Error` den aufgetretenen `error` oder den Wert `nil`, wenn kein Fehler aufgetreten ist.

Du kannst ihn nach Belieben behandeln, einschließlich der Rückgabe eines benutzerdefinierten JSON als Body.
Beispiel eines Fehlerhandlers:
```
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
})
```

### Verbindungsfehler
Wenn beim Senden von Daten an den entfernten Zielserver (oder an den Proxy-Client) ein Fehler auftritt, wird der `proxy.ConnectionErrHandler` aufgerufen, um den Fehler zu behandeln, falls vorhanden; andernfalls wird ein `Standard-Handler` verwendet.
Der Fehler wird als `Funktionsparameter` übergeben und nicht im Proxy-Kontext, du musst also in diesem Handler das Feld ctx.Error nicht prüfen.

In diesem Handler hast du Zugriff auf die rohe Verbindung mit dem Proxy-Client (als `io.Writer`), sodass du bei Bedarf beliebige HTTP-Daten darüber senden kannst, die die Fehlerdaten enthalten.
Es gibt keine Garantie, dass die Verbindung nicht bereits geschlossen wurde, daher könnte `Write()` einen Fehler zurückgeben.

Die `Verbindung` wird nach dem Aufruf des Fehlerhandlers vom Proxy-`automatisch geschlossen`, du musst dir also keine Sorgen darum machen.

## Projektstatus
Dieses Projekt wurde vor `10 Jahren` erstellt und hat ein Stadium der `Reife` erreicht. Es kann sicher in der `Produktion` verwendet werden, und viele Projekte tun das bereits.

Sollte es in Zukunft eine `bahnbrechende Änderung` geben, wird eine `neue Version` des Go-Moduls veröffentlicht (z. B. v2).

## Vertrauenswürdig, als direkte Abhängigkeit genutzt von:
<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>
Tool herunterladen

Beliebteste

Alle anzeigen →

Entdecken Sie die meistgenutzten Tools unserer Community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 Das ultimative OSINT-Toolkit: Untersuchungsgraph, Konfidenzbewertung, Alias-Familien, Karte, Zeitleiste und Berichte. 49 Module, 400+ Websites, keine API-Schlüssel erforderlich.

    772
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    GhostLock One-Tap Execution App (CVE-2026-43499)

    505
  • 3

    ARTEX

    baarai/artex

    LLM-basierte Multi-Agenten-Plattform für autonome Penetrationstests mit Planer-/Worker-Agenten, Asset- und Explorationsgraphen, MITM-Verkehrsaufzeichnung und Schwachstellen-Retesting.

    420
  • 4

    redforge

    cybersecurity91/redforge

    Browser-seitiges Red-Team-Toolkit mit 102 Offline-Tools für Recon, Payload-Generierung, Credential-Angriffe, Krypto, Encoding und Engagement-Reporting.

    345
  • 5

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    Das System der Handlung für KI-native Cybersicherheit – wo Absicht zu gesteuerter Ausführung wird, Beweise zu operativem Gedächtnis werden und jeder Einsatz den nächsten verbessert.

    260
  • 6

    antifox

    antifox-ai/antifox

    KI-Multi-Agenten-Plattform für autonome Penetrationstests, die Recon, Angriffsflächen-Erkennung, Exploit-Validierung und evidenzbasierte Berichtserstellung durchführt.

    251

Alle Tools erkunden

Durchsuchen Sie unsere Tool-Sammlung

Alle Tools anzeigen →