Skip to content
KitploitKITPLOIT
HerramientasExploitsBlog
Log in
Enviar
HerramientasExploitsBlog
Enviar

¡Herramientas de Hacking, PenTest y Ciberseguridad para tu Arsenal de Seguridad!

Kitploit es un directorio de herramientas de hacking, ciberseguridad y pentesting. Descubre las últimas actualizaciones de proyectos para encontrar vulnerabilidades, analizar sistemas, automatizar pruebas y fortalecer tu seguridad.

FeedsContactoPrivacidad© 2026 Kitploit

Directorio de Herramientas

Categorías

Ver todas las categorías
Loading categories
Herramientas/GitHubGitHub/elazarl/goproxy
Utilidades de Propósito GeneralProxies Web e InterceptaciónSeguridad WebSeguridad de RedesTop en Proxies Web e Interceptación #5
GitHubelazarl/goproxy

goproxy

Una biblioteca de proxy HTTP/HTTPS personalizable para Go que admite reenvío regular, túneles CONNECT, intercepción TLS MITM y modificación programática de solicitudes/respuestas.

Ver Repositorio
6.8k1.2k143hace 6 díasRevisado por Kitploit
Compartir
# 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 es una librería para crear un `servidor proxy` HTTP/HTTPS `personalizado` usando
Go (también conocido como Golang), con varios ajustes configurables disponibles.
El objetivo de este proyecto es ofrecer un servidor proxy `optimizado`, utilizable con
una cantidad razonable de tráfico, pero `personalizable` y `programable`.

El proxy en sí mismo es simplemente un handler de `net/http`, por lo que puedes añadir múltiples
middlewares (recuperación de pánico, registro de logs, compresión, etc.) sobre él. Puede
integrarse fácilmente con cualquier otra librería de red HTTP.

