Geekly articles weekly

Usando Cuentas Joomla en un Proyecto Django

Digamos que el sitio que usan sus usuarios está escrito en Joomla, pero para crear un nuevo producto para su audiencia, eligió el paquete Python / Django.


Como resultado, debe usar cuentas de usuario de la base de datos de Joomla en Django.


El problema, sin embargo, es que Joomla y Django usan algoritmos de hash de contraseña diferentes, por lo que solo falla la copia de las cuentas.


Después de leer la documentación de Django, desbordar la pila y pasar un tiempo, obtuve la solución que se describe a continuación, que utiliza las prácticas de desarrollo recomendadas para Django al máximo.


Advertencias


Es posible que esta solución arquitectónica no sea adecuada para usted, vea la discusión en los comentarios .


Para comprender lo que sucede en los ejemplos a continuación, debe tener cierta comprensión de la arquitectura de Django.


También supongo que sabe cómo implementar un proyecto Django, por lo que no estoy describiendo este proceso.


El código se copia de un proyecto en funcionamiento, pero será fácil de ajustar a su proyecto con un mínimo de cambios.


Probablemente, en la próxima versión principal de Django, este código puede romperse, sin embargo, el principio de solución seguirá siendo el mismo.


En esta guía, no describo el front-end del sistema de autorización, ya que:


  • qué front-end tiene dependerá de las necesidades de su proyecto (incluso puede ser un punto final de la API Json, por ejemplo)
  • esta información ya está descrita en los tutoriales oficiales de Django y en varios artículos iniciales

Algoritmo


  • conectar la base de datos de Joomla (DB) al proyecto Django
  • crear un modelo de JoomlaUser que represente a un usuario de la base de datos de Joomla
  • escriba una función check_joomla_password() que verifique que la contraseña ingresada coincida con la contraseña original del usuario.
  • agregar un nuevo backend de autorización "Joomla Auth Backend" al proyecto, que, al autorizar al cliente en Django, obtendrá la cuenta de usuario de la base de datos de Joomla

