Application des exigences de force de mot de passe avec django.contrib.auth.views.password_change

Question

Nous avons une application Django qui nécessite un niveau spécifique de complexité du mot de passe. Nous appliquons actuellement ceci via JavaScript côté client qui peut facilement être vaincu par quelqu'un qui est motivé de manière appropriée.

Je n'arrive pas à trouver d'informations spécifiques sur la configuration de la validation de la force du mot de passe côté serveur à l'aide des vues intégrées à django contrib. Avant de réinventer la roue, existe-t-il un moyen approprié de gérer cette exigence?

Answer 1

Je suis aussi allé avec un formulaire personnalisé pour cela. En urls.py spécifiez votre formulaire personnalisé:

 (r'^change_password/$', 'django.contrib.auth.views.password_change',
     {'password_change_form': ValidatingPasswordChangeForm}),
 

Hériter de PasswordChangeForm et implémenter la validation:

 from django import forms
from django.contrib import auth

class ValidatingPasswordChangeForm(auth.forms.PasswordChangeForm):
    MIN_LENGTH = 8

    def clean_new_password1(self):
        password1 = self.cleaned_data.get('new_password1')

        # At least MIN_LENGTH long
        if len(password1) < self.MIN_LENGTH:
            raise forms.ValidationError("The new password must be at least %d characters long." % self.MIN_LENGTH)

        # At least one letter and one non-letter
        first_isalpha = password1[0].isalpha()
        if all(c.isalpha() == first_isalpha for c in password1):
            raise forms.ValidationError("The new password must contain at least one letter and at least one digit or" \
                                        " punctuation character.")

        # ... any other validation you want ...

        return password1
 

Answer 2

Comme certains ont éludé avec les validateurs personnalisés, voici l'approche que je prendrais ...

Créer un validateur:

 from django.core.exceptions import ValidationError
from django.utils.translation import ugettext as _

def validate_password_strength(value):
    """Validates that a password is as least 7 characters long and has at least
    1 digit and 1 letter.
    """
    min_length = 7

    if len(value) < min_length:
        raise ValidationError(_('Password must be at least {0} characters '
                                'long.').format(min_length))

    # check for digit
    if not any(char.isdigit() for char in value):
        raise ValidationError(_('Password must container at least 1 digit.'))

    # check for letter
    if not any(char.isalpha() for char in value):
        raise ValidationError(_('Password must container at least 1 letter.'))
 

Ajoutez ensuite le validateur au champ de formulaire que vous souhaitez valider:

 from django.contrib.auth.forms import SetPasswordForm

class MySetPasswordForm(SetPasswordForm):

    def __init__(self, *args, **kwargs):
        super(MySetPasswordForm, self).__init__(*args, **kwargs)
        self.fields['new_password1'].validators.append(validate_password_strength)
 

Answer 3

Je voudrais juste installer django-passwords et laisser cela le gérer pour vous: https://github.com/dstufft/django-passwords

Après cela, vous pouvez simplement sous-classer le formulaire d'inscription et remplacer le champ par un PasswordField.

Answer 4

Je pense que vous devriez simplement écrire votre propre validateur (ou utiliser RegexValidator, voir: http://docs.djangoproject.com/en/dev/ref/validators/ ) si vous utilisez des formulaires ou écrivez un autre script en vérifiant les expressions régulières. Cela devrait être une tâche simple. Aussi, je ne pense pas qu'il existe un mécanisme intégré, simplement parce que chaque personne comprend le concept de "mot de passe fort" un peu différent.