Para usar goproxy, se debe configurar el navegador (o cualquier otro cliente)
para que use goproxy como proxy HTTP.
Así es como se hace en [Chrome](https://www.wikihow.com/Connect-to-a-Proxy-Server)
y en [Firefox](http://www.wikihow.com/Enter-Proxy-Settings-in-Firefox).
Si decides empezar con el ejemplo `base`, la URL que debes usar como
proxy es `localhost:8080`, que es la predeterminada en nuestro ejemplo.
También tienes que [confiar](https://github.com/elazarl/goproxy/blob/master/examples/customca/README.md)
en el certificado CA del proxy, para evitar cualquier problema de certificado en los clientes.

> [✈️ Grupo de Telegram](https://telegram.me/goproxygroup)
>
> [🎁 Conviértete en Patrocinador](https://opencollective.com/goproxy)

## Características
- Realizar ciertas acciones solo en `hosts específicos`, con una única comparación de igualdad o con evaluación de expresiones regulares
- Manipular `peticiones` y `respuestas` antes de enviarlas al navegador
- Usar un `http.Transport` `personalizado` para realizar peticiones al servidor de destino
- Puedes especificar una `caché de certificados MITM`, para reutilizarlos más tarde en otras peticiones al mismo host, ahorrando así CPU. No está habilitada por defecto, ¡pero deberías usarla en producción!
- Redirigir el tráfico HTTP normal a un `handler personalizado`, cuando el destino es una `ruta relativa` (p. ej. `/ping`)
- Puedes elegir el logger a usar implementando la interfaz `Logger`
- Puedes `deshabilitar` la `canonicalización` de las cabeceras HTTP de las peticiones, estableciendo `PreventCanonicalization` en true

## Modos de proxy
1. Proxy HTTP regular
2. HTTPS a través de CONNECT
3. Servidor proxy HTTPS MITM ("Man in the Middle"), en el que el servidor genera certificados TLS para analizar los datos de peticiones/respuestas y realizar acciones sobre ellos
4. Conexión proxy "secuestrada" (hijacked), donde el handler configurado puede acceder a los datos brutos de net.Conn

## Patrocinadores
¿Tu empresa usa GoProxy? ¡Ayúdanos a mantener el proyecto activo y en buen estado!
Apoyar a GoProxy nos permite dedicar más tiempo a corregir errores y añadir nuevas funciones.
A cambio, si eliges un plan Gold Supporter o Enterprise, mostraremos con orgullo el logo de tu empresa aquí.

> [Conviértete en Patrocinador](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)

## Mantenedores
- [Elazar Leibovich](https://github.com/elazarl): Creador del proyecto, Ingeniero de Software
- [Erik Pellizzon](https://github.com/ErikPelli): Mantenedor, Freelancer (¡abierto a colaboraciones!)

Si necesitas integrar GoProxy en tu proyecto, o necesitas algunas funciones
personalizadas que mantener en tu fork, puedes contactar por correo electrónico con [Erik](mailto:[email protected])
(el mantenedor actual) y acordar con él cómo puede
ayudarte como consultor independiente de pago.

## Contribuciones
Si tienes algún problema, sugerencia o encuentras un error, no dudes en
ponerte en contacto abriendo un `issue` de GitHub.
Este es un proyecto `open source` gestionado por voluntarios, y estaremos
encantados de discutir cualquier cosa que pueda mejorarlo.

Asegúrate de explicarlo todo, incluyendo el motivo del issue
y lo que quieres cambiar, para que el problema sea más fácil de entender.
También puedes abrir directamente un `Pull Request`, si es un cambio de código pequeño, pero
debes explicar todo en la descripción.
Si abres un pull request llamado `refactoring` con `5,000` líneas cambiadas,
no lo fusionaremos... `:D`

El código de este proyecto se publica bajo la licencia `BSD 3-Clause`,
lo que lo hace útil también para usos `comerciales`.

### Envía tu caso de estudio
Así que has introducido e integrado GoProxy en uno de tus proyectos personales
o en un proyecto de la empresa en la que trabajas.

Estaremos encantados de conocer nuevas `soluciones creativas` hechas con esta librería,
así que no dudes en `contactar` por correo electrónico con el mantenedor indicado arriba para explicar
por qué encontraste este proyecto útil para tus necesidades.

Si has firmado un `Acuerdo de Confidencialidad` (NDA) con la empresa, puedes
proponerles que escriban un `post` en su sitio web oficial sobre
este tema, de modo que esta información será pública por decisión suya, y podrás
`compartir el enlace` del post con nosotros :)

El propósito de los casos de estudio es compartir con la `comunidad` por qué todos los
`contribuyentes` de este proyecto están `mejorando` el mundo con su ayuda y
qué está construyendo la gente con él.

### Linter
El código base utiliza una comprobación automática de lint sobre el código de tu Pull Request.
Antes de abrirlo, deberías comprobar si tus cambios lo respetan, ejecutando
el linter en tu máquina local, para no llevarte ninguna sorpresa.

Para instalar el linter:
```sh
go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest
```

Esto creará un ejecutable en tu carpeta `$GOPATH/bin`
(`$GOPATH` es una variable de entorno; normalmente
su valor equivale a `~/go`; comprueba su valor en tu máquina si no
estás seguro de ello).
Asegúrate de incluir la carpeta bin en el path de tu shell, para poder
usar directamente el comando `golangci-lint run`.

## Un vistazo a GoProxy

Para hacerte una idea de `goproxy`, aquí tienes un proxy HTTP/HTTPS básico
que simplemente reenvía los datos al destino:

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

### Manejador de peticiones
Esta línea añadirá la cabecera `X-GoProxy: yxorPoG-X` a todas las peticiones enviadas a través del proxy,
antes de enviarlas al destino:

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

Cuando la entrada de `OnRequest()` está vacía, la función especificada en `DoFunc`
procesará todas las peticiones entrantes al proxy. En este caso, añadirá
una cabecera a la petición y la devolverá al llamante.
El proxy enviará la petición modificada al destino.
También puedes usar `Do` en lugar de `DoFunc`, si implementas la interfaz
especificada en tu tipo.

> ⚠️ Nota: devolvimos un valor nil como respuesta.
> Si la respuesta devuelta no es nil, goproxy descartará la petición
> y enviará la respuesta especificada al cliente.

### Manejador condicional de peticiones
Rechaza las conexiones a www.reddit.com entre las 8 y las 17 en la zona
horaria local del servidor:

```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` devuelve una `ReqCondition`, que es una función que recibe un `*http.Request`
y devuelve un booleano que comprueba si la petición satisface la condición (y que será procesada).
`DstHostIs("www.reddit.com")` devolverá una `ReqCondition` que devuelve true
cuando la petición está dirigida a "www.reddit.com".
La comprobación de igualdad del host es `insensible a mayúsculas y minúsculas` (case-insensitive), para reflejar el comportamiento de los resolvedores
DNS, de modo que incluso si el usuario escribe "www.rEdDit.com", la comparación
satisfará la condición.
Cuando la hora está entre las 8:00 y las 17:59, devolvemos directamente
una respuesta en `DoFunc()`, de modo que el destino remoto no recibirá la
petición y el cliente recibirá la respuesta `"Don't waste your time!"`.

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

Hay algunos ejemplos de uso del proxy en la carpeta `examples`, que
cubren los casos más comunes. ¡Échales un vistazo y buena suerte!

## Manipulación de peticiones y respuestas

Hay 3  tipos diferentes de handlers para manipular el comportamiento del proxy, como se indica a continuación:

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

Dependiendo de lo que quieras manipular, las formas de añadir handlers a cada una de las listas anteriores son:

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

Ejemplo:

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

Esto rechaza la petición HTTPS a *.reddit.com durante la fase de HTTP CONNECT.
La comprobación de la URL de Reddit no distingue mayúsculas de minúsculas gracias a (?i), por lo que el bloqueo funcionará también si el usuario escribe algo como rEdDit.com.

¡Ten cuidado con este ejemplo! Te muestra un error común que debes evitar.
Esto NO rechazará la petición HTTPS con URL que termine en .gif porque,
si el esquema es HTTPS, el proxy recibirá solo URL.Hostname
y URL.Port durante la fase de HTTP CONNECT.

Para corregir el ejemplo anterior, aquí está la forma correcta de manipular
una petición HTTP usando URL.Path (ruta de destino) como condición.

## Manejo de errores
### Error genérico
Si se produce un error al manejar una petición a través del proxy, por defecto
el proxy devuelve el error HTTP `500` (Internal Server Error) con el `mensaje de
error` como contenido del `body`.

Si quieres anular este comportamiento, puedes definir tu propio
`RespHandler` que cambie la respuesta de error.
Entre los parámetros del contexto, `ctx.Error` contiene el `error` ocurrido,
si lo hay, o el valor `nil`, si no ocurrió ningún error.

Puedes manejarlo como quieras, incluso devolviendo un JSON personalizado como cuerpo.
Ejemplo de un manejador de errores:
```
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
})
```

### Error de conexión
Si se produce un error al enviar datos al servidor remoto de destino (o al
cliente del proxy), se llamará a `proxy.ConnectionErrHandler` para manejar el
error, si está definido; de lo contrario, se usará un `handler por defecto`.
El error se pasa como `parámetro de función` y no dentro del contexto del proxy,
por lo que no tienes que comprobar el campo ctx.Error en este handler.

En este handler tienes acceso a la conexión bruta con el cliente del proxy
(como un `io.Writer`), por lo que podrías enviar cualquier dato HTTP a través de ella,
si fuera necesario, que contenga los datos del error.
No hay garantía de que la conexión no se haya cerrado ya, por lo que
`Write()` podría devolver un error.

La `conexión` será `cerrada automáticamente` por la librería del proxy después de la
llamada al manejador de errores, así que no tienes que preocuparte por ello.

## Estado del proyecto
Este proyecto fue creado hace `10 años` y ha alcanzado una etapa de
`madurez`. Puede usarse de forma segura en `producción`, y muchos proyectos
ya lo hacen.

Si en el futuro hay algún `cambio incompatible` (breaking change), se publicará una `nueva versión` del
módulo Go (p. ej. v2).

## En el que confían, como dependencia directa:
<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>
Descargar herramienta

Más Populares

Ver todos →

Descubre las herramientas más usadas por nuestra comunidad.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 El kit de herramientas OSINT definitivo: grafo de investigación, puntuación de confianza, familias de alias, mapa, línea de tiempo e informes. 49 módulos, más de 400 sitios, sin necesidad de claves API.

    772
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Aplicación de Ejecución con un Solo Toque GhostLock (CVE-2026-43499)

    505
  • 3

    ARTEX

    baarai/artex

    Plataforma de pruebas de penetración autónoma multiagente basada en LLM con agentes planificadores/trabajadores, grafos de activos y de exploración, registro de tráfico MITM y reevaluación de vulnerabilidades.

    420
  • 4

    redforge

    cybersecurity91/redforge

    Kit de herramientas de red team del lado del navegador con 102 herramientas offline para reconocimiento, generación de payloads, ataques de credenciales, criptografía, codificación y elaboración de informes de compromiso.

    345
  • 5

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    El sistema de acción para la ciberseguridad nativa de IA—donde la intención se convierte en ejecución gobernada, la evidencia se convierte en memoria operativa y cada operación mejora la siguiente.

    260
  • 6

    antifox

    antifox-ai/antifox

    Plataforma de pruebas de penetración autónoma con múltiples agentes de IA que ejecuta reconocimiento, descubrimiento de superficie de ataque, validación de explotación y entrega de informes respaldados por evidencia.

    251

Explora todas las herramientas

Explora nuestra colección de herramientas

Ver todas las herramientas →