1. Conexión a la base de datos de Joomla:


  • Lea cómo funciona Django con múltiples bases de datos

  • Para conectar la base de datos de Joomla a nuestro proyecto Django, agregue el siguiente código al archivo de configuración del proyecto /project_name/settings.py :


     DATABASES = { #    'default': { ... }, 'joomla_db': { 'ENGINE': 'django.db.backends.mysql', 'OPTIONS': {}, 'NAME': 'joomla_database_name', # Don't store passwords in the code, instead use env vars: 'USER': os.environ['joomla_db_user'], 'PASSWORD': os.environ['joomla_db_pass'], 'HOST': 'joomla_db_host, can be localhost or remote IP', 'PORT': '3306', } }


Si es necesario, en el mismo archivo con la configuración del proyecto, puede habilitar el registro de consultas de la base de datos:


 # add logging to see DB requests: LOGGING = { 'version': 1, 'handlers': { 'console': { 'level': 'DEBUG', 'class': 'logging.StreamHandler', }, }, 'loggers': { 'django.db.backends': { 'level': 'DEBUG', 'handlers': ['console'], }, }, }

2. crear un modelo JoomlaUser


  • Lea cómo un modelo Django puede usar una base de datos existente
  • Piense dónde colocar el nuevo JoomlaUser.
    En mi proyecto, creé una aplicación llamada "usuarios" ( manage.py startapp users ). Contendrá el backend de autorización y el modelo de usuario de Joomla.
  • generar el modelo automáticamente usando inspectdb:
    python manage.py inspectdb live_users --database="joomla_db"
    joomla_db: el nombre de la base de datos que especificó en settings.py/DATABASES ;
    live_users: nombre de la tabla con cuentas.

  • agregue su modelo a users/models.py :


     class JoomlaUser(models.Model): """ Represents our customer from the legacy Joomla database. """ username = models.CharField(max_length=150, primary_key=True) email = models.CharField(max_length=100) password = models.CharField(max_length=100) # you can copy more fields from `inspectdb` output, # but it's enough for the example class Meta: # joomla db user table. WARNING, your case can differs. db_table = 'live_users' # readonly managed = False # tip for the database router app_label = "joomla_users"


A continuación, debemos asegurarnos de que el modelo accederá a la base de datos correcta. Para hacer esto, agregue al proyecto un enrutador para consultas a diferentes bases de datos , que redirigirá las solicitudes del modelo JoomlaUser a su base de datos nativa.


  1. Cree el archivo "db_routers.py" en la carpeta principal del proyecto (en el mismo lugar donde está su "settings.py"):


     # project_name/db_routers.py class DbRouter: """this router makes sure that django uses legacy 'Joomla' database for models, that are stored there (JoomlaUser)""" def db_for_read(self, model, **kwargs): if model._meta.app_label == 'joomla_user': return 'joomla_db' return None def db_for_write(self, model, **kwargs): if model._meta.app_label == 'joomla_user': return 'joomla_db' return None

  2. registre un nuevo enrutador en settings.py :


     # ensure that Joomla users are populated from the right database: DATABASE_ROUTERS = ['project_name.db_routers.DbRouter']


Ahora puede obtener una cuenta de la base de datos anterior.
Inicie un terminal Django e intente extraer un usuario existente: python manage.py shell


 >>> from users.models import JoomlaUser >>> print(JoomlaUser.objects.get(username='someuser')) JoomlaUser object (someusername) >>>

Si todo funciona (ve al usuario), vaya al siguiente paso. De lo contrario, mire la salida de error y corrija la configuración.


3. Verifique la contraseña de la cuenta de Joomla


Joomla no almacena las contraseñas de los usuarios, sino su hash, por ejemplo
$2y$10$aoZ4/bA7pe.QvjTU0R5.IeFGYrGag/THGvgKpoTk6bTz6XNkY0F2e


A partir de Joomla v3.2, las contraseñas de los usuarios se cifran con el algoritmo BLOWFISH .


Así que descargué el código de Python con este algoritmo:


 pip install bcrypt echo bcrypt >> requirements.txt

Y creó una función para verificar las contraseñas en el users/backend.py :


 def check_joomla_password(password, hashed): """ Check if password matches the hashed password, using same hashing method (Blowfish) as Joomla >= 3.2 If you get wrong results with this function, check that the Hash starts from prefix "$2y", otherwise it is probably not a blowfish hash :return: True/False """ import bcrypt if password is None: return False # bcrypt requires byte strings password = password.encode('utf-8') hashed = hashed.encode('utf-8') return hashed == bcrypt.hashpw(password, hashed)

Atencion Las versiones de Joomla inferiores a la 3.2 utilizan un método de hashing diferente (md5 + salt), por lo que esta función no funcionará. En este caso, lea
discusión sobre Stackoverflow y crear una función de comprobación de hash que se parece a esto:


 # WARNING - THIS FUNCTION WAS NOT TESTED WITH REAL JOOMLA USERS # and definitely has some errors def check_old_joomla_password(password, hashed): from hashlib import md5 password = password.encode('utf-8') hashed = hashed.encode('utf-8') if password is None: return False # check carefully this part: hash, salt = hashed.split(':') return hash == md5(password+salt).hexdigest()

Desafortunadamente, no tengo una base de usuarios de la versión anterior de Joomla, así que no puedo probar esta función por usted.


4. Autorización de usuario de back-end de Joomla


Ahora está listo para crear un backend de Django para autorizar a los usuarios del proyecto Joomla.


  1. lea cómo modificar el sistema de autorización de Django


  2. Registre un nuevo backend (aún no existente) en project/settings.py :


     AUTHENTICATION_BACKENDS = [ # Check if user already in the local DB # by using default django users backend 'django.contrib.auth.backends.ModelBackend', # If user was not found among django users, # use Joomla backend, which: # - search for user in Joomla DB # - check joomla user password # - copy joomla user into Django user. 'users.backend.JoomlaBackend', ]

  3. Cree un backend de autorización de usuario de Joomla en users/backend.py



 from django.contrib.auth.models import User from .models import JoomlaUser def check_joomla_password(password, hashed): # this is a fuction, that we wrote before ... class JoomlaBackend: """ authorize users against Joomla user records """ def authenticate(self, request, username=None, password=None): """ IF joomla user exists AND password is correct: create django user return user object ELSE: return None """ try: joomla_user = JoomlaUser.objects.get(username=username) except JoomlaUser.DoesNotExist: return None if check_joomla_password(password, joomla_user.password): # Password is correct, let's create and return Django user, # identical to Joomla user: # but before let's ensure there is no same username # in DB. That could happen, when user changed password # in Joomla, but Django doesn't know that User.objects.filter(username=username).delete() return User.objects.create_user( username=username, email=joomla_user.email, password=password, # any additional fields from the Joomla user: ... ) # this method is required to match Django Auth Backend interface def get_user(self, user_id): try: return User.objects.get(pk=user_id) except User.DoesNotExist: return None

Resumen


Felicitaciones: ahora los usuarios de su sitio Joomla existente pueden usar sus credenciales en un nuevo sitio / aplicación.


Como autorización de los usuarios activos a través de la nueva interfaz, se copiarán uno por uno en la nueva base de datos.


Alternativamente, es posible que no desee copiar entidades de usuario del sistema antiguo al nuevo.


En este caso, aquí hay un enlace a un artículo que describe cómo reemplazar el modelo de usuario predeterminado con el suyo en Django (el modelo JoomlaUser descrito anteriormente).


La decisión final, si transferir o no a los usuarios, se toma sobre la base de la relación en la que estarán los proyectos nuevos y antiguos. Por ejemplo, dónde se llevará a cabo el registro de nuevos usuarios, qué sitio / aplicación será el principal, etc.


Pruebas y documentación.


Ahora agregue las pruebas y la documentación apropiadas que cubren el nuevo código. La lógica de esta solución está estrechamente entrelazada con la arquitectura de Django y no es muy obvia, por lo que si no realiza las pruebas / documentación ahora, el soporte para el proyecto será más complicado en el futuro.

Source: https://habr.com/ru/post/442592/

More articles:


All Articles