Mirrors/hacktricks
2
0
Fork 0
mirror of https://github.com/carlospolop/hacktricks synced 2024-11-28 07:31:10 +00:00
Code Issues Projects Releases Packages Wiki Activity
hacktricks/network-services-pentesting/pentesting-web/flask.md

11 KiB
Raw Blame History

Flask

☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥

Use Trickest para construir e automatizar fluxos de trabalho com as ferramentas comunitárias mais avançadas do mundo.
Obtenha acesso hoje:

{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}

Provavelmente, se você estiver jogando um CTF, uma aplicação Flask estará relacionada a SSTI.

Cookies

O nome padrão da sessão do cookie é session.

Decodificador

Decodificador online de cookies Flask: https://www.kirsle.net/wizards/flask-session.cgi

Manual

Obtenha a primeira parte do cookie até o primeiro ponto e decodifique em Base64>

echo "ImhlbGxvIg" | base64 -d

O cookie também é assinado usando uma senha

Flask-Unsign

Ferramenta de linha de comando para buscar, decodificar, forçar bruta e criar cookies de sessão de uma aplicação Flask ao adivinhar chaves secretas.

{% embed url="https://pypi.org/project/flask-unsign/" %}

pip3 install flask-unsign

Decodificar Cookie

A cookie is a small piece of data that is stored on the client-side and is used to store information about the user. Cookies are often used in web applications to maintain user sessions and personalize the user experience.

When performing a web application penetration test, it is important to understand how cookies are being used and if they are properly secured. One way to do this is by decoding the cookie to see its contents.

To decode a cookie, you can use various tools and techniques. One common method is to use a browser extension or developer tools to view the cookie's value in plain text. Another option is to use a programming language like Python to decode the cookie programmatically.

Here is an example of how you can decode a cookie using Python:

import base64

def decode_cookie(cookie):
    decoded_cookie = base64.b64decode(cookie)
    return decoded_cookie.decode('utf-8')

cookie = 'SGVsbG8gV29ybGQh'
decoded_cookie = decode_cookie(cookie)
print(decoded_cookie)

In this example, the base64 module is used to decode the cookie. The decode_cookie function takes a cookie as input, decodes it using base64.b64decode, and returns the decoded cookie as a string.

By decoding the cookie, you can see its contents and understand what information is being stored. This can be useful for identifying potential security vulnerabilities, such as sensitive data being stored in cookies without proper encryption or protection.

It is important to note that decoding a cookie does not modify its value or affect the web application in any way. It is simply a way to view the contents of the cookie for analysis purposes.

Remember to always obtain proper authorization before performing any penetration testing activities.

flask-unsign --decode --cookie 'eyJsb2dnZWRfaW4iOmZhbHNlfQ.XDuWxQ.E2Pyb6x3w-NODuflHoGnZOEpbH8'

Força Bruta

flask-unsign --wordlist /usr/share/wordlists/rockyou.txt --unsign --cookie '<cookie>' --no-literal-eval

Assinatura

A assinatura é um mecanismo de autenticação usado para verificar a integridade e a autenticidade dos dados transmitidos. No contexto da segurança da web, a assinatura é frequentemente usada para proteger as sessões de comunicação entre o cliente e o servidor.

Existem diferentes algoritmos de assinatura disponíveis, como RSA, DSA e ECDSA. Esses algoritmos usam chaves públicas e privadas para criar e verificar assinaturas digitais.

Ao realizar testes de penetração em serviços da web, é importante verificar se a assinatura está sendo usada corretamente. Isso envolve verificar se a assinatura é gerada corretamente, se a chave privada é armazenada de forma segura e se a verificação da assinatura é feita adequadamente no servidor.

Os testes de penetração podem incluir tentativas de falsificar assinaturas, explorar vulnerabilidades relacionadas à assinatura e verificar se há vazamento de informações sensíveis relacionadas à assinatura.

flask-unsign --sign --cookie "{'logged_in': True}" --secret 'CHANGEME'

Assinando usando versões antigas (legado)

When using legacy versions of Flask, it is important to be aware of potential security vulnerabilities. Older versions of Flask may not have implemented the latest security features and patches, making them more susceptible to attacks.

To sign data using legacy versions of Flask, you can use the itsdangerous library. This library provides a Signer class that can be used to generate and verify signatures.

Here is an example of how to sign data using the Signer class:

from itsdangerous import Signer

# Create a signer object with a secret key
signer = Signer('my_secret_key')

# Sign some data
data = 'Hello, world!'
signature = signer.sign(data)

# Verify the signature
is_valid = signer.verify(signature)

print(is_valid)  # True

In this example, we create a Signer object with a secret key. We then use the sign() method to generate a signature for the data. The resulting signature can be stored or transmitted along with the data.

To verify the signature, we use the verify() method of the Signer object. This method returns True if the signature is valid, and False otherwise.

It is important to keep the secret key used for signing secure. If an attacker gains access to the secret key, they can generate valid signatures and potentially impersonate trusted entities.

By using the itsdangerous library, you can sign data securely even when using legacy versions of Flask. However, it is recommended to keep your Flask version up to date to benefit from the latest security enhancements and patches.

flask-unsign --sign --cookie "{'logged_in': True}" --secret 'CHANGEME' --legacy

RIPsession

Ferramenta de linha de comando para realizar brute-force em sites usando cookies criados com flask-unsign.

{% embed url="https://github.com/Tagvi/ripsession" %}

ripsession -u 10.10.11.100 -c "{'logged_in': True, 'username': 'changeMe'}" -s password123 -f "user doesn't exist" -w wordlist.txt

SQLi em cookie de sessão Flask com SQLmap

Este exemplo utiliza a opção eval do sqlmap para automaticamente assinar payloads do sqlmap para o Flask usando um segredo conhecido.

Proxy Flask para SSRF

Neste artigo é explicado como o Flask permite uma solicitação que começa com o caractere "@":

GET @/ HTTP/1.1
Host: target.com
Connection: close

Qual no seguinte cenário:

from flask import Flask
from requests import get

app = Flask('__main__')
SITE_NAME = 'https://google.com/'

@app.route('/', defaults={'path': ''})
@app.route('/<path:path>')
def proxy(path):
return get(f'{SITE_NAME}{path}').content

app.run(host='0.0.0.0', port=8080)

Poderia permitir introduzir algo como "@attacker.com" para causar um SSRF.

Use Trickest para construir e automatizar fluxos de trabalho com as ferramentas comunitárias mais avançadas do mundo.
Acesse hoje mesmo:

{% embed url="https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks" %}

☁️ HackTricks Cloud ☁️ -🐦 Twitter 🐦 - 🎙️ Twitch 🎙️ - 🎥 Youtube 🎥