S08L07 - Alteração de senha no Spring Boot

html

Implementando Funcionalidade de Alteração de Senha no Spring Boot: Um Guia Abrangente
Índice

Introdução ................................................. 1
Configurando Seu Projeto Spring Boot ............. 3
Atualizando o Modelo de Conta ............................. 6
Implementando o Account Controller ................ 10
Gerenciando Password Reset Tokens .......................... 14
Criando a Visualização de Alteração de Senha .................... 18
Testando a Funcionalidade de Alteração de Senha ........ 22
Conclusão .......................................................... 26


Introdução
Na era digital de hoje, garantir a segurança das contas de usuário é fundamental. Um aspecto crucial dessa segurança é implementar recursos robustos de gerenciamento de senhas, como password reset e funcionalidades de alteração de senha. Este eBook fornece um guia passo a passo para implementar um recurso de alteração de senha em uma aplicação Spring Boot, adaptado para iniciantes e desenvolvedores com conhecimentos básicos.
Importância e Propósito
Permitir que os usuários alterem suas senhas aumenta a segurança das contas e a confiança dos usuários. Este recurso permite que os usuários atualizem suas credenciais em caso de violação de segurança ou password reset, garantindo proteção contínua de suas informações pessoais.
Prós e Contras
Prós:

Segurança Aprimorada: Atualizações regulares de senha reduzem o risco de acesso não autorizado.
Confiança do Usuário: Fornecer gerenciamento fácil de senhas melhora a confiança do usuário na sua aplicação.
Conformidade: Atende aos padrões de segurança e requisitos regulatórios.

Contras:

Complexidade na Implementação: Requer manuseamento cuidadoso de tokens e comunicação segura.
Experiência do Usuário: Recursos implementados de forma deficiente podem frustrar os usuários.

Quando e Onde Usar
Implemente a funcionalidade de alteração de senha em aplicações onde contas de usuário são gerenciadas, tais como plataformas de e-commerce, redes sociais e software empresarial. É essencial sempre que a autenticação de usuários estiver envolvida para manter a segurança contínua das contas.
Tabela de Comparação: Password Reset vs. Password Change


Característica
Password Reset
Password Change


Propósito
Recuperar acesso quando a senha é esquecida
Atualizar senha enquanto está logado


Gatilho
O usuário inicia o reset através de um link enviado por email
O usuário inicia a alteração nas configurações da conta


Uso de Token
Utiliza o token de reset enviado por email
Pode não requerer um token se o usuário estiver autenticado


Considerações de Segurança
Alta, pois envolve verificação por email
Moderada, requer autenticação existente


Tabela de Uso: Cenários para Implementar Recursos de Senha


Cenário
Recurso Aplicável


Usuário esquece a senha
Password Reset


Usuário atualiza a senha proativamente
Password Change


Violação de segurança requer atualização imediata da senha
Password Reset


Manutenção regular da conta
Password Change



Configurando Seu Projeto Spring Boot
Antes de mergulhar na implementação da funcionalidade de alteração de senha, certifique-se de que seu projeto Spring Boot está configurado corretamente.
Pré-requisitos

Java Development Kit (JDK): Certifique-se de que você tem o JDK 8 ou superior instalado.
Maven ou Gradle: Para gerenciamento de dependências do projeto.
IDE: IntelliJ IDEA, Eclipse ou qualquer IDE Java preferida.
Banco de Dados: MySQL, PostgreSQL ou qualquer banco de dados relacional.

Criando a Aplicação Spring Boot

Inicializar o Projeto:

Use o Spring Initializr para gerar um novo projeto Spring Boot.
Selecione as dependências:

Spring Web
Spring Data JPA
Thymeleaf
Spring Security
H2 Database (para fins de desenvolvimento)




Importar o Projeto:

Importe o projeto gerado para sua IDE.


Configurar Conexão com o Banco de Dados:

Atualize o arquivo application.properties com as credenciais do seu banco de dados.







		
		
			
			
Java
			
			
spring.datasource.url=jdbc:mysql://localhost:3306/blogdb
spring.datasource.username=root
spring.datasource.password=yourpassword
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

			
				
					
				
					1
2
3
4
5
6
7
				
						 
spring.datasource.url=jdbc:mysql://localhost:3306/blogdb
spring.datasource.username=root
spring.datasource.password=yourpassword
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
 
					
				
			
		


Visão Geral da Estrutura do Projeto
Compreender a estrutura do projeto é vital para uma navegação eficiente e implementação.




		
		
			
			
