Poodle Attack in Gin

The POODLE attack (CVE-2014-3566) exploits a fallback to SSL 3.0 and its CBC‑mode padding oracle, allowing an attacker to decrypt parts of HTTPS traffic such as session cookies. In a Gin‑based service the vulnerability usually appears when the underlying net/http server is started with a TLS configuration that either explicitly enables SSL 3.0 or permits weak cipher suites that trigger a version downgrade.

Gin itself does not handle TLS; it relies on the standard library’s http.Server. A common pattern that opens the door to POODLE is:

package main

import (
	"log"
	"net/http"
	"github.com/gin-gonic/gin"
)

func main() {
	r := gin.Default()
	r.GET("/ping", func(c *gin.Context) {
		c.JSON(http.StatusOK, gin.H{"message": "pong"})
	})

	// Vulnerable TLS config – forces SSLv3 or allows weak ciphers
	server := &http.Server{
		Addr:    ":8443",
		Handler: r,
		TLSConfig: &tls.Config{
			MinVersion: tls.VersionSSL30, // explicitly SSLv3
			CipherSuites: []uint16{
				TLS_RSA_WITH_3DES_EDE_CBC_SHA, // weak CBC suite
			},
		},
	}

	if err := server.ListenAndServeTLS("cert.pem", "key.pem"); err != nil {
		log.Fatalf("Server failed: %v", err)
	}
}

When a client connects, an active man‑in‑the‑middle can force the connection down to SSL 3.0 (if the client permits it) and then exploit the padding oracle to recover plaintext byte‑by‑byte. The attack does not require any Gin‑specific handler; it is purely a transport‑layer misconfiguration that becomes visible when the Gin router is attached to an insecure TLS endpoint.

middleBrick performs unauthenticated, black‑box scanning of the API surface. One of its 12 parallel checks is the "Encryption" test, which probes the TLS stack for protocol version support and cipher suite strength. When you submit a Gin service’s base URL (e.g., https://api.example.com), middleBrick:

• Performs a TLS handshake and records the highest protocol version the server agrees to.
• Checks for the presence of SSL 3.0 (or TLS 1.0/1.1) in the negotiated version list.
• Evaluates cipher suites against a set of known weak CBC‑mode suites that are vulnerable to POODLE.
• If SSL 3.0 is accepted or a weak CBC suite is selected, the check returns a finding with severity High, referencing CVE‑2014-3566 and providing the exact protocol/cipher observed.

The finding appears in the dashboard under the Encryption category, with a short description such as:

SSL 3.0 protocol enabled – POODLE vulnerability (CVE‑2014-3566). Server accepted SSL 3.0 during handshake.

Because middleBrick does not need agents, credentials, or source code, the test works regardless of how the Gin server is deployed (Docker, bare metal, Kubernetes, etc.). The scan completes in 5–15 seconds, giving you immediate feedback on whether your Gin service exposes the POODLE attack surface.

Fixing POODLE in a Gin application means correcting the TLS configuration used by the underlying http.Server. Gin offers two idiomatic ways to start a TLS‑enabled server:

1. Using Router.RunTLS – Gin creates the server internally, but you can still pass a custom tls.Config via the http.Server field if you need fine‑grained control.
2. Building a custom http.Server – gives full control over TLS settings while keeping Gin as the handler.

The recommended, secure baseline is to disable SSL 3.0, TLS 1.0, and TLS 1.1, enforce a minimum of TLS 1.2, and select only strong cipher suites (preferably those using AEAD modes such as AES‑GCM or ChaCha20‑Poly1305).

Example using RunTLS with a secure config:

package main

import (
	"crypto/tls"
	"log"
	"github.com/gin-gonic/gin"
)

func main() {
	r := gin.Default()
	r.GET("/secure", func(c *gin.Context) {
		c.JSON(200, gin.H{"status": "ok"})
	})

	// Secure TLS config
	secureConfig := &tls.Config{
		MinVersion: tls.VersionTLS12,
		CipherSuites: []uint16{
			TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
			TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
			TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305,
			TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305,
		},
		PreferServerCipherSuites: true,
	}

	// Attach the config to Gin’s internal server
	s := &http.Server{
		Handler: r,
		TLSConfig: secureConfig,
	}

	// Use RunTLS but replace the internal server with our custom one
	if err := s.ListenAndServeTLS("cert.pem", "key.pem"); err != nil {
		log.Fatalf("Failed to start TLS server: %v", err)
	}
}

If you prefer to keep Gin’s shortcut, you can still inject the config:

r.RunTLS(":8443", "cert.pem", "key.pem")
// Before calling RunTLS, set the global TLS config:
http.DefaultTransport.(*http.Transport).TLSClientConfig = &tls.Config{
	MinVersion: tls.VersionTLS12,
	// ... same cipher suite list as above
}

After applying these changes, rerun middleBrick (or any TLS scanner). The Encryption check should now report TLS 1.2 or higher as the minimum negotiated version and no longer flag weak CBC suites, eliminating the POODLE risk.