Aula 12 – Golang – Fiber – Cookies
Aula 12 – Golang – Fiber – Cookies
Voltar para página principal do site
Todas as aulas desse curso
Aula 11 Aula 13
Fiber
Pacote Programador Fullstack
Redes Sociais:
Link para a Digital Innovation
Quer aprender python3 de graça e com certificado? Acesse então:
workover
Meus link de afiliados:
Hostinger
Digital Ocean
One.com
Código da aula: Github
Melhore seu NETWORKING
Participe de comunidades de desenvolvedores:
Fiquem a vontade para me adicionar ao linkedin.
E também para me seguir no GITHUB.
Canais do Youtube
Toti
Backing Track / Play-Along
Código Fluente
Putz!
Vocal Techniques and Exercises
PIX para doações
PIX Nubank
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")
}
Agora que temos o cookie precisamos usar ele para recuperar o usuário logado.
É o que vamos fazer na próxima aula. 😉 \o/
Até lá!
Código da aula: Github
Voltar para página principal do blog
Todas as aulas desse curso
Aula 11 Aula 13
Redes Sociais:
