Autenticação e Autorização com Spring Security, JWT Tokens e Roles

Oi pessoal sejam bem-vindos ao meu canal para quem não me conhece eu sou a Fê e no vídeo de hoje a gente vai aprender a como fazer a configuração do Spring Security nas nossas aplicações Spring e como fazer autenticação dos nossos usuários Então a gente vai criar a nossa tabela de usuários vamos fazer a verificação da senhas vamos gerar Token para os usuários que estiverem autenticados e também vamos fazer o controle de roles para cada usuário usuários admin vão ter mais permissões na nossa aplicação e usuários comuns não vão ter essas permissões E além disso

a gente vai usar a biblioteca jwt para fazer a geração dos nossos tokens e vamos entender a diferença entre uma autenticação estético e uma autenticação standless bom então dito isso sem mais enrolações Bora para o vídeo [Música] Então pessoal o projeto que eu trouxe aqui para a gente hoje fazer a configuração do Spring Security é um projeto bem simples Eu apenas trouxe esse projeto para a gente conseguir fazer essa configuração Mas vocês podem partir do vídeo daqui e fazer a configuração no projeto de vocês isso não importa muito mas caso vocês queiram clonar esse projeto

eu vou deixar o link do kit Hub aqui na descrição do vídeo bom o que que tem dentro dessa aplicação aqui né ela tem dois pontos de post que basicamente faz a listagem de todos os produtos que a gente tem no nosso banco de dados e adição de um novo produto no banco de dados e o nosso objetivo até o final do vídeo vai ser com que apenas usuários logados possam fazer a inquisição de get maping e apenas usuários que estejam logados e tem o role dia de mim ou seja são administradores consigam fazer a

postagem de um novo produto Então esse vai ser o nosso objetivo até o final do vídeo então vou abrir só para mostrar para vocês como é que tá funcionando os requisições hoje quando eu disparo uma requisição de get ele me lista todos os usuários e aqui eu não tô logada nada não tô mandando reder nenhum e quando eu disparo uma requisição de post ele retorna sucesso e a gente disparando aqui o get novamente a gente já vai ver que ele fez a adição desse produto no banco de dados então o nosso objetivo vai ser fazer

o controle da autenticação dessas duas rotas para que apenas usuários logados conseguiam consumir essas rodas e apenas o usuários que sejam admin consigam adicionar um novo produto no nosso banco de dados Então bora lá então a primeira coisa que a gente vai fazer é adicionar dependência do Spring Security ao nosso projeto e como é que a gente pode fazer isso bom a gente pode entrar no site do Spring me chaise e ele dentro do springite a laser a gente vai selecionar com o nosso projeto é um projeto maviver a linguagem é Java e não vamos

mexer mais em nenhuma configuração eu vou ver aqui em ex dependentes e eu vou procurar pela dependência do Spring e vou adicionar ela pronto apenas ela vou precisar Então vou vir aqui em Explorer e a gente vai visualizar o arquivo do punchesml que ele geraria aqui para nós e visualizando aqui a gente já consegue ver ó que ele adicionou duas dependências da dependência aqui do Spring boot Starter Security o springbut Starter teste e o Spring Security test springbut Starter já está lá na nossa aplicação Então o que a gente vai precisar adicionar é esse Spring

boot started Security e o Spring Security teste então eu vou copiar essas duas dependências essa aqui primeiro vou vir aqui no meu Intel DJ vou parar a execução da minha aplicação e vou entrar no meu arquivo punche x ml aqui dentro do meu arquivo pum XML eu vou colar primeira dependência vou voltar para o navegador vou copiar a segunda dependência que aquela dependência de testes vou voltar para o intelli vou colar aqui logo abaixo dessa dependência do Spring start Security e vou salvar agora a gente vai precisar fazer um Reload das nossas dependências para a

gente Garanta que o maven Tem instalado elas corretamente então vou vir aqui no canto direito da tela vou clicar aqui nesse botãozinho maven e ele vai abrir essa telinha aqui dentro de dependas a gente vai clicar nesse Reload helloud almeven prodigs depois que a gente fizer o Hallo a gente vai ver que ele adicionou mais duas dependências da nossa lista de dependências que foi o springbut Starter Security e o Spring Security teste Beleza agora Spring Security já tá instalado na nossa aplicação então eu vou iniciar minha aplicação novamente eu vou vir aqui no meu arquivo

Alfa aplication que é o nome da minha aplicação e vou clicar no botãozinho Verde aqui para fazer o Run da nossa aplicação pronto a minha aplicação já iniciou Então vou entrar no insumo e vou disparar de novo uma nova requisição e a gente vai ver que algumas coisas mudaram vou primeiro disparar a requisição de get a gente consegue ver aqui que o Spring já tá me retornando um código 401 ryze Ou seja eu não tô autorizada E se eu tentar fazer um post ele vai fazer a mesma coisa vai me retornar um 401 E lembra

que antes a gente estava conseguindo fazer essas requisições livremente então o que que aconteceu logo que a gente adiciono Spring Security como uma dependência do nosso projeto ele já cria essa camada de autenticação de fogo então ele já bloqueia todos da nossa aplicação e pede que o usuário seja autenticado antes que consiga fazer essas requisições só que aqui como é que a gente vai fazer essa autenticação né que ele tá pedindo a gente não adicionou nenhum novo aí de point etc bom o Spring Security já configura isso por padrão para gente então se eu voltar

aqui para o nosso inteligente e dê uma olhada no nosso terminal a gente vai ver que quando a aplicação Foi iniciada o Spring Security lokões locou isso aqui ó e Usain Generation e logou uma senha aqui para nós onde a gente vai essa senha bom o Spring Security por padrão ele configura autenticação através de login e senha então aqui no meu navegador eu vou tentar disparar uma requisição para o nosso loco host na porta 8080/prod Então vou ver aqui vou esperar a requisição e a gente consegue ver que logo quando eu disparei requisição para Barra

product ele já me redirecionou para esse barra login e ele tá me mostrando essa tela de login tudo isso aqui foi adicionado pelo Spring Security e aqui a gente faz o login com aquela senha que ele nos forneceu e essa senha é gerada aleatoriamente a cada vez que é iniciada a nossa aplicação e aqui tem um usuário de fogo que a gente pode usar para logar a nossa aplicação então se eu ver aqui colocar user e colar aquela senha que ele me ligou lá no terminal vou copiar ela aqui e vou colar no campo de

password a gente vai conseguir disparar a requisição para Barra brother que a gente consegue ver que ele nos liberou né autenticação e já tá nos mostrando aqui estágio de todos os produtos mas não era isso que a gente queria adicionar na nossa aplicação eu quero adicionar uma autenticação com tokens no meus agente points então eu quero fazer uma autenticação de usuário manda o usuário e senha via Wind Point eu valido esse usuário e senha e retorna um token através desse token o usuário vai poder fazer as próximas requisições para nossa aplicação Então a gente vai

precisar remover essa configuração padrão do Spring Security então adicionar a configuração que a gente deseja então agora para que a gente consiga ter usuários autenticados na nossa aplicação fazer a conferência do e-mail e da senha por exemplo a gente precisa ter uma forma de armazenar esses usuários Então vou criar uma nova tabela no nosso banco de dados que vai armazenar os dados dos nossos usuários Então vou vir aqui na minha pasta de my greations vou chamar ela de V2 porque eu já tive uma migration que criou a minha tabela de produtos eu vou chamar de

Create table e users eu vou colocar o comando SQL para criar uma nova tabela então Create table e users e aqui a gente tem que ter muito cuidado a gente não pode chamar essa tabela aqui eu tô usando post Então pode mudar de um banco de dados para o outro mas no postres a gente não pode criar uma tabela chamada user Isso é uma tabela especial do postres então a gente não pode fazer a criação então caso a gente queira armazenar usuários a gente precisa criar uma tabela chamada users para não ter conflito com a

tabela especial do post que o post usa para armazenar os usuários dele então aqui a gente vai ter que chamar de users não user Então a gente vai colocar quatro colunas nessa nossa tabela que vai ser o id o login a senha e qual é o role desse usuário se ele é um usuário normal se ele não admin ou qualquer outra rolo que vocês queiram adicionar depois então o meu Édi vai ser do tipo vai ser a primer aqui da minha tabela vai ser e o Nick então o único não pode ter repetido e note

