Introdução
Bem-vindo ao laboratório de Interação com Aplicações Web. No mundo da cibersegurança e da automação web, interagir com aplicações web de forma programática é uma habilidade fundamental. Seja para extrair dados (scraping), testar vulnerabilidades ou automatizar tarefas repetitivas, você precisa de uma maneira confiável de enviar e receber requisições HTTP.
Neste laboratório, você aprenderá a usar a poderosa biblioteca requests do Python. Você escreverá scripts para enviar requisições HTTP GET e POST, extrair informações importantes das respostas do servidor, automatizar o envio de formulários e gerenciar cookies de sessão para manter o estado de autenticação.
Comparado ao uso de sockets brutos, a biblioteca requests trabalha em um nível de abstração mais alto. Ela lida com muitos detalhes do protocolo HTTP para você, como cabeçalhos, codificação, redirecionamentos e cookies. Isso a torna ideal para automação de segurança, onde o foco está no comportamento da web e nos fluxos de trabalho, em vez da mecânica pacote a pacote.
Enviar Requisições HTTP GET
Nesta etapa, você aprenderá a enviar uma requisição HTTP GET básica usando Python. O método GET é utilizado para solicitar dados de um recurso específico, de forma muito semelhante a como seu navegador solicita uma página web quando você digita uma URL.
Pense nisso como a forma mais simples de automação web: solicitar um recurso e inspecionar a resposta. Muitas tarefas de reconhecimento, teste e monitoramento começam exatamente aqui.
Primeiro, certifique-se de estar no diretório do seu projeto. É aqui que você criará todos os seus scripts Python para este laboratório.
cd ~/project
Agora, vamos criar um script Python para enviar uma requisição GET para um servidor web local que foi preparado para você. Use o editor de texto nano para criar um arquivo chamado get_request.py:
nano get_request.py
Digite o seguinte código Python no editor:
import requests
url = 'http://127.0.0.1:5000/get'
response = requests.get(url)
print("Response Body:")
print(response.text)
Salve o arquivo e saia do editor (no nano, pressione Ctrl+O, Enter para salvar e Ctrl+X para sair).
O código acima importa a biblioteca requests, define a URL de destino e usa a função requests.get() para enviar a requisição. A resposta do servidor é armazenada na variável response, e imprimimos o texto bruto do corpo da resposta.
Execute seu script usando o interpretador Python:
python3 get_request.py
Você deverá ver uma saída semelhante a esta:
Response Body:
{"message":"GET request successful"}
Extrair Status HTTP e Cabeçalhos
Nesta etapa, você aprenderá a extrair informações mais detalhadas de uma resposta HTTP, especificamente o código de status e os cabeçalhos.
O corpo da resposta é apenas parte da história. Os códigos de status informam como o servidor entendeu a requisição, e os cabeçalhos descrevem metadados como tipo de conteúdo, política de cache, cookies ou o software do servidor. Uma boa automação analisa todas as três camadas: código, cabeçalhos e corpo.
Quando um servidor responde a uma requisição HTTP, ele inclui um código de status (como 200 para OK, ou 404 para Não Encontrado) e cabeçalhos que fornecem metadados sobre a resposta (como o tipo de conteúdo ou o software do servidor).
Crie um novo arquivo chamado check_status.py no diretório do seu projeto:
nano check_status.py
Adicione o seguinte código ao arquivo:
import requests
url = 'http://127.0.0.1:5000/get'
response = requests.get(url)
print(f"Status Code: {response.status_code}")
if response.status_code == 200:
print("The request was successful!")
print("\nResponse Headers:")
print(f"Content-Type: {response.headers.get('Content-Type')}")
print(f"Server: {response.headers.get('Server')}")
Salve o arquivo e saia do editor.
Neste script, response.status_code recupera o código de status inteiro retornado pelo servidor. O response.headers é um objeto semelhante a um dicionário que contém todos os cabeçalhos HTTP enviados de volta pelo servidor. Usamos o método .get() para extrair cabeçalhos específicos de forma segura.
Execute o script para ver as informações extraídas:
python3 check_status.py
Sua saída deve ser parecida com esta:
Status Code: 200
The request was successful!
Response Headers:
Content-Type: application/json
Server: Werkzeug/3.0.1 Python/3.10.12
Automatizar o Envio de Formulários (POST)
Nesta etapa, você aprenderá a enviar uma requisição HTTP POST. Ao contrário das requisições GET, que são usadas para recuperar dados, as requisições POST são usadas para enviar dados ao servidor. Isso é comumente usado para submeter formulários web, como credenciais de login.
Essa distinção reflete a semântica do HTTP. Na prática, o GET é geralmente usado para ler recursos, enquanto o POST é frequentemente usado para ações que submetem ou alteram o estado. Entender essa diferença ajuda você a prever como as aplicações se comportam e como seus scripts devem interagir com elas.
Escreveremos um script para simular o envio de um formulário de login com nome de usuário e senha.
Crie um novo arquivo chamado post_request.py:
nano post_request.py
Insira o seguinte código:
import requests
url = 'http://127.0.0.1:5000/post'
## Define the form data as a dictionary
form_data = {
'username': 'admin',
'password': 'secret'
}
## Send the POST request with the data parameter
response = requests.post(url, data=form_data)
print(f"Status Code: {response.status_code}")
print(f"Response Body: {response.text}")
Salve o arquivo e saia do editor.
Aqui, definimos um dicionário chamado form_data contendo nossas credenciais. Em seguida, usamos requests.post() e passamos nosso dicionário para o parâmetro data. A biblioteca requests formata automaticamente esses dados como uma submissão de formulário web padrão.
Execute o script para enviar o formulário:
python3 post_request.py
Você deverá ver uma mensagem de login bem-sucedido:
Status Code: 200
Response Body: {"message":"Login successful"}
Você pode tentar alterar a senha no script para um valor incorreto (como wrongpass) e executá-lo novamente para ver como o servidor responde com um código de status 401 Unauthorized.
Gerenciar Cookies de Sessão
Nesta etapa final, você aprenderá a gerenciar cookies de sessão. O HTTP é um protocolo sem estado (stateless), o que significa que cada requisição é independente. Para lembrar de um usuário após o login, as aplicações web utilizam cookies.
Se você usar requests.get() ou requests.post() diretamente, os cookies não são salvos entre as requisições. Para manter uma sessão (como permanecer logado), você deve usar um objeto Session fornecido pela biblioteca requests.
Crie um arquivo chamado session_request.py:
nano session_request.py
Adicione o seguinte código:
import requests
## Create a Session object
session = requests.Session()
login_url = 'http://127.0.0.1:5000/login'
profile_url = 'http://127.0.0.1:5000/profile'
print("Attempting to access profile BEFORE login...")
response1 = session.get(profile_url)
print(f"Status: {response1.status_code}, Body: {response1.text.strip()}")
print("\nLogging in to establish a session...")
## The session object will automatically store cookies returned by the server
session.post(login_url)
print("\nAttempting to access profile AFTER login...")
## The session object will automatically send the stored cookies with this request
response2 = session.get(profile_url)
print(f"Status: {response2.status_code}, Body: {response2.text.strip()}")
Salve o arquivo e saia do editor.
Neste script, requests.Session() cria uma sessão persistente. Quando enviamos a requisição POST para /login, o servidor define um cookie de sessão. O objeto Session armazena esse cookie e o inclui automaticamente na requisição GET subsequente para /profile, permitindo-nos acessar a rota protegida.
Execute o script:
python3 session_request.py
Observe a saída. Você verá que a primeira tentativa falha porque não estamos logados, mas a segunda tentativa é bem-sucedida porque o cookie de sessão foi gerenciado automaticamente:
Attempting to access profile BEFORE login...
Status: 401, Body: {"message":"Unauthorized"}
Logging in to establish a session...
Attempting to access profile AFTER login...
Status: 200, Body: {"message":"Welcome to your profile!"}
Resumo
Você aprendeu a usar a biblioteca requests do Python para automatizar interações web. Começou enviando requisições HTTP GET básicas e extraindo metadados importantes, como códigos de status e cabeçalhos. Em seguida, avançou para o envio de requisições HTTP POST para automatizar o preenchimento de formulários. Por fim, aprendeu a usar objetos Session para gerenciar cookies e manter o estado de autenticação ao longo de múltiplas requisições.
Essas habilidades formam a base para muitas tarefas avançadas em web scraping, integração de APIs e testes automatizados de segurança.