Java
			
			
SpringBlog/
├── src/
│   ├── main/
│   │   ├── java/org/studyeasy/SpringBlog/
│   │   │   ├── config/
│   │   │   ├── controller/
│   │   │   ├── models/
│   │   │   ├── repositories/
│   │   │   ├── services/
│   │   │   └── SpringBlogApplication.java
│   │   ├── resources/
│   │   │   ├── static/
│   │   │   └── templates/
└── pom.xml

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
				
						 
SpringBlog/
├── src/
│   ├── main/
│   │   ├── java/org/studyeasy/SpringBlog/
│   │   │   ├── config/
│   │   │   ├── controller/
│   │   │   ├── models/
│   │   │   ├── repositories/
│   │   │   ├── services/
│   │   │   └── SpringBlogApplication.java
│   │   ├── resources/
│   │   │   ├── static/
│   │   │   └── templates/
└── pom.xml
 
					
				
			
		



Atualizando o Modelo de Conta
O modelo Account representa as contas de usuário em sua aplicação. Para suportar a funcionalidade de alteração de senha, você precisará atualizar este modelo para incluir campos para password reset tokens.
Adicionando o Campo do Token

Navegue até o Modelo Account.java:





		
		
			
			
Java
			
			
package org.studyeasy.SpringBlog.models;

import javax.persistence.*;
import java.time.LocalDateTime;

@Entity
public class Account {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String email;
    private String password;

    @Column(name = "token")
    private String passwordResetToken;

    private LocalDateTime tokenExpiry;

    // Getters and Setters
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
				
						 
package org.studyeasy.SpringBlog.models;
 
import javax.persistence.*;
import java.time.LocalDateTime;
 
@Entity
public class Account {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
 
    private String email;
    private String password;
 
    @Column(name = "token")
    private String passwordResetToken;
 
    private LocalDateTime tokenExpiry;
 
    // Getters and Setters
}
 
					
				
			
		



Explicação:

passwordResetToken: Armazena o token único enviado para o email do usuário para resetar a senha.
tokenExpiry: Registra o tempo de expiração do token para garantir a segurança.



Migrando o Banco de Dados
Após atualizar o modelo, certifique-se de que o esquema do banco de dados reflita essas alterações.

Executar a Aplicação:

O Spring Boot atualiza automaticamente o esquema do banco de dados com base na propriedade ddl-auto=update.


Verificar as Alterações:

Acesse seu banco de dados e confirme que a tabela Account agora inclui as colunas token e token_expiry.




Implementando o Account Controller
O AccountController gerencia operações relacionadas ao usuário, incluindo funcionalidades de password reset e alteração de senha.
Adicionando o Endpoint de Alteração de Senha

Navegue até AccountController.java:





		
		
			
			
Java
			
			
package org.studyeasy.SpringBlog.controller;

import org.studyeasy.SpringBlog.services.AccountService;
import org.studyeasy.SpringBlog.models.Account;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;

import java.time.LocalDateTime;
import java.util.Optional;

@Controller
public class AccountController {

    @Autowired
    private AccountService accountService;

    @GetMapping("/change-password")
    public String changePasswordPage(
            @RequestParam("token") String token,
            Model model,
            RedirectAttributes redirectAttributes) {

        Optional<Account> optionalAccount = accountService.findByToken(token);

        if (optionalAccount.isPresent()) {
            Account account = optionalAccount.get();
            Long accountId = account.getId();

            LocalDateTime now = LocalDateTime.now();
            if (now.isAfter(account.getTokenExpiry())) {
                redirectAttributes.addFlashAttribute("error", "Token expired");
                return "redirect:/forgot-password";
            }

            model.addAttribute("accountId", accountId);
            return "account_views/change_password";
        } else {
            redirectAttributes.addFlashAttribute("error", "Invalid token");
            return "redirect:/forgot-password";
        }
    }

    // Additional methods...
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
				
						 
package org.studyeasy.SpringBlog.controller;
 
import org.studyeasy.SpringBlog.services.AccountService;
import org.studyeasy.SpringBlog.models.Account;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;
 
import java.time.LocalDateTime;
import java.util.Optional;
 
@Controller
public class AccountController {
 
    @Autowired
    private AccountService accountService;
 
    @GetMapping("/change-password")
    public String changePasswordPage(
            @RequestParam("token") String token,
            Model model,
            RedirectAttributes redirectAttributes) {
 
        Optional<Account> optionalAccount = accountService.findByToken(token);
 
        if (optionalAccount.isPresent()) {
            Account account = optionalAccount.get();
            Long accountId = account.getId();
 
            LocalDateTime now = LocalDateTime.now();
            if (now.isAfter(account.getTokenExpiry())) {
                redirectAttributes.addFlashAttribute("error", "Token expired");
                return "redirect:/forgot-password";
            }
 
            model.addAttribute("accountId", accountId);
            return "account_views/change_password";
        } else {
            redirectAttributes.addFlashAttribute("error", "Invalid token");
            return "redirect:/forgot-password";
        }
    }
 