no não pode ser vazio depois eu vou ter o meu login que também vai ser um texto aqui o login pode ser tanto um usuário quanto um e-mail por exemplo vai ser not no então não pode ser nulo E o Nick também tem que ser único não posso repetir por exemplo mesmo e-mail cadastrado então eu vou ter minha peça que também vai ser um texto e vai ser not no aqui eu não posso colocar E o Nick não posso fazer com que a senha sejam únicas dentro do meu banco de dados senão uma é uma

fragilidade né do meu sistema e por fim a gente vai criar a nossa coluna Road a minha coluna role vai ser do tipo Text e também não pode ser nula pronto aqui uma coisa muito importante eu tenho que parar a execução do meu programa antes de criar my grations não pode ter algum problema aqui eu dei sorte que eu não tinha salvado o arquivo ainda então ele não chegou a executar mas se eu tivesse dado um control S salvar do meu arquivo o Spring Security identificar um novo arquivo e o Flyer que é o a

biblioteca que eu tô usando para criação de migrations e a identificar esse novo arquivo de uma igreja já ia rodar e eu ainda não tinha terminado e declarar todas as propriedades da minha tabela então é muito importante quando a gente vai criar uma nova migration para execução do nosso programa e depois iniciar de novo e já tem vídeo aqui no canal explicando um pouco mais sobre o conceito de my greations e também implementando my rations Spring eu vou deixar o link aqui no card então aqui para fechar a minha o meu comando SQL para criação

de tabela Eu tenho que colocar aqui um ponto e vírgula no final senão ele vai dar erro de sintaxe pronto vou fechar tudo aqui mas toda vez que a gente cria uma nova tabela no nosso banco né quase toda vez a gente precisa criar uma entidade represente essa tabela também então a entidade vai ser o objeto que a gente vai manipular né os dados que estão dentro dessa tabela então aqui dentro da minha pasta domen eu vou criar um novo pacote que eu vou chamar de user e dentro desse pacotinho usa a gente vai criar

uma nova classe que vai representar a nossa entidade usuário então aqui eu vou criar uma nova classe chamada user Então a gente vai ter que colocar algumas anotações nessa nossa Classe A primeira coisa que a gente vai precisar fazer é indicar aquela representa uma tabela Então a gente vai usar anotação table do JPA aqui eu vou colocar nem igual e users vai ser Qual é o nome da tabela que essa entidade que representa então vou ter que colocar anotação entidade também qual é a entidade que ele representa também entidade e users e aqui eu vou

colocar algumas anotações do lomboque para fazer a geração dos meus gateres etc de forma automática e a geração dos meus constructors também então só vou colar aqui pronto todos os as anotações que a gente precisa e agora a gente vai precisar de aqui quais são né as propriedades que esse meu muser tem então primeiro ele tem um ID que é uma string depois a gente vai ter um Private também é uma string que é o nosso login um Private string também que a nossa password e por fim a gente vai ter a nossa Road essa

nossa role eu vou criar agora como uma string mas ela não vai ser uma string a gente vai criar um e-um para enunciar todos os tipos de roles que podem ter dentro da nossa aplicação mas primeiro Vamos só fazer a configuração Inicial aqui da nossa classe user então a gente cria o nosso serum de guzer Road e aqui essa nossa classe user vai ter que implementar uma outra classe que se chama e user the Tails essa classe user the Tales vem de dentro do Spring Security e ela é usada para a gente identificar uma classe

que represente um usuário que vai ser autenticado na nossa aplicação então quando a gente coloca aqui implementos ele já vai nos indicar um erro porque a gente precisa implementar os métodos que estão declarados nessa interface user the Tales Então se a gente colocar o mouse aqui em cima ele vai nos mostrar essa lâmpadazinha aqui e vai dizer ó implemento metas Então a gente vai selecionar todos esses métodos aqui que tem que ser implementados de acordo com a interface então a interface lá que os príncipe definiu quando a gente vai implementar uma classe de user the

Tales ela define né que a gente tem que ter esses métodos Então a gente vai definir esses métodos eu vou dar um ok aqui e ele gerou todos os métodos automaticamente para nós e aqui a gente vai fazer algumas mudanças a gente consegue ver aqui que ele colocou tudo retorno falso aqui seria para a gente fazer as validações dentro desses métodos então aqui ó para ver se o usuário está ele está ativo se a credencial não Tá inspirada se o usuário não está bloqueado se não está inspirado isso aqui a gente não vai adicionar hoje

algo mais complexo um pouco mais avançado no vídeo a gente vai fazer uma autenticação básica com login e senha e robôs Então tudo isso aqui a gente vai colocar para retornar true a gente não vai fazer nenhuma validação e vai ser como se o meu usuário estivesse semprenabot a credencial Nunca tivesse inspirado ele nunca tivesse bloqueado enfim todos esses essas opções aqui mas aqui nesse método get user name a gente não vai retornar no falso aqui a gente vai retornar o login do nosso usuário Então a gente vai colocar aqui retorne login que é o

que representam e username do nosso usuário né que aqui pode ser o e-mail pode ser um nickname enfim que vocês quiserem para sua aplicação e aqui a gente consegue ver que tem mais um método que ele adicionou que foi o get autorits Isso aqui vai ser quando o Spring Security for consultar uma entidade Nossa para ver quais são as rowes que esse usuário aqui tem então ele vai chamar essa função então é aqui que a gente tem que retornar Quais são as roles do meu usuário para que os príncipe que ele te consiga tomar as

decisões corretas de acordo com a role desse usuário quais seriam as decisões corretas bloquear ou não bloquear o post lá no nosso indicante criar um produto por exemplo então aqui como é que a gente vai fazer a gente vai precisar do nosso enum de roles então eu vou criar agora a nossa classe e use Rose então aqui dentro da minha do meu pacote user eu vou criar uma nova Java glass e eu vou chamar de user Road e vai ser do tipo e-um aqui dentro eu vou criar dois anúncios Primeiro vai ser admin e eu

vou colocar aqui dentro admin e o segundo vai ser user e aqui dentro vou colocar user que é string que representa essa Road e aqui eu tenho que colocar um ponto e vírus depois eu vou precisar criar um atributo dentro dessa classe que vai ser um atributo privado vai ser do tipo string e vai se chamar e por fim a gente vai definir um Construtor para essa nossa classe user Road recebe uma string que é o nosso role e o disco na verdade esse Público aqui não precisa porque como é um menu a gente não

tem isso aqui é só colocar e usar ele já vai identificar e aqui eu vou adicionar um outro método que vai ser um método gather para pegar então aqui eu vou colocar um Publique string e ele vai fazer um return pronto que ele tá retornando a role que ele representa agora lá na nossa classe user a gente vai trocar o atributo aqui role para um rio pronto e aqui dentro do nosso método get ao Torrents a gente vai retornar essas roles de acordo com a role do usuário mas aqui a gente vai ter que fazer

um depara das rules da nossa aplicação com as broas do Spring Security porque o Spring Security já tem definido né mapeado Por padrão algumas roads então e aqui ele espera receber uma coleção de rules aquele não espera receber só uma porque por exemplo o usuário que é de mim ele também tem as permissões de um usuário normal o usuário que é sei lá chefe ele tem as permissões de mim e de usuário normal então ele sempre tem usuário que tem que estar acima da ilha aqui ele tem sempre as permissões dos usuários que estão abaixo

né ou não a gente pode mostrar montar nossa forma de Rose de hierarquias mas aqui a gente precisa Collection para mostrar quais seriam todos os acessos as prevenções que esse usuário tem de acordo com a role dele então aqui eu vou fazer uma verificação eu vou fazer eas o nosso é nunca a gente acabou de criar a gente vai retornar uma lista neste ponto off e aqui dentro a gente vai distanciar as roads do Spring Security Então vou colocar aqui New Simple Grant que isso aqui essa classe que vem do Spring Security e aqui dentro

eu vou colocar admin e eu vou retornar mais uma role aqui dentro então quando o cara for admin ele vai ter as permissões dia de mim e as permissões de usuário normal Então vou colocar New Simple Grant Security e aqui eu vou colocar Road user caso contrário caso ele não tenha a role dia de mim aqui na nossa aplicação a gente vai retornar só a road user Então vou retornar aqui ELS retorn list.of Então aqui tem que ser uma coleção Então a gente vai ter que sempre Retornar assim em formato de lista New Simple Grant

