Implementar una autenticación segura es un aspecto crucial en la construcción de sistemas cliente-servidor robustos en Python. Este tutorial te guiará a través del proceso de implementación de la autenticación en tus aplicaciones Python, comenzando con la autenticación básica de nombre de usuario y contraseña y avanzando hacia métodos basados en tokens. Al final de este laboratorio, comprenderás cómo asegurar tus aplicaciones Python con mecanismos de autenticación adecuados.
La autenticación es el proceso de verificar la identidad de un usuario o sistema antes de otorgar acceso a recursos protegidos. En los sistemas cliente-servidor, una autenticación adecuada asegura que solo los usuarios autorizados puedan acceder a datos sensibles o realizar ciertas operaciones.
Comencemos configurando nuestro entorno de trabajo. Primero, crea un nuevo directorio para nuestro proyecto:
mkdir -p ~/project/auth_demo
cd ~/project/auth_demoA continuación, necesitamos instalar los paquetes Python necesarios que usaremos a lo largo de este laboratorio:
pip install flask flask-login requestsDeberías ver una salida similar a esta:
Collecting flask
Downloading Flask-2.2.3-py3-none-any.whl (101 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 101.8/101.8 KB 6.2 MB/s eta 0:00:00
Collecting flask-login
Downloading Flask_Login-0.6.2-py3-none-any.whl (17 kB)
Collecting requests
Downloading requests-2.29.0-py3-none-any.whl (62 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 62.5/62.5 KB 5.5 MB/s eta 0:00:00
...
Successfully installed flask-2.2.3 flask-login-0.6.2 requests-2.29.0 ...Antes de sumergirnos en la implementación, comprendamos los conceptos básicos de autenticación:
Autenticación con Nombre de Usuario y Contraseña: La forma más común donde los usuarios proporcionan credenciales para verificar su identidad.
Autenticación basada en Tokens (Token-based Authentication): Después de un inicio de sesión exitoso, el servidor genera un token para que el cliente lo use en solicitudes posteriores, evitando la necesidad de enviar credenciales cada vez.
Autenticación basada en Sesiones (Session-based Authentication): El servidor almacena información de la sesión después de un inicio de sesión exitoso y proporciona un ID de sesión al cliente.
Visualicemos un flujo de autenticación básico:
Cliente Servidor
| |
|--- Solicitud de Inicio de Sesión (credenciales) ---->|
| |--- Verificar Credenciales
| |
|<---- Respuesta de Autenticación -------|
| |
|--- Solicitudes Subsiguientes (con auth) >|
| |--- Verificar Auth
| |
|<---- Respuesta de Recurso Protegido ---|Ahora que entendemos los conceptos básicos y hemos configurado nuestro entorno, creemos una estructura de archivos simple para nuestro proyecto:
touch ~/project/auth_demo/server.py
touch ~/project/auth_demo/client.pyEn el siguiente paso, implementaremos un sistema básico de autenticación con nombre de usuario y contraseña utilizando Flask en el lado del servidor y un cliente Python para autenticarse con él.
En este paso, implementaremos un sistema de autenticación básico que utiliza nombres de usuario y contraseñas. Crearemos:
Implementemos nuestro servidor Flask con capacidades básicas de autenticación. Abre el archivo server.py en el editor VSCode:
code ~/project/auth_demo/server.pyAhora, agrega el siguiente código para implementar un servidor de autenticación simple:
from flask import Flask, request, jsonify, session
import os
app = Flask(__name__)
## Generate a random secret key for session management
app.secret_key = os.urandom(24)
## Simple in-memory user database
users = {
"alice": "password123",
"bob": "qwerty456"
}
@app.route('/login', methods=['POST'])
def login():
data = request.get_json()
## Extract username and password from the request
username = data.get('username')
password = data.get('password')
## Check if the user exists and the password is correct
if username in users and users[username] == password:
session['logged_in'] = True
session['username'] = username
return jsonify({"status": "success", "message": f"Welcome {username}!"})
else:
return jsonify({"status": "error", "message": "Invalid credentials"}), 401
@app.route('/protected', methods=['GET'])
def protected():
## Check if the user is logged in
if session.get('logged_in'):
return jsonify({
"status": "success",
"message": f"You are viewing protected content, {session.get('username')}!"
})
else:
return jsonify({"status": "error", "message": "Authentication required"}), 401
@app.route('/logout', methods=['POST'])
def logout():
## Remove session data
session.pop('logged_in', None)
session.pop('username', None)
return jsonify({"status": "success", "message": "Logged out successfully"})
if __name__ == '__main__':
app.run(host='0.0.0.0', port=5000, debug=True)Este servidor:
Ahora, creemos un cliente que pueda autenticarse con nuestro servidor. Abre el archivo client.py:
code ~/project/auth_demo/client.pyAgrega el siguiente código:
import requests
import json
## Server URL
BASE_URL = "http://localhost:5000"
def login(username, password):
"""Authenticate with the server using username and password"""
response = requests.post(
f"{BASE_URL}/login",
json={"username": username, "password": password}
)
print(f"Login response: {response.status_code}")
print(response.json())
## Return the session cookies if login was successful
return response.cookies if response.status_code == 200 else None
def access_protected(cookies=None):
"""Access a protected resource"""
response = requests.get(f"{BASE_URL}/protected", cookies=cookies)
print(f"Protected resource response: {response.status_code}")
print(response.json())
return response
def logout(cookies=None):
"""Logout from the server"""
response = requests.post(f"{BASE_URL}/logout", cookies=cookies)
print(f"Logout response: {response.status_code}")
print(response.json())
return response
if __name__ == "__main__":
## Test with valid credentials
print("=== Authenticating with valid credentials ===")
cookies = login("alice", "password123")
if cookies:
print("\n=== Accessing protected resource ===")
access_protected(cookies)
print("\n=== Logging out ===")
logout(cookies)
## Test with invalid credentials
print("\n=== Authenticating with invalid credentials ===")
login("alice", "wrongpassword")
## Try to access protected resource without authentication
print("\n=== Accessing protected resource without authentication ===")
access_protected()Este cliente:
Para ver nuestro sistema de autenticación en acción, necesitaremos ejecutar tanto el servidor como el cliente. Primero, iniciemos el servidor:
python ~/project/auth_demo/server.pyDeberías ver una salida similar a esta:
* Serving Flask app 'server'
* Debug mode: on
WARNING: This is a development server. Do not use it in a production deployment.
* Running on all addresses (0.0.0.0)
* Running on http://127.0.0.1:5000Ahora, abre una nueva pestaña de terminal haciendo clic en el botón "+" junto a la terminal y ejecuta el cliente:
cd ~/project/auth_demo
python client.pyDeberías ver una salida que demuestra:
Esta salida confirma que nuestro sistema básico de autenticación con nombre de usuario y contraseña funciona correctamente.
En el siguiente paso, mejoraremos este sistema implementando la autenticación basada en tokens para una mayor seguridad.
En el paso anterior, creamos un sistema de autenticación básico utilizando sesiones. Si bien esto funciona para aplicaciones simples, la autenticación basada en tokens ofrece varias ventajas, particularmente para APIs y sistemas distribuidos.
En la autenticación basada en tokens:
Actualicemos nuestro sistema para usar JSON Web Tokens (JWT), un estándar popular para la autenticación basada en tokens.
Primero, necesitamos instalar el paquete PyJWT:
pip install pyjwtDeberías ver una salida que confirme la instalación:
Collecting pyjwt
Downloading PyJWT-2.6.0-py3-none-any.whl (20 kB)
Installing collected packages: pyjwt
Successfully installed pyjwt-2.6.0Modifiquemos nuestro servidor para usar tokens JWT en lugar de sesiones. Actualiza el archivo server.py:
code ~/project/auth_demo/server.pyReemplaza el código existente con:
from flask import Flask, request, jsonify
import jwt
import datetime
import os
app = Flask(__name__)
## Secret key for signing JWT tokens
SECRET_KEY = os.urandom(24)
## Simple in-memory user database
users = {
"alice": "password123",
"bob": "qwerty456"
}
def generate_token(username):
"""Generate a JWT token for the authenticated user"""
## Token expires after 30 minutes
expiration = datetime.datetime.utcnow() + datetime.timedelta(minutes=30)
payload = {
'username': username,
'exp': expiration
}
## Create the JWT token
token = jwt.encode(payload, SECRET_KEY, algorithm='HS256')
return token
def verify_token(token):
"""Verify the JWT token"""
try:
## Decode and verify the token
payload = jwt.decode(token, SECRET_KEY, algorithms=['HS256'])
return payload
except jwt.ExpiredSignatureError:
## Token has expired
return None
except jwt.InvalidTokenError:
## Invalid token
return None
@app.route('/login', methods=['POST'])
def login():
data = request.get_json()
## Extract username and password from the request
username = data.get('username')
password = data.get('password')
## Check if the user exists and the password is correct
if username in users and users[username] == password:
## Generate a JWT token
token = generate_token(username)
return jsonify({
"status": "success",
"message": f"Welcome {username}!",
"token": token
})
else:
return jsonify({"status": "error", "message": "Invalid credentials"}), 401
@app.route('/protected', methods=['GET'])
def protected():
## Get the token from the Authorization header
auth_header = request.headers.get('Authorization')
if not auth_header or not auth_header.startswith('Bearer '):
return jsonify({"status": "error", "message": "Missing or invalid token"}), 401
## Extract the token
token = auth_header.split(' ')[1]
## Verify the token
payload = verify_token(token)
if payload:
return jsonify({
"status": "success",
"message": f"You are viewing protected content, {payload['username']}!"
})
else:
return jsonify({"status": "error", "message": "Invalid or expired token"}), 401
if __name__ == '__main__':
app.run(host='0.0.0.0', port=5000, debug=True)Este servidor actualizado:
Ahora, actualicemos nuestro cliente para usar los tokens JWT. Actualiza el archivo client.py:
code ~/project/auth_demo/client.pyReemplaza el código existente con:
import requests
import json
## Server URL
BASE_URL = "http://localhost:5000"
def login(username, password):
"""Authenticate with the server using username and password"""
response = requests.post(
f"{BASE_URL}/login",
json={"username": username, "password": password}
)
print(f"Login response: {response.status_code}")
data = response.json()
print(data)
## Return the token if login was successful
return data.get('token') if response.status_code == 200 else None
def access_protected(token=None):
"""Access a protected resource using JWT token"""
headers = {}
if token:
headers['Authorization'] = f'Bearer {token}'
response = requests.get(f"{BASE_URL}/protected", headers=headers)
print(f"Protected resource response: {response.status_code}")
print(response.json())
return response
if __name__ == "__main__":
## Test with valid credentials
print("=== Authenticating with valid credentials ===")
token = login("alice", "password123")
if token:
print("\n=== Accessing protected resource with valid token ===")
access_protected(token)
## Test with invalid credentials
print("\n=== Authenticating with invalid credentials ===")
login("alice", "wrongpassword")
## Try to access protected resource without token
print("\n=== Accessing protected resource without token ===")
access_protected()
## Try to access protected resource with invalid token
print("\n=== Accessing protected resource with invalid token ===")
access_protected("invalid.token.value")Este cliente actualizado:
Ahora, ejecutemos nuestro sistema de autenticación basado en tokens actualizado. Primero, detén cualquier proceso de servidor en ejecución con Ctrl+C, luego inicia el servidor actualizado:
python ~/project/auth_demo/server.pyAbre una nueva pestaña de terminal o usa la segunda pestaña existente para ejecutar el cliente:
cd ~/project/auth_demo
python client.pyDeberías ver una salida que demuestra:
Esta salida confirma que nuestro sistema de autenticación basado en tokens funciona correctamente.
La autenticación basada en tokens ofrece varias ventajas sobre la autenticación basada en sesiones:
En aplicaciones del mundo real, es posible que desees mejorar aún más tu sistema de autenticación con características como la actualización de tokens, el control de acceso basado en roles y el almacenamiento seguro de tokens.
En nuestras implementaciones anteriores, almacenamos las contraseñas en texto plano, lo cual es un riesgo de seguridad significativo. En este paso, mejoraremos nuestro sistema de autenticación implementando el hashing de contraseñas utilizando el algoritmo bcrypt.
Almacenar contraseñas en texto plano presenta varios riesgos de seguridad:
El hashing de contraseñas resuelve estos problemas al:
Primero, necesitamos instalar el paquete bcrypt:
pip install bcryptDeberías ver una salida que confirme la instalación:
Collecting bcrypt
Downloading bcrypt-4.0.1-cp36-abi3-manylinux_2_28_x86_64.whl (593 kB)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 593.8/593.8 KB 10.5 MB/s eta 0:00:00
Installing collected packages: bcrypt
Successfully installed bcrypt-4.0.1Mejoremos nuestro servidor para incluir el registro de usuarios con hashing de contraseñas. Actualiza el archivo server.py:
code ~/project/auth_demo/server.pyReemplaza el código existente con:
from flask import Flask, request, jsonify
import jwt
import datetime
import os
import bcrypt
app = Flask(__name__)
## Secret key for signing JWT tokens
SECRET_KEY = os.urandom(24)
## Store users as a dictionary with username as key and a dict of hashed password and roles as value
users = {}
def hash_password(password):
"""Hash a password using bcrypt"""
## Convert password to bytes if it's a string
if isinstance(password, str):
password = password.encode('utf-8')
## Generate a salt and hash the password
salt = bcrypt.gensalt()
hashed = bcrypt.hashpw(password, salt)
return hashed
def check_password(password, hashed):
"""Verify a password against its hash"""
## Convert password to bytes if it's a string
if isinstance(password, str):
password = password.encode('utf-8')
## Check if the password matches the hash
return bcrypt.checkpw(password, hashed)
def generate_token(username, role):
"""Generate a JWT token for the authenticated user"""
## Token expires after 30 minutes
expiration = datetime.datetime.utcnow() + datetime.timedelta(minutes=30)
payload = {
'username': username,
'role': role,
'exp': expiration
}
## Create the JWT token
token = jwt.encode(payload, SECRET_KEY, algorithm='HS256')
return token
def verify_token(token):
"""Verify the JWT token"""
try:
## Decode and verify the token
payload = jwt.decode(token, SECRET_KEY, algorithms=['HS256'])
return payload
except jwt.ExpiredSignatureError:
## Token has expired
return None
except jwt.InvalidTokenError:
## Invalid token
return None
@app.route('/register', methods=['POST'])
def register():
data = request.get_json()
## Extract registration data
username = data.get('username')
password = data.get('password')
## Basic validation
if not username or not password:
return jsonify({"status": "error", "message": "Username and password are required"}), 400
## Check if the username already exists
if username in users:
return jsonify({"status": "error", "message": "Username already exists"}), 409
## Hash the password and store the user
hashed_password = hash_password(password)
users[username] = {
'password': hashed_password,
'role': 'user' ## Default role
}
return jsonify({
"status": "success",
"message": f"User {username} registered successfully"
})
@app.route('/login', methods=['POST'])
def login():
data = request.get_json()
## Extract username and password from the request
username = data.get('username')
password = data.get('password')
## Check if the user exists
if username not in users:
return jsonify({"status": "error", "message": "Invalid credentials"}), 401
## Check if the password is correct
if check_password(password, users[username]['password']):
## Generate a JWT token
token = generate_token(username, users[username]['role'])
return jsonify({
"status": "success",
"message": f"Welcome {username}!",
"token": token
})
else:
return jsonify({"status": "error", "message": "Invalid credentials"}), 401
@app.route('/protected', methods=['GET'])
def protected():
## Get the token from the Authorization header
auth_header = request.headers.get('Authorization')
if not auth_header or not auth_header.startswith('Bearer '):
return jsonify({"status": "error", "message": "Missing or invalid token"}), 401
## Extract the token
token = auth_header.split(' ')[1]
## Verify the token
payload = verify_token(token)
if payload:
return jsonify({
"status": "success",
"message": f"You are viewing protected content, {payload['username']}!",
"role": payload['role']
})
else:
return jsonify({"status": "error", "message": "Invalid or expired token"}), 401
@app.route('/admin', methods=['GET'])
def admin():
## Get the token from the Authorization header
auth_header = request.headers.get('Authorization')
if not auth_header or not auth_header.startswith('Bearer '):
return jsonify({"status": "error", "message": "Missing or invalid token"}), 401
## Extract the token
token = auth_header.split(' ')[1]
## Verify the token
payload = verify_token(token)
if not payload:
return jsonify({"status": "error", "message": "Invalid or expired token"}), 401
## Check if user has admin role
if payload['role'] != 'admin':
return jsonify({"status": "error", "message": "Admin access required"}), 403
return jsonify({
"status": "success",
"message": f"Welcome to the admin panel, {payload['username']}!"
})
## Add an admin user for testing
admin_password = hash_password("admin123")
users["admin"] = {
'password': admin_password,
'role': 'admin'
}
if __name__ == '__main__':
app.run(host='0.0.0.0', port=5000, debug=True)Este servidor mejorado:
Ahora, actualicemos nuestro cliente para probar estas nuevas características. Actualiza el archivo client.py:
code ~/project/auth_demo/client.pyReemplaza el código existente con:
import requests
import json
## Server URL
BASE_URL = "http://localhost:5000"
def register(username, password):
"""Register a new user"""
response = requests.post(
f"{BASE_URL}/register",
json={"username": username, "password": password}
)
print(f"Registration response: {response.status_code}")
print(response.json())
return response.status_code == 200
def login(username, password):
"""Authenticate with the server using username and password"""
response = requests.post(
f"{BASE_URL}/login",
json={"username": username, "password": password}
)
print(f"Login response: {response.status_code}")
data = response.json()
print(data)
## Return the token if login was successful
return data.get('token') if response.status_code == 200 else None
def access_protected(token=None):
"""Access a protected resource using JWT token"""
headers = {}
if token:
headers['Authorization'] = f'Bearer {token}'
response = requests.get(f"{BASE_URL}/protected", headers=headers)
print(f"Protected resource response: {response.status_code}")
print(response.json())
return response
def access_admin(token=None):
"""Access the admin panel using JWT token"""
headers = {}
if token:
headers['Authorization'] = f'Bearer {token}'
response = requests.get(f"{BASE_URL}/admin", headers=headers)
print(f"Admin panel response: {response.status_code}")
print(response.json())
return response
if __name__ == "__main__":
## Test user registration
print("=== Registering a new user ===")
register("testuser", "testpass123")
## Try to register with the same username (should fail)
print("\n=== Registering with existing username ===")
register("testuser", "differentpass")
## Test regular user login and access
print("\n=== Regular user login ===")
user_token = login("testuser", "testpass123")
if user_token:
print("\n=== Regular user accessing protected resource ===")
access_protected(user_token)
print("\n=== Regular user trying to access admin panel ===")
access_admin(user_token)
## Test admin login and access
print("\n=== Admin login ===")
admin_token = login("admin", "admin123")
if admin_token:
print("\n=== Admin accessing protected resource ===")
access_protected(admin_token)
print("\n=== Admin accessing admin panel ===")
access_admin(admin_token)Este cliente actualizado:
Ahora, ejecutemos nuestro sistema de autenticación mejorado. Primero, detén cualquier proceso de servidor en ejecución con Ctrl+C, luego inicia el servidor actualizado:
python ~/project/auth_demo/server.pyAbre una nueva pestaña de terminal o usa la segunda pestaña existente para ejecutar el cliente:
cd ~/project/auth_demo
python client.pyDeberías ver una salida que demuestra:
Esta salida confirma que nuestro sistema de autenticación mejorado con hashing de contraseñas y control de acceso basado en roles funciona correctamente.
Nuestro sistema mejorado ahora proporciona:
Estas mejoras hacen que nuestro sistema de autenticación sea mucho más robusto y adecuado para aplicaciones del mundo real.
En este laboratorio, has aprendido a implementar la autenticación en un sistema cliente-servidor de Python, desde conceptos básicos hasta técnicas avanzadas. Has logrado:
Estas habilidades proporcionan una base sólida para construir aplicaciones Python seguras. Recuerda que la autenticación es solo un aspecto de la seguridad de la aplicación; en sistemas de producción, también debes considerar:
Al aplicar estos principios, puedes construir aplicaciones Python que protejan eficazmente los datos de los usuarios y mantengan operaciones seguras.