    // Additional methods...
}
 
					
				
			
		



Explicação:

Endpoint: /change-password lida com requisições GET para alterações de senha.
Parâmetros:

token: O password reset token recebido por email.


Processo:

Validar Token: Verifica se o token existe e não expirou.
Redirecionar em Falha: Se inválido ou expirado, redireciona para a página de forgot password com uma mensagem de erro.
Carregar Visualização: Se válido, carrega a visualização de alteração de senha.





Conceitos e Terminologia Chave

@Controller: Indica que esta classe funciona como um controller no framework Spring MVC.
@GetMapping: Mapeia requisições HTTP GET para métodos handler específicos.
Model: Facilita a passagem de dados para a view.
RedirectAttributes: Permite que atributos sejam passados durante um cenário de redirecionamento.
Optional: Encapsula a possibilidade de um objeto Account ausente.


Gerenciando Password Reset Tokens
Gerenciar password reset tokens é crucial para a segurança e funcionalidade do recurso de alteração de senha.
Criando o Método de Geração de Token

Navegue até AccountService.java:





		
		
			
			
Java
			
			
package org.studyeasy.SpringBlog.services;

import org.studyeasy.SpringBlog.models.Account;
import org.studyeasy.SpringBlog.repositories.AccountRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Optional;
import java.util.UUID;

@Service
public class AccountService {

    @Autowired
    private AccountRepository accountRepository;

    public Optional<Account> findByToken(String token) {
        return accountRepository.findByPasswordResetToken(token);
    }

    public void createPasswordResetToken(Account account) {
        String token = UUID.randomUUID().toString();
        account.setPasswordResetToken(token);
        account.setTokenExpiry(LocalDateTime.now().plusHours(24));
        accountRepository.save(account);
        // Send email with token...
    }

    // Additional methods...
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
				
						 
package org.studyeasy.SpringBlog.services;
 
import org.studyeasy.SpringBlog.models.Account;
import org.studyeasy.SpringBlog.repositories.AccountRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
import java.util.Optional;
import java.util.UUID;
 
@Service
public class AccountService {
 
    @Autowired
    private AccountRepository accountRepository;
 
    public Optional<Account> findByToken(String token) {
        return accountRepository.findByPasswordResetToken(token);
    }
 
    public void createPasswordResetToken(Account account) {
        String token = UUID.randomUUID().toString();
        account.setPasswordResetToken(token);
        account.setTokenExpiry(LocalDateTime.now().plusHours(24));
        accountRepository.save(account);
        // Send email with token...
    }
 
    // Additional methods...
}
 
					
				
			
		



Explicação:

findByToken: Recupera um Account com base no token fornecido.
createPasswordResetToken: Gera um token único, define sua expiração e o salva na conta. Além disso, inicia o processo para enviar o token por email.



Método de Repositório para Pesquisa de Token

Navegue até AccountRepository.java:





		
		
			
			
Java
			
			
package org.studyeasy.SpringBlog.repositories;

import org.studyeasy.SpringBlog.models.Account;
import org.springframework.data.jpa.repository.JpaRepository;

import java.util.Optional;

public interface AccountRepository extends JpaRepository<Account, Long> {
    Optional<Account> findByPasswordResetToken(String token);
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
				
						 
package org.studyeasy.SpringBlog.repositories;
 
import org.studyeasy.SpringBlog.models.Account;
import org.springframework.data.jpa.repository.JpaRepository;
 
import java.util.Optional;
 
public interface AccountRepository extends JpaRepository<Account, Long> {
    Optional<Account> findByPasswordResetToken(String token);
}
 
					
				
			
		



Explicação:

findByPasswordResetToken: Um método customizado seguindo as convenções de nomenclatura do Spring Data JPA para encontrar uma conta pelo seu password reset token.



Considerações de Segurança

Unicidade do Token: Certifique-se de que os tokens são únicos e aleatórios para evitar adivinhação.
Expiração do Token: Defina um tempo de expiração razoável (por exemplo, 24 horas) para limitar a janela de vulnerabilidade.
Armazenamento Seguro: Armazene os tokens de forma segura no banco de dados, potencialmente usando hashing para maior segurança.


Criando a Visualização de Alteração de Senha
A visualização apresenta a interface do usuário para inserir uma nova senha. Usando templates do Thymeleaf, você pode criar um formulário fácil de usar.
Desenhando o Template change_password.html

Navegue até src/main/resources/templates/account_views/change_password.html:





		
		
			
			
Java
			
			
<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Change Password</title>
    <link rel="stylesheet" th:href="@{/css/style.css}">
</head>
<body>
    <div class="container">
        <h2>Change Your Password</h2>
        <form th:action="@{/update-password}" method="post">
            <input type="hidden" th:name="accountId" th:value="${accountId}" />
            
