‫-: Então, anteriormente, já implementamos
‫uma funcionalidade de inscrição simples, mas nesta
‫aula, na
‫verdade, também faremos o login do
‫usuário para fazer um processo de inscrição mais real.
‫Então, começando com esta palestra,
‫vamos realmente começar a implementar nossa autenticação,
‫e é aí que fica realmente sério.
‫Portanto, antes de começarmos, quero dar
‫a vocês um aviso aqui,
‫então a autenticação é muito difícil de acertar e muitos
‫tutoriais por aí que você encontrará quando
‫pesquisar por autenticação com
‫o Node semelhante. js e
‫Express, muitos deles cometem muitos erros graves e
‫simplificam demais as coisas que não deveriam ser simplificadas.
‫Tudo bem, isso não quer dizer que todos os
‫tutoriais por
‫aí são ruins, tudo bem,
‫ou que são inúteis ou algo assim, mas eu realmente gasto semanas
‫pesquisando todas as melhores práticas e refinando
‫e melhorando meu código, para
‫fazer essa seção de autenticação que nós vamos começar
‫a implementar agora da melhor forma possível,
‫para um iniciante como você, tudo bem, e isso é
‫porque precisamos ser realmente muito cuidadosos ao escrever esta parte do
‫aplicativo, porque lembre-se, os dados do nosso usuário estão em jogo
‫aqui , e a confiança na empresa que
‫executa o aplicativo também
‫está em jogo e, portanto,
‫implementar a autenticação é uma responsabilidade
‫real, na qual você não deve cometer nenhum erro.
‫Agora existem algumas bibliotecas
‫por aí que podem nos ajudar a
‫implementar autenticação e autorização e a mais conhecida
‫se chama Passport, mas mesmo
‫uma biblioteca como
‫essa não tira todo o trabalho e toda
‫a responsabilidade de você, tudo bem.
‫Agora, neste
‫caso aqui, vamos implementar toda a
‫lógica de proteção e autorização de login por conta própria,
‫exceto, é claro, para a implementação do token da web
‫Jason de que falamos no último vídeo.
‫Ok, então toda a assinatura e verificação
‫de todas essas coisas, vamos deixar para a biblioteca
‫WJT, mas então o resto,
‫vamos nos implementar nas próximas aulas.
‫Agora, como mencionei antes,
‫já temos nossa função de inscrição aqui, certo, mas agora, tudo
‫o que ela
‫faz é simplesmente criar um novo usuário
‫e, em seguida, enviá-lo de volta ao cliente.
‫Pouco depois de terminar de gravar este curso,
‫percebi
‫que há uma falha de segurança
‫muito séria nessa forma de inscrever
‫usuários. Basicamente, o problema é que,
‫agora, criamos um novo usuário usando todos os dados que
‫chegam com o corpo certo,
‫e então o problema aqui é que assim,
‫qualquer um pode especificar a função como um direito de administrador,
‫então basicamente, todos podem simplesmente se registrar como um administrador em
‫nosso aplicativo e,
‫portanto, é claro que não precisamos disso.
‫Portanto, novamente, essa é uma falha de segurança
‫séria e é claro que precisaremos consertar
‫e consertar é bastante simples.
‫Então, o que você precisa em vez desta linha
‫de código, que está selecionada
‫aqui, é este trecho de código que acabei de colocar aqui na tela.
‫OK.
‫Então, novamente, vá em frente e exclua esta linha de
‫código que está selecionada aqui
‫e substitua-a pelo código que acabei de colocar
‫aqui na tela.
‫Qual é a grande diferença aqui,
‫bem, com esse novo
‫código, basicamente permitimos que apenas os dados de que
‫realmente precisamos sejam colocados no
‫novo usuário, apenas um nome, o e-mail e as senhas.
‫E agora, mesmo se um usuário tentar inserir manualmente uma função,
‫não armazenaremos isso no novo usuário, e
‫o mesmo para outras
‫coisas, como por exemplo, uma foto.
‫Portanto, esta é a solução rápida e fácil para esse problema.
‫Agora,
‫o que isso fará é que não podemos mais nos registrar
‫como um administrador e, portanto, se precisarmos
‫adicionar um novo
‫administrador ao nosso sistema, podemos simplesmente criar um novo
‫usuário normalmente e ir para o
‫MongoDB Compass, e basicamente editar essa função lá.
‫Então, edite manualmente
‫do usuário para o administrador, ok.
‫Claro que também poderíamos definir uma rota
‫especial apenas para criar
‫administradores, mas isso seria um pouco demais.
‫Ok, então vamos em frente.
‫Observe que o código no resto do
‫vídeo e todos os vídeos
‫neste curso ainda será a versão errada antiga, certo, mas na verdade
‫no código final que está no
‫repositório GitHub, eu já
‫consertei isso e nós tem o código correto lá.
‫De qualquer forma, geralmente quando nos inscrevemos em qualquer aplicativo da
‫web, você também se loga automaticamente, certo, e vamos
‫implementar isso muito rapidamente aqui.
‫Então, faça o login do
‫novo usuário, assim que ele se inscreveu, ok,
‫e lembre-se da aula anterior, como
‫isso funciona, tudo o que
‫realmente precisamos fazer é assinar
‫um token da web do Jason
‫e enviá-lo de volta para o usuário , ok, mas
‫agora vamos primeiro instalar o pacote MPM que usaremos
‫para tudo relacionado aos tokens da
‫web do Jason.
‫Então, em nosso outro terminal,
‫digamos que o MPM install, Jason web token, tudo isso junto assim
‫e aquilo deve então
‫instalar este pacote e vamos em
‫frente e
‫dar uma olhada nele no GitHub,
‫apenas para ver a documentação
‫e vamos faça
‫isso aqui, não precisamos mais deste aqui,
‫pelo menos por enquanto, e isso nos levará à página sobre MPM, e
‫você verá o quão
‫popular esse pacote realmente é,
‫então temos 2. 3 milhões de downloads
‫semanais, o que é realmente uma tonelada de downloads
‫e podemos dar uma olhada na documentação aqui
‫também, mas eu pessoalmente prefiro fazer isso no GitHub.
‫Acho que parece muito mais limpo
‫aqui, e estou tão acostumado
‫com isso neste momento, então geralmente só vejo aqui, ok.
‫De qualquer forma, a primeira função que
‫usaremos com o JWT aqui é sign, ok, então, para
‫basicamente criar um novo token, e para isso, é
‫claro, precisamos da carga útil,
‫precisamos da chave para aquele segredo privado que
‫mencionei antes
‫que seja apenas armazenado em nosso servidor
‫e que precisamos assinar o
‫token e então podemos passar algumas
‫opções e faremos tudo isso em
‫um segundo, eu só quero mostrar a outra função
‫que temos aqui, e que realmente temos uma
‫tonelada de opções aqui, por exemplo
‫expira em, que vamos usar para
‫usar também, então todas
‫essas coisas e depois verificamos.
‫Também falamos sobre o processo de verificação e
‫isso é basicamente implementado nesta função, ok, e isso é
‫o que vamos usar, ao
‫fazer o login de um usuário, ok, e isso
‫é realmente tudo que existe,
‫então você tem tudo essas opções
‫diferentes aqui, ok, você
‫também decodificou, mas essa não é realmente importante,
‫ok, então você vê que este pacote realmente
‫inclui apenas
‫as duas funcionalidades que discutimos no vídeo anterior.
‫Então, assinando e depois verificando, ok.
‫Portanto, vamos voltar aqui e realmente começar
‫a usar o pacote de tokens da Web Jason.
‫Então, vamos importá-lo
‫aqui, e ele geralmente é simplesmente chamado
‫de JWT e requer o token da web Jason.
‫Ok, então vamos criar nosso token aqui, ok, e
‫eu gostaria de
‫simplesmente chamá-lo assim, apenas token, ok, então o sinal
‫de ponto JWT, e agora a primeira coisa é a carga útil,
‫e este é basicamente um objeto
‫para todos os dados que
‫vamos armazenar dentro do token, e neste
‫caso,
‫queremos realmente apenas o ID do usuário, tudo bem,
‫então nada de louco aqui, não muitos dados
‫que não são realmente importantes.
‫Então dizemos que o ID é e
‫simplesmente obtemos o ID do novo usuário
‫que acabou de ser criado, ok, novo ponto de
‫usuário e, em seguida, lembre-se que no MonogoDB, o ID é na verdade
‫chamado de ID de sublinhado, tudo bem, e então é o
‫objeto que são os dados,
‫a carga útil, que queremos colocar em nosso JWT.
‫Em seguida, precisamos do segredo, ok, basicamente uma
‫string para um
‫segredo, tudo bem, claro
‫que este é um terrível, tudo bem, isso é
‫apenas uma espécie de marcador
‫de posição porque, na verdade, nosso arquivo
‫de configuração é um lugar perfeito para armazenar esse tipo de
‫dado secreto, assim como a senha, por exemplo,
‫e vamos adicionar e editar aqui, ok, vamos chamá-lo de JWT, segredo
‫e, claro, o nome que damos aqui, realmente não importa, mas o
‫que importa é o segredo que
‫especificamos
‫aqui, tudo bem, porque usando a criptografia HSA 256 padrão
‫para a assinatura, o segredo deve ter pelo menos trinta e dois caracteres, certo,
‫mas quanto maior, melhor na verdade e é aqui
‫que muitos tutoriais lá fora falham, alguns
‫deles simplesmente colocam uma string
‫bem curta aqui, mas isso não
‫é o ideal novamente, então para melhor criptografar
‫a assinatura, novamente você
‫deve usar pelo menos trinta e
‫dois caracteres, então vou criar meu segredo aqui agora mas
‫você realmente deveria usar
‫outro, ok, por favor, não use o sa eu
‫um como estou fazendo porque isso pode se
‫tornar um problema de segurança para
‫seu aplicativo, ok, sempre
‫use um segredo exclusivo para seus aplicativos e nunca
‫o mesmo, tudo bem, e
‫especialmente não o de outra pessoa, então
‫definitivamente não aquele que eu estou digitando agora.
‫Então isso pode
‫ser qualquer coisa, não tem que ser
‫personagens estranhos ou coisas assim, eu prefiro
‫usar uma frase como essa, meu
‫segredo ultra seguro e ultra longo, então o que aconteceu
‫aqui, de qualquer maneira
‫isso deveria ter trinta e dois caracteres e então
‫este
‫é o que vamos usar para meus tokens
‫da web do Jason, mas, novamente, use outro, certo.
‫De qualquer forma, vamos voltar ao controlador de autenticação aqui e
‫agora realmente usá-lo.
‫Portanto, lembre-se de que uma variável de
‫ambiente é o segredo do processo ponto final ponto JWT,
‫certo.
‫Portanto, neste ponto, temos a carga
‫útil e o segredo.
‫O cabeçalho do token será criado automaticamente, mas agora
‫o que
‫também podemos fazer é passar
‫algumas opções, e a opção que
‫vou passar é quando o JWT deve expirar.
‫Então, isso significa que após o
‫tempo que passaremos aqui, o
‫token da web Jason não
‫será mais
‫válido, mesmo se de outra forma fosse verificado
‫corretamente, tudo bem,
‫então isso é basicamente para desconectar um
‫usuário após um certo período de
‫tempo simplesmente como uma medida de segurança, ok.
‫Portanto, vamos definir esse tempo de expiração também como uma
‫variável de configuração aqui, de
‫modo que o JWT expire em e aqui, é claro, você pode
‫usar o mesmo tempo que
‫estou colocando.
‫Portanto, podemos usar uma
‫string especial como, por exemplo, 90D
‫e o algoritmo de assinatura descobrirá
‫automaticamente que isso significa noventa dias, ok, você também
‫pode usar dez horas ou cinco minutos ou três segundos ou algo
‫assim, ou apenas qualquer número
‫,
‫que será tratado como milissegundos, mas
‫acho melhor simplesmente usar noventa ou
‫algo assim, então, neste caso, noventa dias, tudo bem,
‫e novamente, após noventa
‫dias, o JWT não será mais válido,
‫mesmo que a assinatura está correta e tudo é válido.
‫Ok, então, novamente, apenas como uma medida de segurança
‫adicional,
‫ok, essas opções como sempre, nós as passamos
‫como um objeto e depois vamos
‫especificar a expiração em, então expira em e, em seguida, processa ponto
‫final e o JWT expira em, ok, e isso aqui irá adicionar
‫alguns dados adicionais à carga
‫útil, mas isso
‫não é nenhum problema.
‫Acabamos de criar um token, agora
‫tudo o que
‫precisamos fazer é enviá-lo ao cliente.
‫Então, vamos colocá-lo aqui antes do usuário realmente
‫e, em seguida, é isso.
‫Isso é realmente tudo que precisamos fazer para
‫fazer o login de
‫um novo usuário, porque
‫no momento não estamos verificando se alguma senha está correta
‫ou se o usuário
‫realmente existe no banco de
‫dados
‫porque aqui, neste caso, o usuário
‫acabou de ser criado, e então,
‫imediatamente, logamos o usuário no
‫aplicativo enviando um token, ok, e o uso
‫do cliente deve, então, de alguma forma armazenar
‫esse token, assim
‫como falamos antes na aula anterior, ok, então vamos salvá-lo aqui, e vamos
‫realmente experimentar, ok, vamos ver meu antigo endereço
‫aqui, olá @ jonas. io, vamos enviá-lo e
‫esperar por ele e, de fato, aqui
‫está nosso token da web do Jason, então parabéns, você acabou
‫de criar seu primeiro token da
‫web do Jason, que deve ser um
‫pouco parecido com este e, claro, não
‫será exatamente o mesmo, porque o nosso segredo
‫também não é o mesmo, certo, e agora o
‫que quero mostrar a
‫vocês, é o depurador JWT, que
‫mostrei como screenshot no início do
‫último vídeo.
‫Então, vamos copiar este token
‫e então vamos para o JWT. io, ok, então aqui
‫embaixo
‫nós temos o depurador
‫e vamos excluir este aqui, colocar o nosso
‫e imediatamente você verá que nossa
‫assinatura é inválida, mas isso é
‫porque a função de sinal edita
‫essas duas propriedades
‫aqui, porque especificamos uma expiração data basicamente.
‫Então, isso aqui é emitido em,
‫e este é o tempo de expiração,
‫ok, então se removermos esses dois daqui, você verá
‫que
‫agora, esta assinatura foi verificada,
‫ok, então o que é importante notar aqui, é
‫claro que o cabeçalho está visível
‫ok é facilmente decodificável basicamente, e você que
‫não especificamos nada disso, foi o pacote de
‫tokens da web Jason que fez isso por nós, mas
‫aqui está a carga útil que especificamos, então, se dermos uma
‫olhada neste ID, deve ser
‫exatamente o mesmo que temos no carteiro, terminando
‫em seis OF, e então, de
‫fato, é exatamente o mesmo certo, ok, então esses
‫dois aqui estão abertos e então a
‫assinatura é claro, não podemos realmente veja, porque é claro
‫que nosso segredo é apenas isso, é realmente
‫secreto, tudo bem, então isso era apenas para mostrar
‫a vocês que tudo funciona, e vamos fechar isso,
‫e sim, não podemos
‫fazer o login de usuários, mas somente se o usuário acabou
‫de se cadastrar, pois nesse caso,
‫não precisamos verificar o e-mail no banco
‫de dados, e
‫também não o senha, ok.
‫Então, fazer tudo isso é um processo muito mais complexo,
‫e isso é realmente o que
‫faremos na próxima aula,
‫então na próxima, iremos realmente logar os usuários, com
‫base em seus endereços de e-mail e suas senhas.