autority pronto e pronto agora a gente já tem a nossa entidade que representa o nosso usuário né a nossa tabela usuário e que também representa um usuário da autenticação da nossa aplicação então a gente fez o link com a nossa tabela através aqui das anotações do JPA e também a gente já fez o mapeamento para o Spencer para que a gente consiga usar essa classe depois para fazer a manipulação os nossos usuários pessoal eu passando aqui rapidinho para lembrar vocês de deixar seu like se inscrever aqui no canal se você tá gostando do conteúdo até

aqui porque o like a inscrição de vocês são muito importante para apoiar o canal e permitir que eu continue produzindo esses conteúdos de programação de forma gratuita bom dito isso bora continuar o vídeo e agora a gente vai precisar criar um repostri para consultar os usuários no nosso banco de dados Então vou vir aqui na minha pasta repostres e vou adicionar um novo repost que eu vou chamar de user repouster esse nosso repouso vai ter que estender a classe JPA repost e aqui ele recebe por parâmetro dois tipos primeiro o tipo da entidade dessa tabela

que aqui é o nosso user né que seria classe que seria entidade da nossa tabela então o tipo da chave primária a chave primária no nosso caso foi o ID do usuário e ela é do tipo de string pronto e aqui o meu repouso ele não tem que ser uma classe sim interface salvei e agora a gente vai já vai declarar um novo método aqui dentro que vai ser um método para consultar o usuário pelo login o login seria o e-mail nickname enfim o que a gente decidir para nossa aplicação então aqui eu vou declarar

um novo método Mas vai ser um método que não tem implementação o JPA por padrão quando a gente declara um método com uma nomenclatura padrão ele já consegue identificar através da assinatura do método a currie SQL que ele vai ter que rodar para fazer essa consulta né ou essa inserção Enfim então aqui a gente vai declarar um novo método e esse método de find by login vai ser usado pelo Spring Security para consultar os usuários Então a primeira coisa O nome desse método vai ser find by login quando a gente coloca find by Ele já

sabe que vai precisar fazer uma Curi pelo próximo parâmetro quando a gente passou login Então faz login ele vai fazer na coluna login né filtrando pela coluna login com parâmetro passado né que tiveram médico um parâmetro passado e aqui o parâmetro do passado vai ser uma string que a gente vai chamar de login então aqui de novo pode ser o link name pode ser o e-mail enfim que a gente preferir salvar no nosso banco de dados para representar o login no nosso usuário e esse método ele vai ter que retornar alguma coisa e o que

que ele vai retornar aqui nesse caso ele vai retornar um user the Tales isso aqui é super importante que a gente coloque que ele vai retornar um Muse the Tales porque vai ser usado pelos princecurity depois e agora a gente vai criar o nosso primeiro service que vai ser o nosso authentication service esse serviço vai ser chamado automaticamente pelos print Security toda vez que um usuário precisar se autenticar Então dentro dessa Classe A gente vai definir alguns métodos algumas coisas que vão ajudar o Spring Security a identificar o modo como a gente quer fazer essa

autenticação então aqui eu vou criar uma nova um novo pacote que eu vou Services Então vou colocar todo Services da minha aplicação aqui dentro e aqui dentro eu vou criar uma nova classe que vai ser autorization Service para que o Spring me identifique que essa classe representa um serviço da nossa aplicação a gente vai ter que colocar a notação de service aqui em cima da classe e para que o spinning Security identifique que essa classe é o nosso autorization service que ele vai ter que chamar de forma automática a gente vai ter que fazer essa

nossa classe implementar uma classe do Spring Security que é a classe e user the Tales service e aqui a partir do momento que a gente implementar ele vai nos lançar um erro dizendo que a gente não tá implementando os métodos que são necessários né que são definidos Então a gente vai ver aqui vai colocar implemento e esse método que ele quer que a gente implemente é o load user by E username então é que toda vez que alguém tentar se autenticar na nossa aplicação os princípios que a gente vai ter que ter uma forma de

consultar esses usuários né só que ele não sabe que a gente criou uma tabela no banco de dados ou que a gente está buscando numa outra p. enfim que a gente preferia que a gente poderia pegar os nossos usuários lá no no Google por exemplo se a gente tivesse usando uma autenticação de terceiros então aqui dentro desse método vai ser hologar onde a gente vai fazer a consulta dos nossos usuários pro Spring Security então a gente Abstrai isso para ele ele só vai chamar esse método ele não vai saber o que a gente tá fazendo

por baixo dos panos para pegar esse usuário para carregar o usuário pelo username então aqui eu vou precisar que essa minha classe eu tente autorization service tenha uma Instância do meu repouso e para que eu consiga fazer a consulta no meu banco de dados então aqui eu vou declarar um novo atributo autoarte para que o Spring Jet automaticamente essa dependência que vai ser do tipo e user repousar eu vou chamar de repouso e aqui dentro desse meu load user by username eu vou retornar e aqui eu vou passar o user name que ele recebeu por

parâmetro pronto só isso dessa forma o Spring Security já vai ser capaz de consultar os nossos usuários no nosso banco de dados na tabela que a gente criou e agora a gente vai desabilitar as configurações padrões do Spring Security Então a gente vai tirar aquele aquela autenticação que ele tinha adicionado a nossa aplicação aquela tela de login enfim que ele tinha criado e a gente vai fazer a nossa configuração né de autenticação stateles através de tokens E para isso a gente precisa fazer a configuração do Spring Security Então vou criar um novo pacote aqui na

nossa aplicação gente esses pacotes aqui que eu tô criando né os meus packets vocês podem usar os nomes que vocês preferirem eu tô usando os nomes que eu estou mais habituada que eu costumo utilizar mas aqui vai da preferência de vocês e da forma como vocês organizam seus projetos Então vou criar aqui um novo pacote eu vou chamar de infra dentro desse meu pacotinho que eu vou criar um novo pacote que eu vou chamar de Security então aqui vai ficar toda a infra relacionada a minha segurança da aplicação e aqui dentro eu vou criar uma

nova classe que eu vou chamar de configuration Então as configurações de segurança da minha aplicação Essa é minha classe que eu te configuration a gente precisa indicar para o Spring que ela é uma classe de configuração e a gente também precisa indicar para Spring Security que aqui a gente tá desabilitando as configurações padrões dele e a gente tá declarando as nossas configurações e como é que a gente faz isso através de anotações Então vou vir aqui vou colocar a notação configuration para indicar para Spring que essa é uma classe te confuração e aqui eu vou

colocar enable webcurity o que que eu tô dizendo para o Spring para o que que eu tô dizendo aqui olha esse príncipe habilita aqui a configuração do webscurity e eu vou configurar dentro dessa classe entendeu É isso que a gente tá fazendo então o primeiro método que a gente vai declarar aqui é o Security Filter Chan o que que esse método representa significa corrente de filtro de segurança então através desse normalmente já consegue identificar corrente de filtro de segurança Então seria a corrente de filtros que eu vou aplicar minha requisição para fazer a segurança da

minha aplicação então o que que seriam esses filtros filtros vão ser métodos que a gente vai chamar para fazer validações nesse usuário que tá fazendo a requisição na nossa aplicação e validar se ele está apto né a fazer essa requisição se a gente pode liberar essa requisição ou não então por isso que se chama Security Filter Chan a gente está declarando a nossa camada a nossa corrente de filtros para nossa aplicação Então vou declarar aqui esse nosso método e esse é o nosso método vai retornar um Security Filter Chan também então o Spring Security precisa

disso o nome do nosso método vai ser seguir esse nosso método recebe por parâmetro um http Security DP Security dentro desse Meu método a gente vai precisar fazer algumas configurações nesse nosso http Security então aqui eu vou colocar return http Security nesse tipo pensei que a gente vai adicionar as nossas configurações para o Spring Security então primeira configuração que a gente vai fazer uma configuração padrão então vou colocar aqui ponto csrf aqui eu vou receber um objeto csrf ir com esse objeto eu vou colocar csrf ponto de zebu para desligar essa configuração agora a próxima

configuração que a gente vai adicionar é indicar para o Spring que a gente quer fazer uma autenticação para quem não sabe a diferença de autenticação stakeless state eu já fiz um post lá no meu Instagram explicando um pouquinho mais eu vou deixar o link aqui no card também mas é basicamente não tem indicação a gente armazena informações da sessão do usuário então o nosso servidor armazena todas as sessões que estão ativas e quando a gente tá falando de autenticação stakeless a gente só faz autenticação é Toke então a gente cria um Token para o usuário