            <div class="form-group">
                <label for="newPassword">New Password:</label>
                <input type="password" class="form-control" id="newPassword" name="newPassword" required>
            </div>

            <div class="form-group">
                <label for="confirmPassword">Confirm Password:</label>
                <input type="password" class="form-control" id="confirmPassword" name="confirmPassword" required>
            </div>

            <button type="submit" class="btn btn-primary">Update Password</button>
        </form>
    </div>
    <script th:src="@{/js/jquery-3.4.1.min.js}"></script>
    <script th:src="@{/js/bootstrap.js}"></script>
</body>
</html>

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
				
						 
<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Change Password</title>
    <link rel="stylesheet" th:href="@{/css/style.css}">
</head>
<body>
    <div class="container">
        <h2>Change Your Password</h2>
        <form th:action="@{/update-password}" method="post">
            <input type="hidden" th:name="accountId" th:value="${accountId}" />
            
            <div class="form-group">
                <label for="newPassword">New Password:</label>
                <input type="password" class="form-control" id="newPassword" name="newPassword" required>
            </div>
 
            <div class="form-group">
                <label for="confirmPassword">Confirm Password:</label>
                <input type="password" class="form-control" id="confirmPassword" name="confirmPassword" required>
            </div>
 
            <button type="submit" class="btn btn-primary">Update Password</button>
        </form>
    </div>
    <script th:src="@{/js/jquery-3.4.1.min.js}"></script>
    <script th:src="@{/js/bootstrap.js}"></script>
</body>
</html>
 
					
				
			
		


Diagrama: Fluxo de Trabalho de Alteração de Senha




		
		
			
			
Java
			
			
graph TD;
    A[Usuário Solicita Alteração de Senha] --> B[Sistema Gera Token]
    B --> C[Enviar Token por Email]
    C --> D[Usuário Clica no Link de Reset]
    D --> E[Validar Token]
    E --> F[Mostrar Formulário de Alteração de Senha]
    F --> G[Usuário Envia Nova Senha]
    G --> H[Atualizar Senha no Banco de Dados]
    H --> I[Mensagem de Confirmação]

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
				
						 
graph TD;
    A[Usuário Solicita Alteração de Senha] --> B[Sistema Gera Token]
    B --> C[Enviar Token por Email]
    C --> D[Usuário Clica no Link de Reset]
    D --> E[Validar Token]
    E --> F[Mostrar Formulário de Alteração de Senha]
    F --> G[Usuário Envia Nova Senha]
    G --> H[Atualizar Senha no Banco de Dados]
    H --> I[Mensagem de Confirmação]
 
					
				
			
		


Características Principais

Interface Amigável ao Usuário: Design limpo e intuitivo para facilitar o uso.
Validação: Assegure que a nova senha atende aos padrões de segurança e que ambos os campos de senha correspondem.
Mecanismo de Feedback: Informe os usuários sobre atualizações de senha bem-sucedidas ou erros durante o processo.


Testando a Funcionalidade de Alteração de Senha
Após implementar o recurso de alteração de senha, testes rigorosos garantem sua confiabilidade e segurança.
Passos para Testar

Iniciar Password Reset:

Navegue até a página de forgot password.
Digite um endereço de email registrado.
Certifique-se de que um email com um link de reset contendo um token válido foi recebido.


Acessar Link de Reset:

Clique no link no email.
Verifique se a visualização de alteração de senha carrega corretamente se o token for válido.
Tente usar um token inválido ou expirado para confirmar o manuseio correto de erros.


Enviar Nova Senha:

Digite uma nova senha e confirme-a.
Envie o formulário e assegure que a senha seja atualizada no banco de dados.
Tente fazer login com a nova senha para verificar a alteração.


Casos de Bordas:

Teste com senhas não correspondentes para verificar a validação.
Tente múltiplas solicitações de password reset para assegurar a unicidade e manuseio do token.



Exemplo de Saída
Após alterar a senha com sucesso, o usuário deve ver uma mensagem de confirmação semelhante a:




		
		
			
			
Java
			
			
Your password has been successfully updated. You can now log in with your new credentials.

			
				
					
				
