docs(i18n): middleware (pt-br)

Author: vishr

site/src/content/docs/pt-br/middleware/basic-auth.md

@@ -0,0 +1,74 @@
+---
+title: Basic Auth
+description: Middleware de autenticação HTTP Basic que valida credenciais de usuário e senha.
+sidebar:
+  order: 1
+---
+
+O middleware Basic Auth fornece autenticação básica HTTP.
+
+- Para credenciais válidas, ele chama o próximo handler.
+- Para credenciais ausentes ou inválidas, ele envia uma response `401 Unauthorized`.
+
+## Uso
+
+```go
+e.Use(middleware.BasicAuth(func(c *echo.Context, username, password string) (bool, error) {
+	// Use a constant time comparison to prevent timing attacks.
+	if subtle.ConstantTimeCompare([]byte(username), []byte("joe")) == 1 &&
+		subtle.ConstantTimeCompare([]byte(password), []byte("secret")) == 1 {
+		return true, nil
+	}
+	return false, nil
+}))
+```
+
+## Configuração customizada
+
+```go
+e.Use(middleware.BasicAuthWithConfig(middleware.BasicAuthConfig{}))
+```
+
+## Configuração
+
+```go
+type BasicAuthConfig struct {
+	// Skipper defines a function to skip middleware.
+	Skipper Skipper
+
+	// Validator validates the credentials. If the request contains multiple basic
+	// auth headers, it is called once for each header until the first valid result.
+	// Required.
+	Validator BasicAuthValidator
+
+	// Realm is the realm attribute of the WWW-Authenticate header.
+	// Default value "Restricted".
+	Realm string
+
+	// AllowedCheckLimit sets how many headers are allowed to be checked. This is
+	// useful in environments such as corporate test setups with application proxies
+	// restricting access with their own auth scheme.
+	// Default value 1.
+	AllowedCheckLimit uint
+}
+```
+
+O `Validator` tem a assinatura:
+
+```go
+type BasicAuthValidator func(c *echo.Context, user string, password string) (bool, error)
+```
+
+### Configuração padrão
+
+```go
+// Effective defaults applied when fields are left unset.
+BasicAuthConfig{
+	Skipper: DefaultSkipper,
+	Realm:   "Restricted",
+}
+```
+
+:::caution[Segurança]
+Sempre compare credenciais com `subtle.ConstantTimeCompare` para evitar timing attacks.
+:::

site/src/content/docs/pt-br/middleware/body-dump.md

@@ -0,0 +1,72 @@
+---
+title: Body Dump
+description: Capture payloads de request e response e passe-os para um handler para logging ou debugging.
+sidebar:
+  order: 2
+---
+
+O middleware Body Dump captura os payloads de request e response e os passa para um
+handler registrado. Em geral, ele é usado para debugging ou logging.
+
+:::caution
+Evite Body Dump para payloads grandes, como uploads ou downloads de arquivos. Se precisar usá-lo
+nessas rotas, adicione uma exceção na função skipper.
+:::
+
+## Uso
+
+```go
+e := echo.New()
+e.Use(middleware.BodyDump(func(c *echo.Context, reqBody, resBody []byte, err error) {
+	// Handle the request and response bodies.
+}))
+```
+
+## Configuração customizada
+
+```go
+e := echo.New()
+e.Use(middleware.BodyDumpWithConfig(middleware.BodyDumpConfig{}))
+```
+
+## Configuração
+
+```go
+type BodyDumpConfig struct {
+	// Skipper defines a function to skip middleware.
+	Skipper Skipper
+
+	// Handler receives the request and response payloads and the handler error, if any.
+	// Required.
+	Handler BodyDumpHandler
+
+	// MaxRequestBytes limits how much of the request body to dump. If the request body
+	// exceeds this limit, only the first MaxRequestBytes are dumped and the handler
+	// receives truncated data.
+	// Default: 5 * MB (5,242,880 bytes). Set to -1 to disable limits (not recommended).
+	MaxRequestBytes int64
+
+	// MaxResponseBytes limits how much of the response body to dump. If the response body
+	// exceeds this limit, only the first MaxResponseBytes are dumped and the handler
+	// receives truncated data.
+	// Default: 5 * MB (5,242,880 bytes). Set to -1 to disable limits (not recommended).
+	MaxResponseBytes int64
+}
+```
+
+O `Handler` tem a assinatura:
+
+```go
+type BodyDumpHandler func(c *echo.Context, reqBody []byte, resBody []byte, err error)
+```
+
+### Configuração padrão
+
+```go
+// Effective defaults applied when fields are left unset (Handler is required).
+BodyDumpConfig{
+	Skipper:          DefaultSkipper,
+	MaxRequestBytes:  5 * MB,
+	MaxResponseBytes: 5 * MB,
+}
+```

site/src/content/docs/pt-br/middleware/body-limit.md

@@ -0,0 +1,48 @@
+---
+title: Body Limit
+description: Rejeite requests cujo body exceda um tamanho máximo configurado.
+sidebar:
+  order: 3
+---
+
+O middleware Body Limit define o tamanho máximo permitido para o body de um request. Se o tamanho
+exceder o limite configurado, ele envia uma response `413 Request Entity Too Large`.
+
+O limite é aplicado tanto ao header de request `Content-Length` quanto ao conteúdo real
+lido, o que o torna resistente a headers falsificados. O limite é especificado
+em bytes.
+
+## Uso
+
+```go
+e := echo.New()
+e.Use(middleware.BodyLimit(2_097_152)) // 2 MB
+```
+
+## Configuração customizada
+
+```go
+e := echo.New()
+e.Use(middleware.BodyLimitWithConfig(middleware.BodyLimitConfig{}))
+```
+
+## Configuração
+
+```go
+type BodyLimitConfig struct {
+	// Skipper defines a function to skip middleware.
+	Skipper Skipper
+
+	// LimitBytes is the maximum allowed size in bytes for a request body.
+	LimitBytes int64
+}
+```
+
+### Configuração padrão
+
+```go
+// Effective defaults applied when fields are left unset (Limit is required).
+BodyLimitConfig{
+	Skipper: DefaultSkipper,
+}
+```