depois de validar usuário e senha retorna para ele com esse topo ele consegue fazer as próximas requisições a gente valida se esse token é válido se ele foi criado por nós então libera a requisição para o usuário caso contrário a gente não libera e hoje o padrão mais comum na web a gente vê autênticações stakelas que é o padrão das aplicações brecha usar autenticação States a gente não armazena sessão a gente não guarda informações da sessão no nosso servidor a gente sim só passa um token que seria tipo assim uma palavra passe né Para que

o usuário consiga depois usar esse Toquinho que a gente passou para ele para fazer as próximas requisições então para a gente fazer essa configuração e ativar autenticação stayley a gente vai colocar Fashion esse Fashion weenerys passar um objeto objeto fashion a gente vai pegar esse objeto vamos fazer fecha um ponto fecha um praty polos Então a gente vai declarar aqui qual é a nossa política de sessão e a nossa política de sessão é sem guardar estado e aqui a gente já pode colocar ponto Build para criar o nosso objeto Security Filter Chan e aqui a

gente não pode esquecer de colocar anotação arroba bim para que o Spring consiga estanciar a nossa classe e agora eu vou Executar a nossa aplicação novamente para a gente ver se mudou alguma coisa desde a nossa última execução porque lembra que quando a gente adicionou o Spring Security ele tinha bloqueado todas as nossas requisições e não permitia mais que a gente fizesse nenhuma requisição sem estar autenticado usando aquele usuário de fogo e aquela senha que ele gerava a cada inicialização então agora vamos verificar se com essas configurações que a gente fez ele passou a liberar

as nossas requisições Mas ele deu um erro aqui iniciando deixa eu ver o que que foi ah isso aqui foi lá na nossa classe de usuário eu esqueci de colocar algumas configurações então aqui em cima da nossa propriedade a dia a gente precisa fazer umas configurações para indicar para pa que esse aqui é o atributo que representa a chave primária lá na nossa da nossa tabela então aqui eu tenho que colocar anotação @idi e eu também preciso colocar aqui esse é um valor gerado automaticamente então generated beloy e a gente tem que passar Qual é

a estratégia de geração desse valor então stretud e aqui eu vou colocar Generation Type ponto o ID Então eu quero que esse ID seja gerado como o ID toda vez que a gente criar um novo usuário Então agora eu vou Executar a nossa aplicação novamente vamos ver se ele vai inicializar sem problemas pronto a minha aplicação já iniciou então eu vou abrir o nosso insônia e vou disparar agora uma nova aquisição get antes ele tava me retornando esse 401 rised e agora a gente vai ver se ele liberou essa requisição Então como a gente fez

aqui a nossa configuração própria do Spring Security e aqui a gente não tá fazendo controle nenhum a gente só pediu para ele ó dá para mim as configurações que eu vou configurar e aqui nas nossas configurações a gente basicamente diz que a gente quer uma autenticação mas não fez nenhum desse controle então você tem que passar a liberar todos os requisições novamente Então vou disparar que uma inquisição de get Pronto agora já tá deixando eu passar retornando 200 Ok e listando todos os produtos então agora a gente vai fazer a configuração para fechar novamente esses

endpoints e fazer o controle através do nosso usuário e senha e das roles que a gente criou Então a gente vai adicionar mais uma configuração aqui que vai ser autorais O que que a gente está declarando aqui a gente está declarando Quais são os nossos requisições do http que a gente quer que seja uma autorizadas autenticadas então aqui a gente também vai receber um objeto que vai chamar autorais e esse objeto autoraise a gente vai poder fazer matches das urls que estão sendo chamadas para ver para cada URL Qual é a regra que eu quero

seguir então vou colocar aqui requestres que seja do tipo post para o end point/prodate eu quero que o usuário tenha aqui eu tenho que colocar o parênteses para fechar esse meu outro ryzed aquele tá dando um erro Ah foi porque eu coloquei um parênteses a mais aqui então vou tirar pronto e agora para todo o resto das requisições então Anne requests todas demais que não forem essas eu quero que esteja autenticado apenas então autenticado vai ser o usuário normal que fez login com um e-mail e senha independente da Row só preciso que ele esteja autenticado

pronto dessa forma a gente já bloqueou novamente as nossas requisições então aqui eu vou dar um Clear All vou inicializar de novo novamente a nossa aplicação e vou tentar disparar novamente uma requisição e agora a gente vai ver que ele vai passar a retornar o 401 novamente mas não por causa da configuração padrão do Spring mas sim porque a gente configurou que a gente quer que esses agente ponte estejam privados só possam ser chamados quando usuário esteja autenticado vou abrir meu insônia vou disparar novamente a requisição e agora ele me mandou um 403 Forb então

eu tô proibido de chamar essa requisição porque porque eu não mandei token nenhuma eu não estou autenticada e agora a gente vai fazer esse controle e agora a gente precisa ter uma forma de validar se o nossos usuários estão autenticados para que eles consigam acessar esses que a gente acabou de privar Mas para que a gente consiga validar seus usuários estão autenticados a gente precisa de um endpoint de autenticação Então vai ser o endpoint onde o usuário vai fazer o login onde ele vai passar para nós o e-mail e a senha por exemplo a gente

vai validar se está ok se estiver ok a gente vai retornar um token e validar esse usuário então aqui dentro de controllers eu vou criar uma nova um novo arquivo que eu vou chamar de authenticgation Controller que é o Controller de autenticação aqui dentro desse meu Controller eu vou colocar anotação de wrest Controller para indicar que ele é um controle rest e request mapping para mapear além de point a qual esse Controller vai ser chamado e aqui dentro eu vou colocar Alfa então [Música] e aqui dentro de doman dentro do meu user eu vou criar

um novo record que eu vou chamar de authentication de tio esse meu authentication de Teen vai ter só dois atributos que vai ser uma string que é o meu login e uma string que é o meu password e aqui no meu controle eu vou importar esse recorte que a gente acabou de criar E aí agora a gente vai ter que ter uma forma de validar se essa senha e esse e-mail existem em nosso banco de dados né se esse login existe o nosso banco de dados e se a senha passada por parâmetro corresponde a senha

que passava lá no banco de dados porém não é uma boa prática a gente salvar no nosso banco de dados a senha do usuário como uma stream então Digamos que o meu login seja Fernanda Keeper e a senha que eu criei para mim foi um dois três quatro cinco seis sete oito nove não é uma boa prática eu salvar diretamente essa string lá no meu banco de dados colocar lá string 1 2 3 4 5 6 7 8 9 é um padrão a gente fazer um hash dessa senha Então a gente vai criptografar essa senha

então salvar essa senha no banco de dados e depois quando a gente quiser consultar a gente criptográfica senha e compara com a senha lá no meu banco de dados Então as nossas senhas dos bancos de dados vão estar salvas em formato de hash Então a gente vai precisar do Spring Security aqui que ele nos ajude para a gente fazer essa verificação do login da senha do usuário então para isso a gente vai precisar declarar aqui uma nova variável que eu vou chamar de username password e aqui a gente vai criar uma nova Instância da classe

e user name password authentication token essa classe aqui vem do Spring Security e ela recebe por parâmetro o login do usuário e a senha lembra que antes a gente configurou lá para o Spring Security como é que ele consultava os usuários no banco a gente forneceu para ele uma Instância do repouso Então agora ele vai fazer tudo isso automático e vai usar essa Instância do repost para fazer essa consulta e agora a gente vai ter que autenticar esse usuário essa senha que a gente criou com Spring Security então aqui eu vou criar uma nova variável

chamada Alf e aqui eu vou precisar usar o authentication Manager que é fornecido pelo Spring Security então eu vou criar aqui um novo atributo na minha classe que vai ser autor arde vai ser injetado pelo próprio Spring e esse atributo vai ser do tipo authentication Manager e aqui eu vou chamar de authentication manager esse authentication Manager 10.tetication menos a gente vai chamar a função authenticate e essa função Authentic recebe um parâmetro que é o login e a senha juntos né formados como um token então que seria esse nosso username password esse método aqui authenticate recebe

por parâmetro 1 e user name password token que é esse aqui que a gente acabou de criar na linha de cima usando a classe e user name password Art e agora que a gente já conseguiu autenticar eu vou colocar aqui um retorno ponto ok Ponto build só que aqui a gente também precisa indicar para o Spring Quem é essa authentication Manager porque aqui a gente só declarou uma classe desse tipo que ela é do tipo authentication mas a gente não indicou da onde ele tem que pegar ela e a gente vai fazer isso através da