					1
2
3
				
						 
Your password has been successfully updated. You can now log in with your new credentials.
 
					
				
			
		


Trechos de Código com Comentários

Atualizando a Senha em AccountController.java:





		
		
			
			
Java
			
			
@PostMapping("/update-password")
public String updatePassword(
        @RequestParam("accountId") Long accountId,
        @RequestParam("newPassword") String newPassword,
        @RequestParam("confirmPassword") String confirmPassword,
        RedirectAttributes redirectAttributes) {

    if (!newPassword.equals(confirmPassword)) {
        redirectAttributes.addFlashAttribute("error", "Passwords do not match");
        return "redirect:/change-password?token=" + token;
    }

    Optional<Account> optionalAccount = accountService.findById(accountId);
    if (optionalAccount.isPresent()) {
        Account account = optionalAccount.get();
        account.setPassword(passwordEncoder.encode(newPassword));
        account.setPasswordResetToken(null);
        account.setTokenExpiry(null);
        accountService.save(account);
        redirectAttributes.addFlashAttribute("success", "Password updated successfully");
        return "redirect:/login";
    } else {
        redirectAttributes.addFlashAttribute("error", "Account not found");
        return "redirect:/forgot-password";
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
				
						 
@PostMapping("/update-password")
public String updatePassword(
        @RequestParam("accountId") Long accountId,
        @RequestParam("newPassword") String newPassword,
        @RequestParam("confirmPassword") String confirmPassword,
        RedirectAttributes redirectAttributes) {
 
    if (!newPassword.equals(confirmPassword)) {
        redirectAttributes.addFlashAttribute("error", "Passwords do not match");
        return "redirect:/change-password?token=" + token;
    }
 
    Optional<Account> optionalAccount = accountService.findById(accountId);
    if (optionalAccount.isPresent()) {
        Account account = optionalAccount.get();
        account.setPassword(passwordEncoder.encode(newPassword));
        account.setPasswordResetToken(null);
        account.setTokenExpiry(null);
        accountService.save(account);
        redirectAttributes.addFlashAttribute("success", "Password updated successfully");
        return "redirect:/login";
    } else {
        redirectAttributes.addFlashAttribute("error", "Account not found");
        return "redirect:/forgot-password";
    }
}
 
					
				
			
		



Explicação:

Vinculação de Senha: Garante que a nova senha e a confirmação correspondam.
Codificação de Senha: Usa passwordEncoder para hash seguro da nova senha antes de armazená-la.
Invalidando o Token: Limpa o token de reset e sua expiração após uma atualização bem-sucedida da senha.
Feedback ao Usuário: Fornece mensagens de sucesso ou erro apropriadas com base no resultado da operação.




Conclusão
Implementar uma funcionalidade de alteração de senha em uma aplicação Spring Boot é um passo crítico para garantir a segurança das contas de usuário e aprimorar a experiência geral do usuário. Este guia forneceu uma revisão abrangente, desde a configuração do projeto e atualização do modelo de conta até a implementação de controllers, gerenciamento de tokens, criação de visualizações e testes da funcionalidade.
Principais Lições

Segurança em Primeiro Lugar: Sempre priorize a segurança ao manusear credenciais de usuário e password reset tokens.
Experiência do Usuário: Desenhe interfaces intuitivas e responsivas para facilitar o gerenciamento de senhas de forma contínua.
Testes Rigorosos: Teste regularmente todos os aspectos do recurso para garantir confiabilidade e segurança.

Seguindo os passos delineados neste eBook, você pode implementar com confiança um recurso de alteração de senha seguro e eficiente em suas aplicações Spring Boot.
Palavras-chave: Spring Boot password change, Spring Boot password reset, Spring Security, password reset token, account security, Spring Boot tutorial, user authentication, Spring Data JPA, Thymeleaf forms, password update functionality.
Nota: Este artigo é gerado por IA.
Característica	Password Reset	Password Change
Propósito	Recuperar acesso quando a senha é esquecida	Atualizar senha enquanto está logado
Gatilho	O usuário inicia o reset através de um link enviado por email	O usuário inicia a alteração nas configurações da conta
Uso de Token	Utiliza o token de reset enviado por email	Pode não requerer um token se o usuário estiver autenticado
Considerações de Segurança	Alta, pois envolve verificação por email	Moderada, requer autenticação existente
Cenário	Recurso Aplicável
Usuário esquece a senha	Password Reset
Usuário atualiza a senha proativamente	Password Change
Violação de segurança requer atualização imediata da senha	Password Reset
Manutenção regular da conta	Password Change