Poodle Attack in Gin with Basic Auth

The Poodle attack (Padding Oracle On Downgraded Legacy Encryption) targets systems that negotiate TLS with SSLv3. When an API endpoint implemented with Gin uses HTTP Basic Authentication over a connection that can be forced to fall back to SSLv3, the cipher suite vulnerable to Poodle becomes exploitable. An attacker who can intercept or influence the TLS negotiation may downgrade the connection and then use a padding oracle to recover plaintext authentication credentials byte by byte.

In this specific combination, Basic Auth transmits username and password in an Authorization header encoded as base64 (not encrypted). If SSLv3 is negotiated, the confidentiality of those base64-encoded credentials is compromised due to the padding oracle weakness. Even though Basic Auth is a transport-layer concern and not a Gin framework concern, Gin applications that do not explicitly disable SSLv3 or enforce strong cipher suites may inadvertently allow a client or reverse proxy to negotiate SSLv3, enabling Poodle. The scanner’s TLS and Encryption checks can surface such weak protocol/cipher findings by correlating endpoint behavior with the reported TLS configuration, highlighting the risk when outdated protocols coexist with weak authentication transport.

For example, a Gin server that accepts connections without explicit TLS minimum version enforcement might accept an SSLv3 handshake if a client offers it. Combined with a cipher suite susceptible to Poodle, this creates a path for credential exposure. The scanner’s findings in this area focus on protocol support and cipher strength, which are prerequisites for this attack vector when Basic Auth is in use.

Remediation focuses on preventing SSLv3 negotiation and ensuring strong transport security, while avoiding storing or transmitting credentials in clear text. On the server side, explicitly configure TLS settings to disable SSLv3 and prefer modern cipher suites. Do not rely on Basic Auth alone; consider migrating to token-based authentication where feasible.

Below is a minimal, secure Gin example using TLS with modern settings and Basic Auth over HTTPS. It avoids SSLv3 by configuring the tls.Config with MinVersion and CipherSuites, and it uses middleware to check credentials on each request.

//go
package main

import (
	"crypto/tls"
	"crypto/x509"
	"fmt"
	"net/http"
	"os"

	"github.com/gin-gonic/gin"
)

func main() {
	r := gin.New()

	// Basic Auth middleware for Gin
	r.Use(func(c *gin.Context) {
		user, pass, ok := c.Request.BasicAuth()
		if !ok || !checkCredentials(user, pass) {
			c.Header("WWW-Authenticate", `Basic realm="restricted", charset="UTF-8"`)
			c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "invalid credentials"})
			return
		}
		c.Next()
	})

	r.GET("/secure", func(c *gin.Context) {
		c.JSON(http.StatusOK, gin.H{"message": "authenticated"})
	})

	// Configure TLS with secure settings
	tlsConfig := &tls.Config{
		MinVersion: tls.VersionTLS12,
		CipherSuites: []uint16{
			tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
			tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
		},
		PreferServerCipherSuites: true,
	}

	srv := &http.Server{
		Addr:      ":8443",
		Handler:   r,
		TLSConfig: tlsConfig,
	}

	certFile := os.Getenv("TLS_CERT")
	keyFile := os.Getenv("TLS_KEY")
	if certFile == "" || keyFile == "" {
		fmt.Println("TLS_CERT and TLS_KEY environment variables must be set")
		os.Exit(1)
	}

	// ListenAndServeTLS will use the TLS config above
	if err := srv.ListenAndServeTLS(certFile, keyFile); err != nil {
		fmt.Printf("Server failed: %v\n", err)
		os.Exit(1)
	}
}

func checkCredentials(user, pass string) bool {
	// Replace with secure credential verification, e.g., constant-time compare
	return user == "admin" && pass == "correct-horse-battery-staple"
}

Key points in this example:

• MinVersion: tls.VersionTLS12 disables SSLv3 and TLS 1.0/1.1, preventing protocol downgrade attacks like Poodle.
• CipherSuites specifies strong, AEAD-based suites, avoiding cipher suites known to be weak or susceptible to padding oracle attacks.
• PreferServerCipherSuites: true ensures the server’s ordered preference is respected, reducing negotiation risks.
• Basic Auth credentials are validated on each request; transmission must occur only over the enforced TLS connection.

Complementary practices include using short-lived credentials, rotating secrets, and avoiding Basic Auth for public APIs in favor of OAuth 2.0 or API keys with strong transport protection. The scanner’s findings for Authentication, Encryption, and TLS configuration can help validate that these settings are correctly applied.