nossa classe de Security a gente vai adicionar outra configuração então aqui a gente vai declarar um novo método público que vai retornar um autistation Manager e eu vou chamar de authentication manager também e esse é o authentication Manager recebe por parâmetro um authentication configuration que eu vou chamar de authentication com figuration E aí aqui a gente vai retornar esse authentication configuration ponto get authentication Manager só para pegar Instância de authentication manager aqui do Spring Security e é aqui a gente vai colocar a roupa bem para que o Spring e identifique essa classe aqui e consiga

fazer a ingestão de dependência e agora porque ele tá me indicando um erro porque esse authenticgate autentication Manager pode lançar uma exceção quando ele não encontrar nessa Estância então aqui a gente vai adicionar isso na assinatura do nosso método a gente vai colocar aqui reception e aí pronto ele vai parar de me indicar o erro só que como eu falei para vocês a gente vai salvar nossa senha no banco de dados criptografada a gente não vai salvar string pura e a gente precisa informar para o Spring para o Spring Security que ele vai precisar fazer

essa transformação então para isso a gente vai adicionar mais um método de configuração aqui na nossa classe que eu te configuration Então vou aqui vou declarar um novo método público que vai retornar um password em colder e eu vou chamar esse método de passwordin code ele não vai receber nada por parâmetro e ele vai retornar um mil bcript password encontra o que que esse becript passwordin coder é bom ele é uma classe que o Spring Security nos fornece para fazer criptografia das senhas né o das informações que a gente deseja então ele usa algoritmo de

hashi conhecido por exemplo Shadows 56 eu não me lembro exatamente qual é o que o becript utiliza então ele utiliza um algoritmo de resto conhecido faz o resto dos dados e faz o Decode também então ele utiliza um algoritmo de resto conhecido para fazer o resto dos dados e transformar os dados em dados criptografados para que a gente salve no nosso banco de dados por exemplo de forma segura e aqui a gente não pode esquecer de colocar anotação @bim para que o Spring faça a injeção correta desse método aqui para que ele seja utilizado né

No momento que a gente precisa então agora o Spring já vai conseguir fazer a verificação da senha do nosso usuário como é que ele vai fazer isso ele vai usar esse bcript passwordin colder que a gente passou para ele para incriptografar sem aquele receber por parâmetro e comparar com o resto da senha que já tem lá no banco de dados então toda vez que a gente for registrar um novo usuário a gente vai rachar sua senha a gente vai esquecer a senha normal a gente vai hackear essa e vai salvar o hash lá no banco

tirados toda vez que a gente for identificar o usuário a gente vai pegar a senha dele nos passou por parâmetro fazer o resto dela também e comparar com o resto que a gente tem lá no banco de dados se os restos forem Iguais significa que a senha é igual porque isso é um padrão dos algoritmos de hashi com a mesma entrada a gente gera sempre a mesma saída para a gente conseguir fazer essa validação Então é assim que o Spring vai fazer então ele vai chamar aquele nosso backcript passwordin coder lá e vai chamar o

método de encontro então aqui se a gente entrar aqui no nosso passwordin Condor e colocar aqui um ponto A gente vai ver que ele tem esse método aqui em code e vai ser esse método aqui em code que seria criptografar né que o Spring vai chamar para fazer a comparação das senhas posteriormente mas aqui a gente só criou um método de login então nosso usuário Por enquanto só consegue logar na nossa aplicação a gente ainda não consegue criar novos usuários então aqui embaixo eu vou declarar mais um método que vai ser do tipo post também

então vou colocar post map só que em vez de login eu vou chamar de register para a gente registrar um novo usuário e aqui eu vou também retornar só que eu vou chamar de redster aqui a gente também vai receber as informações pelo Body Então a gente vai colocar aqui o request body@vellite para fazer as validações e aqui eu não vou usar o mesmo de Tião porque no corpo da hora de registrar um novo usuário a gente vai receber o role desse usuário também né Qual é a role desse usuário então aqui eu vou chamar

de register do tio seria o de Tião para fazer o registro de um novo usuário e eu vou criar aqui dentro do domand e usuários também então vai ser um novo record Então vou chamar de resister de tio dentro desse meu RedTube a gente vai ter as mesmas coisas que tinha no nosso authentication que é usuário e só que a gente vai ter mais um parâmetro que vai ser uma string que vai se chamar de role que é role que esse usuário vai possuir E aí aqui a gente vai importar o nosso register pronto e

agora a gente vai precisar primeiro verificar se esse login que está tentando ser cadastrado né Por exemplo se fosse um e-mail um nickname se ele não existe no banco de dados caso ainda não exista a gente pode fazer o cadastro desse novo usuário então aqui a gente vai precisar declarar mais uma dependência da nossa classe que vai ser o nosso repousor que aqui eu vou chamar de user repousters pronto e aqui dentro do meu método rexter eu vou fazer um for diferente de nu Ou seja caso exista alguém já no banco com esse login eu

vou retornar um responde então vou retornar um status de Bad request caso contrário quase eu não encontre ninguém no banco de dados com esse login quer dizer que a gente pode fazer o registro desse novo usuário então aqui eu vou criar uma nova variável como eu chamar de increpted password porque lembrando a gente não vai salvar a senha que foi passada pelo usuário sim o resto dela e aqui eu vou fazer um mil bcring code e eu vou passar deeira ponto password dessa forma a gente vai pegar o resto da senha do usuário e agora

eu vou criar uma nova variável e user vai ser o meu New youser e aqui eu vou colocar New e user passando por parâmetro para o Construtor o dele é ponto login então ele tá dizendo que ele não tá encontrando um Construtor na classe user que receba 13 Strings por parâmetro E por que isso porque na hora que a gente definiu os construtores da nossa Classe A gente colocou aqui com unboxing então um Construtor que não receba nenhum argumento e ao Argos um Construtor para essa classe que vai receber todos os parâmetros né Então quais

seriam todos os parâmetros o id o login a senha e o Broly e aqui a gente não tem um Construtor que receba só o login a senha e o role Então a gente vai ter que definir isso aqui dentro aqui eu vou colocar Public e user vai receber por parâmetro uma string que é o login uma string que é a senha e um user que é o meu Road aqui eu não vou receber o role como uma string e agora a gente já vai mudar isso lá no nosso controle para dar certo então aqui meu

desconto login vai receber login vai receber meu password e desse ponto role vai receber o meu role e agora lá no nosso authentication controle ele vai indicar um erro porque esse meu dedo é ponto role é do tipo string então no meu RedTube em vez de receber uma string eu já vou dizer aqui que esse aqui é do tipo youser Road caso não seja ele vai lançar uma exceção Mas aí tem que lançar uma exceção mesmo porque a gente precisa receber uma role válida então voltando aqui para o nosso controle a gente já pode continuar

a criação do nosso usuário e para a gente salvar de vez esse nosso usuário no banco de dados basta a gente fazer desse ponto repoas e passar por parâmetro à distância desse novo usuário que a gente acabou de criar e aqui eu já posso retornar um respondente ponto ok Ponto B e dessa forma a gente finaliza o nosso end Point para criação de um novo usuário só que agora a gente vai ter que fazer uma alteração no nosso Security configurations porque porque lembra que aqui a gente tinha bloqueado a requisição post pro wendpoint/prodax apenas para

admins e todas as outras requisições a gente pediu que fosse o usuário autenticado só que aqui no momento de fazer login por exemplo usuário ainda não vai estar autenticado então qualquer usuário pode disparar uma requisição de login isso não significa que qualquer usuário vai conseguir fazer login mas o ponto é que eu quero que a minha aplicação processa essa requisição de login eu não quero que bloqueie o usuário por ele não estar autenticado então aqui no nosso Security Filter Chan a gente vai ter que adicionar essa configuração e como é que a gente faz isso

a gente vai adicionar mais um request Matters então aqui antes do requestres do Bar Brothers eu vou adicionar um request metas para o nosso de autenticação então vou colocar leite Pimenta ponto post Então as minhas duas requisições ali são requisições de post e aqui eu vou passar para o parâmetro ao URL do endpoint então é barra Alf barra login e aqui eu vou colocar permite ou então Vou permitir que qualquer pessoa faça requisição para esse índio Point e a mesma coisa eu vou fazer para o Point de redster porém eu vou fazer isso só para

