Aula 12 - Golang - Fiber - Cookies

Antes de começarmos, vamos recapitular o que são cookies.

Cookies

Os cookies são pequenos arquivos de texto que os sites salvam no navegador do usuário para armazenar informações específicas sobre a interação do usuário com o site. Eles foram inventados no início dos anos 90 e são amplamente utilizados em aplicações web desde então.

Objetivo

O objetivo principal dos cookies é personalizar a experiência do usuário na web, tornando-a mais rápida e conveniente. Eles podem armazenar informações de login, preferências do usuário, histórico de navegação, carrinho de compras, entre outros dados.

Como Funciona

Os cookies funcionam assim: quando você visita um site, o servidor envia um cookie para o seu navegador para armazenar informações sobre a sua visita. Por exemplo, se você visitar um site de comércio eletrônico e adicionar um produto ao carrinho de compras, um cookie será salvo no seu navegador para lembrar que você adicionou aquele produto. Isso significa que, quando você voltar ao site mais tarde, o produto ainda estará no seu carrinho de compras, mesmo se você fechar o navegador. Quando você visitar o site novamente, o seu navegador envia o cookie de volta para o servidor, para que ele possa lembrar das suas preferências e fornecer uma experiência personalizada.

Tipos

Existem dois tipos principais de cookies: os cookies de sessão e os cookies persistentes. Os cookies de sessão são temporários e são apagados quando você fecha o navegador, enquanto os cookies persistentes são armazenados no seu navegador por um período determinado de tempo, mesmo depois de fechar o navegador.

Privacidade

É importante destacar que os cookies podem ser usados para rastrear o comportamento do usuário na web, o que tem gerado preocupações com a privacidade. Por esse motivo, muitos navegadores permitem que os usuários gerenciem os cookies, permitindo que eles escolham quais sites podem salvar cookies em seus navegadores e quais tipos de informações podem ser armazenadas. Além disso, muitos sites agora exigem o consentimento do usuário antes de salvar cookies em seus navegadores.

Seguindo com projeto

Armazenando o Cookie

Vamos armazenar o token em um cookie com data de expiração. No código abaixo, do authController.go, o HTTPOnly: true, é propriedade usada para evitar que o cookie seja acessado pelo JavaScript no lado do cliente. Isso ajuda a prevenir vulnerabilidades de segurança, já que o cookie só pode ser lido e enviado pelo servidor, e não por scripts no navegador. E para mandar esse cookie para o frontend, c.Cookie(&cookie).

fiber-project/controllers/authController.go

package controllers

import (
	"fiber-project/database"
	"fiber-project/models"

	"github.com/gofiber/fiber/v2"
	"golang.org/x/crypto/bcrypt"
        "github.com/golang-jwt/jwt/v4"
        "strconv"
        "time"
)

func Register(c *fiber.Ctx) error {
	var data map[string]string

	if err := c.BodyParser(&data); err != nil {
		return err
	}
	if data["password"] != data["confirm_password"] {
		c.Status(400)
		return c.JSON(fiber.Map{
			"message": "Passwords do not match!",
		})
	}

	password, _ := bcrypt.GenerateFromPassword([]byte(data["password"]), 14)

	user := models.User{
		FirstName: data["first_name"],
		LastName:  data["last_name"],
		Email:     data["email"],
		Password:  password,
	}

	database.DB.Create(&user)
	return c.JSON(user)
}

func Login(c *fiber.Ctx) error {
	//get the request parameter
	var data map[string]string

	if err := c.BodyParser(&data); err != nil {
		return err
	}

	var user models.User
	//get user by email
	database.DB.Where("email = ?", data["email"]).First(&user)

        //user not found
	if user.Id == 0 {
		c.Status(404)
		return c.JSON(fiber.Map{
			"message": "User not found!",
		})
	}
        //incorrect password
        if err := bcrypt.CompareHashAndPassword(user.Password, []byte(data["password"])); err != nil {
		c.Status(400)
		return c.JSON(fiber.Map{
			"message": "Incorrect password!",
		})
	}
        claims := jwt.RegisteredClaims{
		ID:        strconv.Itoa(int(user.Id)),
		ExpiresAt: jwt.NewNumericDate(time.Now().Add(24 * time.Hour)),
	}
	jwtToken := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
	token, err := jwtToken.SignedString([]byte("secret"))
	if err != nil {
		return c.SendStatus(fiber.StatusInternalServerError)
	}
        cookie := fiber.Cookie{
            Name: "jwt",
            Value: token,
            Expires: time.Now().Add(24 * time.Hour),
            HTTPOnly: true,
        }
        c.Cookie(&cookie)
	return c.JSON(fiber.Map{
		"jwt": token,
	})
}

CORS

Precisamos habilitar o CORS no main.go. Antes, vamos entender o que é e para que serve o CORS. CORS significa "Cross-Origin Resource Sharing" (Compartilhamento de Recursos de Origem Cruzada) e é um mecanismo de segurança em navegadores da web que permite que um site restrinja as solicitações feitas a outro site. Quando um navegador faz uma solicitação para um servidor, o servidor pode enviar uma resposta com o cabeçalho "Access-Control-Allow-Origin" para especificar quais origens estão autorizadas a acessar seus recursos. Se a solicitação estiver fora da origem autorizada, o navegador bloqueará a resposta e não permitirá que a página acesse o recurso. O CORS é usado principalmente como uma medida de segurança para proteger os usuários da web contra ataques maliciosos, como a injeção de scripts. Por exemplo, suponha que você tenha um site que permita que os usuários façam upload de imagens. Se não houver nenhuma restrição de CORS, um hacker pode enviar um script malicioso por meio de um formulário de upload, o que poderia permitir o acesso a informações confidenciais do usuário, como cookies de autenticação. Com o CORS, os servidores podem especificar quais origens estão autorizadas a fazer solicitações e limitar o risco de ataques maliciosos. Resumindo, o CORS é uma medida de segurança que ajuda a proteger os usuários de sites da web contra vulnerabilidades e ataques maliciosos. A configuração padrão do middleware CORS permite solicitações de qualquer domínio. A propriedade AllowCredentials definida como true, permite que o servidor inclua cookies e cabeçalhos de autenticação na solicitação. Isso permite que o aplicativo receba solicitações de outros domínios, incluindo cookies e informações de autenticação, graças a esse AllowCredentials como true. Se não tiver como true, o frontend não vai conseguir pegar o cookie.

fiber-project/main.go


package main

import (
	"fiber-project/database"
	"fiber-project/routes"
	"github.com/gofiber/fiber/v2"
        "github.com/gofiber/fiber/v2/middleware/cors"
)

func main() {
	database.Connect()
	app := fiber.New()
        app.Use(cors.New(cors.Config{
            AllowCredentials: true,
        }))
	routes.Setup(app)
	app.Listen(":3000")
}

Aula 12 - Golang - Fiber - Cookies