a gente conseguir testar aqui porque o ideal é que o nosso a gente Point de register então para criar um novo usuário também seja bloqueado e também tem a permissão só para de mim por exemplo porque isso porque senão qualquer usuário vai poder ir lá criar um novo usuário com um role admin E aí adicionar um novo produto na nossa aplicação e esse não é o nosso objetivo então normalmente como é que a gente faz para criar o primeiro usuário a gente cria um primeiro usuário na mão lá no banco de dados então a gente

cria um usuário de mim registrar no banco de dados e a partir desse inicial a gente cria os demais que aí vão ter as permissões para registrar mais usuários e para registrar os produtos mas aqui no caso eu vou permitir todas as requisições para o registro para a gente conseguir testar aqui vim Sonia e disparar os requisições para criar os nossos usuários e pronto com essa configuração feita eu vou dar um Reload na nossa aplicação para aquele inicie novamente com todas essas alterações que a gente fez só para garantir que ele atualizou enquanto isso eu

já vou abrindo aqui o link Sônia para a gente disparar uma nova requisição então aqui eu vou criar uma nova requisição do tipo post que vai ser para a gente Point de registrar um usuário então aqui vou ver barra Alf barra register e aqui no corpo da minha requisição eu vou mandar as informações desse meu usuário então primeiro eu vou mandar o login que vai ser Fernanda Keeper a minha senha que vai ser um dois três quatro cinco seis sete oito nove e por fim um role que vai ser admin e eu vou disparar essa

requisição pronta Ele já que me retornou um 200 Ok então vou criar uma nova requisição aqui post para a gente fazer o nosso login Então vou usar base url/alf/login vou mandar um corpo que é um Jason e nesse Jason vou botar basicamente o que a gente mandou aqui na requisição para registrar um novo usuário só que eu vou tirar esse atributo de role e vou mandar só o login e assim vou te esperar a requisição e ele já me retornou aqui um 200 Ok ou seja ele conseguiu verificar esse meu login e a senha que

eles estavam condizentes se eu mandar aqui uma senha que não é a mesma que eu tinha registrado por exemplo eu vou mandar aqui 99999999 vou disparar de novo a inquisição e ele me retornou 403 forbida porque a gente não teve um match da senha para esse usuário aqui esse login então o nosso login É registro do nossos usuários está funcionando e agora a última etapa que falta a gente fazer é depois que o usuário fizer o seu login a gente retornar para ele um token então criar um serviço que vai validar se esse token está

válido ou não para que a gente libere as próximas requisições para o endpoint de post para registrar um novo produto e Proerd Point get para listar os produtos então agora para que a gente faça a geração do Token retorne para ele na requisição de login retornar para o nosso usuário a gente vai precisar usar uma biblioteca para geração de tokens e a biblioteca que a gente vai usar aqui hoje é o jwt Então como é que a gente vai instalar o jwt a gente vai procurar no Google por jwt authentication e vamos entrar aqui no

site do jwt e aqui dentro a gente vai vir em Library então aqui vai ter listado todos os as bibliotecas disponíveis para diferentes linguagens de programação e quais são os algoritmos de restos disponível nessas linguagens então a linguagem que a gente está utilizando é o Java então aqui eu vou vir aqui e filtrar por Java pronto assim que o filtro aqui ele já me mostra quais são as bibliotecas disponíveis que eu posso instalar na minha aplicação para implementar autenticação com token jwt e aquele me mostra também quais são os tipos de hash que cada uma

dessas bibliotecas possui e a biblioteca a gente vai utilizar é a própria biblioteca do Alpha zero que é o Java jwt Então a gente vai clicar aqui para entrar no repositório dessa biblioteca e aqui no próprio repositório da biblioteca ele vai nos mostrar como a gente faz a instalação dessa dependência e aqui com maven e aqui com o Grid Então a gente vai copiar aqui a declaração da dependência com meven que é o que a gente está utilizando para gerenciar as nossas dependências vamos voltar lá para o intelly Jay e dentro do nosso arquivo Ponche

XML a gente vai colar essa nova dependência Então vou vir aqui Vou colocar depois da dependência do unboxing eu vou colar aí ele já vai me mostrar que uma setinha para fazer um Reload das dependências com MA então vou clicar aqui para ele fazer o Reload esse Reload vai ser para aquele instale essa nova dependência que a gente adicionou eu vou parar o servidor também só para evitar algum erro e agora que a gente já tem a biblioteca do JW tem instalada a gente vai configurar o nosso serviço que vai fazer geração dos tokens aqui

dentro do nosso pacote infra e dentro do pacote Security eu vou criar uma nova classe que eu vou chamar de token service vai ser a nossa classe para geração dos tokens essa minha classe por elas são service eu preciso avisar o Spring Então vou colocar aqui anotação @service em cima da nossa classe essa classe vai ter um método para a gente gerar os nossos tokens Então vai ser um método público vai retornar uma string que é o nosso token e eu vou chamar de generate aqui ficou genorate pronto e esse meu generade token vai receber

por parâmetro um usuário por quê Porque depois quando o usuário fizer requisição e mandar esse token a gente precisa ver quem é esse usuário e vê se ele tem a role necessária para fazer aquela requisição Então como a nossa autenticação é stateles a gente não guarda em nenhum lugar as sessões que estão ativas a gente guarda essas informações no token e o token fica transitando entre o cliente e o servidor então aqui dentro do meu método generate token eu vou criar um troycat porque um troycat porque os métodos que a gente vai chamar aqui dentro

podem lançar uma exceção então a gente precisa já englobar eles contrai Cat Então a primeira coisa que a gente precisa declarar é Qual o algoritmo de geração de token que a gente vai utilizar né o algoritmo que a gente vai usar é o HM AC 256 então aqui eu vou declarar vou chamar de amor William vai ser um algorition só que tudo vem dentro da biblioteca do jwt ponto hmc256 Esse é o rean aqui recebe por parâmetro matric o que que é essa Sigla A Secret a forma que a gente faz para que os nossos

restos sejam únicos para nossa aplicação Como assim se a gente sempre usasse o mesmo algoritmo de hashi e para as mesmas entradas ele sempre gera a mesma saída Alguém poderia num Brook Force ter um mapeamento ali um dicionário de tradução por exemplo de palavra para hash para conseguir né descobrir senhas e quebrar né autenticação do sistemas Então como é que funciona no momento de gerar o resto a criptografia a gente passa também por parâmetro para esse algoritmo de haste de criptografia uma Secret essa Secret que é como se fosse um parâmetro para essa função que

faz a criptografia para que ela adicione uma coisinha mais que vai ser unicamente exclusiva para nossa aplicação para por conta dessa senha que a gente passou caso outra pessoa saiba dessa nossa senha aí a pessoa vai conseguir quebrar a nossa aplicação Então essa é a nossa Secret tem que ser muito bem guardada porque ela é informação única para geração dos nossos tokens então é como se fosse a chavinha do nosso cadeado a gente bota o cadeado e fecha com a chave essa chave a gente precisa guardar que é só com essa chave que a gente

consegue descriptografar depois e entender a mensagem então só quem tem essa chave no caso Teoricamente seria só nós só a nossa aplicação conhecendo a chave consegue criar uma nova mensagem e descriptografar aquelas que já estão criptografadas então aqui como é que a gente vai fazer para ter essa sigla bom eu vou criar aqui nessa classe um novo atributo que eu vou chamar que vai ser uma string que eu vou chamar de Secret só que não vai ser um atributo dessa Classe A gente vai pegar esse valor de algum lugar da onde a gente vai pegar

isso duas nossas variáveis de ambiente Então as variáveis de ambientes são definidas no momento que a gente faz o Deploy da nossa aplicação ficam lá no nosso consultório da WS por exemplo se a nossa aplicação tivesse sendo publicada por lá ou na ferramenta que a gente vai utilizando a gente coloca ali Nossa Secrets e só quem tem acesso a aplicação ali mesmo né no Consul de gerenciamento para fazer o Deploy etc sabe quais são essas Secrets conseguem alterá-las não fica dentro do código então não vai ficar lá no teu Beach Club só que fica num

lugar específico e como é que a gente vai pegar esse valor né do nossos variáveis de ambiente a gente vai usar anotação um vela e aqui dentro a gente vai colocar uma aspas Vamos colocar um símbolo de cifrão e abrir Chaves e aqui eu vou colocar api pontos Security ponto token ponto Secret da onde está saindo isso daqui bom isso aqui vai ser um caminho que a gente vai definir lá no nosso arquivo de configuração application aqui na a gente vai criar essa configuração aqui api ponto security.top.secret e por aqui que a gente vai consultar

nossas variáveis de ambiente como é que a gente faz isso a gente bota cifrão abre Chaves novamente coloca jwt Secret o que que é o jwt Secret é o nome da minha variável de ambiente daí então quando a gente for declarar nossas variáveis em ambiente a gente tem que declarar essas dessa forma mas caso eu não encontre essa variável de ambiente jwt's Secret eu quero que ele usa o valor de fome qual o valor de fonte vou colocar mais Secret que então caso não encontre variável de ambiente jwt Secret usa esse valor aqui no lugar

beleza e agora esse valor vai ser injetado aqui nessa minha classe e com esse Secret a gente passa por parâmetro para o nosso algorition e agora já tendo nosso algoritmo a gente consegue fazer a geração do nosso topo Então vou declarar aqui uma nova variável que vai ser uma string token e aqui eu vou fazer jwt é quem foi o emissor Quem foi que criou esse token então aqui eu vou colocar o nome da nossa aplicação por exemplo alfine que a gente pode colocar o nome que a gente quiser o nome que identifica essa nossa

aplicação e o próximo atributo que a gente vai adicionar no nosso token with subject Então subjet seria o usuário que está recebendo esse tom e aqui a gente vai botar em user ponto get login então aqui a gente vai salvar o login do nosso usuário no Token para que depois quando a gente descriptográfico no usuário tiver fazendo uma requisição a gente consiga identificar quem é esse usuário que tá fazendo a requisição aí depois eu vou passar um Rick experts Então vou colocar um tempo de inspiração para esse nosso token que eu vou colocar um número

aleatório e agora a gente já vai mudar isso e depois a gente vai botar um ponto sai e vamos passar logo reader por parâmetro que que esse ponto sai é para ele fazer a assinatura e a geração final e aqui um ponto e vírgula agora aqui embaixo eu vou criar um novo método que vai ser um método privado e vai retornar um instante o instante é um instante de tempo então isso aqui é um tipo da próprio Java e aqui a gente vai falar e vai chamar de generate experient e o que que ele vai

fazer aqui basicamente ele vai fazer um retorno louco ou datetime ponto Now ponto Plus Hours duas Instant e aqui Zone set off e aqui é zona 7.of e aqui dentro a gente vai passar o Nossa zona né de tempo que é menos três então aqui o horário de Brasília fica no menos três zona offset de menos 3 que que a gente fez aqui a gente pegou o tempo exatamente agora adicionou duas horas ou seja nosso tempo de inspiração para esse homem vai ser duas horas e transformou num instante né para que esse tipo aqui que

vai ser o que o que o ifespration x recebe e colocou no nosso time Zone né no time Zone aqui de Brasília para que a nossa aplicação é aqui do Brasil enfim aqui você coloca o time Zone que faz mais sentido para sua aplicação dependendo da onde estamos seus usuários enfim e aqui a gente vai chamar esse Generation E aí sim ele vai parar de me indicar o erro e agora a gente só precisa retornar esse token aqui dentro então pronto e agora a gente precisa fazer o cat aqui do Nosso Erro né que eu

falei para vocês Que esse essa criação aqui pode gerar uma exceção então aqui ele já tá me indicando né que eu preciso fazer o cat desse erro ele tá deixando aqui como vermelhinho então aqui a exceção que a gente vai pegar é a jwt Creation Exception eu vou chamar de Exception Então jwt pode lançar essa exceção quando algum desses nossos parâmetros não estiver no formato esperado ele não vai conseguir gerar o Tom e aqui eu sou vou basicamente lançar uma nova sessão então troll New Run eu vou colocar e vou passar por parâmetro também a

exceção por que que eu fiz isso porque assim vai ficar mais fácil para gente visualizar quando o erro vier aqui desse Cat Então dessa forma Run Timex colocando a nossa mensagem personalizada eu consigo identificar melhor Qual foi esse erro e depois eu posso criar uma nova classe né para fazer o cat dessa exceção então retornar uma resposta adequada para o usuário então a gente pode ir lá criar uma classe que trate especificamente que essa exceção que a gente tá lançando e retorna um Jason ali formatado com erro bonitinho para o usuário e agora que a

gente já criou o método para gerar o token a gente vai criar um método também para validar se citou quem está válido então quando a gente gera a gente manda para o usuário mas depois quando o usuário fizer uma nova requisição a gente vai ter que validar se esse token está valendo E para isso a gente vai usar o jwt também então aqui eu vou criar um novo método público que vai retornar uma string que que é esses trem que ele vai retomar a gente vai retornar o usuário que está registrado nesse topo Então a

gente vai pegar esse login aqui que a gente salvou no Token para fazer a identificação desse usuário e aí aqui eu vou chamar de valadates eu vou receber por parâmetro uma string que é o meu token como é que a gente vai fazer isso de novo vou colocar um troycat e aqui a gente vai criar o nosso Gran de novo só que agora a gente vai fazer assim ó return jwt ponto recuer e aqui a gente vai passar o algoritmo né que a gente está utilizando Richard Então a gente vai passar Quem foi o emissor

então foi um dos Nós Alf pii ponto build então aqui a gente tá montando novamente o dado né que tem ali dentro e aqui verify vou passar o token então eu vou pegar o sangue gente então aqui a gente colocou o adicionou sabe gente no token aqui ó descriptografei o token peguei o Subway que eu tinha salvo lá dentro e pronto é isso que a gente precisa e aqui a gente vai ter que tratar a exceção então aqui é jwt verification Exception então ele vai lançar essa exceção quando ele não conseguir verificar esse meu token

Ou seja quando o token for inválido não estiver válido o usuário passou um token que não é verdadeiro que não foi a gente que gerou né ou que já expirou e aqui vou pegar essa exceção e o que eu vou fazer é retornar uma string vazia porque porque depois lá o método que precisar desse usuário recebeu uma stream vazia já vai perceber que não tem usuário nenhum você vai ver seu Spring Security E aí ele vai retornar o erro de Ana to right né que esse usuário não tá autorizado porque porque eu tô com insperou

porque ele mandou um toque inválido enfim e agora para que o Spring faça essa verificação do Token Que o usuário enviar para mim automaticamente em todas as requisições que eu bloqueei que eu fechei que eu coloquei que eram para ser autorizadas a gente vai ter que adicionar mais uma configuração aqui no nosso Security depois né dele fazer essa verificação ele vai verificar aqui se o endpoint que está sendo chamado cai em alguma dessas regras se cair né cair na regra de autenticada ou de ter o role admin Então a gente vai precisar que ele faça

essa verificação então aqui eu vou colocar mais uma configuração que é de Filter before então eu vou adicionar um filtro antes disso Como assim um filtro antes disso esse aqui é um filtro que faz a verificação por exemplo se o a gente pode estar aberto ou não mas quando eu coloco aqui que eu preciso que o usuário tem essa role como eu ainda não tratei o Toke Ainda não peguei usuário ali de dentro não fiz o tratamento aqui ele vai ver tem a row não não tem então retorna aí ou aqui no autenticado ele vai

verificar tal autenticado esse usuário tá logado tá com token não não tá então retornei Então antes que ele caia nessa condição aqui eu quero fazer essa verificação do Token quero criptografar ver qual é o usuário ver qual é o rolo que ele tem e salvar essa informação para o Spirit Spring Security usar depois para fazer né Essa segurança aqui então a gente vai adicionar um filtro antes disso então qual é o filtro o filtro a gente vai chamar de Security Filter a gente vai criar esse filtro e eu quero que esse filtro ocorra antes do

user name password authentication filters Então a gente vai ter que criar essa classe que justifica então aqui no nosso infra ponto Security eu vou criar uma New Java classe que eu vou chamar de Security Filter e aqui dentro a gente vai fazer essas verificações Então a gente vai ter que colocar anotações essa nossa classe também para que o spring spring Security identificam o que que essa classe faz né então aqui essa classe vai ser um componente Então ela é um componente da nossa aplicação e ela estende uma classe que se chama Once Perry Quest Filter

então é um Filter que acontece uma vez a cada requisição então em toda requisição uma vez eu vou passar esse filtro aqui para fazer esse pente fino para pegar o token ver né tirar as informações de token ou não ou botar ali que tá vazio enfim e aí quando a gente estende essa classe ele vai pedir para que a gente implemente um método obrigatório e esse método se chama do Filter interno esse do filtro interno é o Filter aqui que ele vai chamar Antes desse aqui que a gente colocou então quando a gente declarou aqui

que eu quero que ele passa esse filtro ele vai chamar esse método aqui da classe do filtro interna então é aqui que a gente vai pegar o token recuperar as informações que estão dentro desse Tom então vou fazer aqui vá token é igual a desse ponto recovery passando o nosso request esse recovery token é um método que a gente vai criar então o método privado que retorna uma string eu vou chamar de recovery Toke e aqui ele recebe um este pi server let request que eu vou chamar de request dentro desse request a gente tem

os nossos headers e um desses headers é o Heather autorization que vai ser onde o usuário vários passar o topo então aqui eu vou pegar o feder que vai ser request.get reder e o nome desse header é autorization agora eu vou botar um if Heather for igual anu eu vou retornar nu aqui então quer dizer que não tem nenhum token nessa requisição Caso contrário eu vou retornar ao header ponto replace e aqui tem que ser Bear espaço pronto por que que eu coloquei isso por que que eu tô substituindo o valor que tem nesse autorization

né tô substituindo esse Berry por um valor vazio porque é padrão nas nossas requisições http quando a gente manda o header de autorização que contém um token a gente identifica esse tipo de Topo nesse caso aqui é um tokenberry Berry token então sempre quando a gente fala sua identificação a gente coloca berrier espaço e aí o valor do toco em si para a gente fazer essa identificação então aqui eu tô substituindo esse berrier que vai vir sempre nas requisições por padrão para o espaço vazio para a gente pegar só o valor do Token lá no

final e descartar essa parte aqui do BFF serve só por padronização Então agora que eu peguei o meu token eu vou verificar se o meu Token for diferente de nulo então vou fazer um processamento aqui dentro Caso contrário eu vou só fazer Filter Chan ponto do Filter request e responda o que que é isso aqui Filter champ ponto do Filter tô chamando o próximo filtro então aqui o que eu tinha para fazer eu já terminei pode ir para o próximo filtro qual é o próximo filtro É esse aqui e username password authentication Filter é o

que tá de próximo na nossa corrente de filtros então isso aqui vai acontecer quando ele cair nesse quando ele não tiver token mas caso ele tenha topo eu quero fazer um processamento antes então vou pegar o subject que tem dentro desse topo e para pegar esse Subway que a gente vai ter que usar o nosso token service então aqui eu vou declarar uma dependência dessa classe vai ser uma dependência atual vai ser do tipo token service eu vou chamar de token certo e aqui eu vou pegar esse token serve e vou chamar validay e vou

passar por parâmetro o Tom caso ele válido com sucesso não lança nenhuma exceção a gente vai ter o nosso user the Tails que eu vou chamar de user esse user the Tail vai ser meu e user repousar e aqui a gente vai ter que declarar o nosso também como e aqui a gente vai fazer find by login passando esse Subway então aqui eu vou trocar de Subway para login então quando a gente validou nosso token recebeu o nosso login e aí eu encontrei meu usuário e aí agora a gente vai fazer as verificações nesse nosso

usuário como é que a gente vai fazer isso vou criar aqui uma nova variável que eu vou chamar de authentication vai ser um New e user name password authentication token que é lá dos print que a gente já conhece vou passar por parâmetro o meu user o segundo parâmetro a gente passa como num e por fim eu vou passar meu user.gate ao Toy dessa forma eu peguei todas as informações que o Spring Security vai precisar para fazer as validações depois dos próximos 20 pontos né do Point ele vai verificar se usa tem a role né

de mim por exemplo ou se usa tal autenticado então aqui a gente gerou esse é o nosso token que agora a gente vai salvar no contexto dessa requisição para que os print Security consiga utilizar depois então aqui eu vou fazer Security context holder então é o contexto da minha autenticação.get contax.7 authentication e aqui eu vou passar o authentication então agora como essa esse filtro aqui aconteceu antes desse aqui a gente fez a verificação e salvou no contexto da autenticação esse usuário porque a gente avalidou ele caso a gente não encontra toco nenhum a gente não

vai salvar nada nessa sessão de autenticação né que está rolando a gente vai só chamar o próximo filtro e quando chegar nesse próximo um filtro ele vai procurar por essa Roller vai procurar seu celular então dedicado não vai encontrar nada e vai retornar o 403 forbidy Então por fim agora aqui nessa nossa Classe A gente vai declarar esse nosso Security Filter que vai ser do tipo Security Filter e aqui Security Filter e pronto agora a gente já finalizou todas as configurações que a gente precisava para fazer o controle da autenticação ção do nosso usuário e

agora lá na nossa requisição de login do usuário a gente vai precisar retornar para ele o token para que ele utilize nas próximas requisições então aqui eu vou gerar um novo token vai token igual a token service e aqui a gente vai ter que ter uma Instância do Token service também então declarar mais um autoart aproveite Service pronto token service ponto generate token e esse generate token recebe por parâmetro usuário e aqui a gente só tem o nosso Alf que foi retornado aqui pelo nosso authentication que fez o encolde lá da nossa senha e fez

a comparação então através desse Alfre a gente vai fazer Alf ponto get Prince Paul mccat Prince vai pegar o objeto principal né vai pegar Quem esse usuário e aqui a gente vai fazer um Cash para tipo usuário para que ele pare de retornar ele e pronto a gente já gerou o nosso topo que agora basta a gente retornar esse token no corpo da nossa requisição mas para deixar bonitinho eu vou criar um novo de ti ou então aqui eu vou criar uma nova classe que na verdade vai ser um Record e eu vou chamar de

Alf não vou chamar de login e aqui dentro eu vou retornar uma string que é o meu toque Pronto agora com esse login eu vou aqui eu vou fazer um New logintro nosso token e vou tirar o build aqui que a gente não vai mais precisar pronto dessa forma o usuário quando ele logar na nossa aplicação ele vai receber um token através desse Tom que ele vai conseguir chamar esses nossos a gente Pontes de post e de get Então vamos validar se isso tá funcionando eu vou iniciar minha aplicação aqui novamente Então vou entrar na

minha classe alfabrication vou iniciar ela e pronto ela já finalizou a inicialização então eu vou abrir o nosso insônia e vou disparar novamente a nossas requisições então primeiro eu vou disparar uma requisição de get só para a gente ver o erro de 403 porque a gente não tá autorizado vou disparar a requisição de post também não estou autorizado Então agora eu vou disparar Nossa requisição de login eu vou fazer um login na nossa aplicação fiz o login recebi meu toco Então vou copiar esse token e agora primeiro eu vou disparar uma requisição de get então

aqui eu vou adicionar o novo Heather que vai ser um Bear token vou colocar o meu token Vou colocar aqui um prefixo como barrier como a gente já tinha comentado vou enviar a requisição 200 Ok porque eu fui autenticada e pude fazer o acesso desse ind Point Então vou pegar esse token e vou enviar aqui para nossa requisição de post também então vou adicionar aqui também um autorization header que vai ser do tipo barretoken vou colar meu token Vou colocar aqui vou mandar a requisição 200 Ok cadastrei um novo produto vou mandar a requisição de

ganch de novo e aqui a gente já consegue ver o meu terceiro produto mas agora eu vou criar um novo usuário que vai ter a role só de user então ele não vai ser admin eu vou chamar de Fernanda que perdoe e a senha vai ser a mesma coisa então vou te esperar a requisição criei esse meu novo usuário eu vou fazer o login com esse novo usuário então aqui vai ser um login do usuário Fernando que perdoece vou enviar Beleza agora eu vou copiar esse token e primeiro eu vou fazer a requisição de get

que eu era para poder eu posso porque eu sou um usuário comum Beleza mas agora na requisição de post quando enviar esse token desse usuário eu vou ser barrada porque eu não tenho a Roller necessária eu não tenho essa permissão disparei requisição e ele me retornou 403 forbida bom pessoal para Esse vídeo foi isso Eu espero que vocês tenham gostado e se você gostou não esqueça de deixar seu like se inscrever aqui no canal para acompanhar os próximos vídeos e mais conteúdos de programação e tecnologia eu vou deixar aqui na descrição do vídeo o link

para o repositório no gitcube com código completo que a gente desenvolveu aqui durante o vídeo e vou deixar o link também para documentação do Spring Security para quem quiser aprender um pouquinho mais bom pessoal para Esse vídeo foi isso e até o próximo vídeo