Source code
from datetime import datetime
from django.conf import settings
from django.utils.crypto import constant_time_compare, salted_hmac
from django.utils.http import base36_to_int, int_to_base36
class PasswordResetTokenGenerator:
"""
Strategy object used to generate and check tokens for the password
reset mechanism.
"""
key_salt = "django.contrib.auth.tokens.PasswordResetTokenGenerator"
algorithm = None
_secret = None
_secret_fallbacks = None
def __init__(self):
self.algorithm = self.algorithm or "sha256"
def _get_secret(self):
return self._secret or settings.SECRET_KEY
def _set_secret(self, secret):
self._secret = secret
secret = property(_get_secret, _set_secret)
def _get_fallbacks(self):
if self._secret_fallbacks is None:
return settings.SECRET_KEY_FALLBACKS
return self._secret_fallbacks
def _set_fallbacks(self, fallbacks):
self._secret_fallbacks = fallbacks
secret_fallbacks = property(_get_fallbacks, _set_fallbacks)
def make_token(self, user):
"""
Return a token that can be used once to do a password reset
for the given user.
"""
return self._make_token_with_timestamp(
user,
self._num_seconds(self._now()),
self.secret,
)
def check_token(self, user, token):
"""
Check that a password reset token is correct for a given user.
"""
if not (user and token):
return False
# Parse the token
try:
ts_b36, _ = token.split("-")
except ValueError:
return False
try:
ts = base36_to_int(ts_b36)
except ValueError:
return False
# Check that the timestamp/uid has not been tampered with
for secret in [self.secret, *self.secret_fallbacks]:
if constant_time_compare(
self._make_token_with_timestamp(user, ts, secret),
token,
):
break
else:
return False
# Check the timestamp is within limit.
if (self._num_seconds(self._now()) - ts) > settings.PASSWORD_RESET_TIMEOUT:
return False
return True
def _make_token_with_timestamp(self, user, timestamp, secret):
# timestamp is number of seconds since 2001-1-1. Converted to base 36,
# this gives us a 6 digit string until about 2069.
ts_b36 = int_to_base36(timestamp)
hash_string = salted_hmac(
self.key_salt,
self._make_hash_value(user, timestamp),
secret=secret,
algorithm=self.algorithm,
).hexdigest()[
::2
] # Limit to shorten the URL.
return "%s-%s" % (ts_b36, hash_string)
def _make_hash_value(self, user, timestamp):
"""
Hash the user's primary key, email (if available), and some user state
that's sure to change after a password reset to produce a token that is
invalidated when it's used:
1. The password field will change upon a password reset (even if the
same password is chosen, due to password salting).
2. The last_login field will usually be updated very shortly after
a password reset.
Failing those things, settings.PASSWORD_RESET_TIMEOUT eventually
invalidates the token.
Running this data through salted_hmac() prevents password cracking
attempts using the reset token, provided the secret isn't compromised.
"""
# Truncate microseconds so that tokens are consistent even if the
# database doesn't support microseconds.
login_timestamp = (
""
if user.last_login is None
else user.last_login.replace(microsecond=0, tzinfo=None)
)
email_field = user.get_email_field_name()
email = getattr(user, email_field, "") or ""
return f"{user.pk}{user.password}{login_timestamp}{timestamp}{email}"
def _num_seconds(self, dt):
return int((dt - datetime(2001, 1, 1)).total_seconds())
def _now(self):
# Used for mocking in tests
return datetime.now()
Run 1
This code demonstrates excellent readability through clear organization, minimal nesting, and logical structure. The class has a clear single responsibility around token generation/verification. Methods are concise and well-named, making intent obvious. Nesting is minimal - the deepest nesting occurs in check_token with try/except blocks and loops, but it's handled cleanly with early returns. Code length is appropriate for the functionality provided. Action granularity is good with one main operation per line, though a few lines like the salted_hmac call chain could be broken up. Reading flow is natural - make_token flows to _make_token_with_timestamp, check_token validates logically step-by-step. Comments explain non-obvious security decisions without being excessive. The use of properties for secret management and clear separation of time-related helper methods contribute to overall maintainability.
Run 2
The code is well-structured and readable overall. The class has a clear single responsibility, with logical separation of public methods (make_token, check_token), internal helpers (_make_token_with_timestamp, _make_hash_value), and property accessors. Nesting is mostly flat: check_token has one level of for/else and early return guards, which keeps the flow manageable. Intent is explicit through meaningful names and clear docstrings. Action granularity is generally good, though some lines (e.g., hash_string assignment) combine several operations. The sliced hexdigest inline comment explains a non-obvious choice. The _make_hash_value method is concise and clearly documents the rationale via comments. Minor drawbacks include slightly dense list construction in check_token and the somewhat terse conditional expression for login_timestamp. Overall, the code is maintainable, follows Django conventions, and balances conciseness with clarity effectively.
Run 3
The code is well-structured and highly readable. It exhibits a clear separation of concerns with private helper methods for token construction, hash value generation, and time calculations. There is no excessive nesting, and each method is concise with a single responsibility. Variable and method names accurately convey their purpose, making the intent clear. The code is appropriately sized for its functionality, avoiding unnecessary verbosity while retaining necessary detail. Each operation is on its own line, and the logical progression from public API to private helpers supports natural reading flow. The only minor deductions are due to the use of some Django-specific utilities which require familiarity, and the somewhat terse token parsing section, but overall this is exemplary code.
Run 1
Code Structure: Well-organized class with focused methods separating configuration, token generation, validation, and hashing. Nesting: Mostly flat, with early returns keeping validation simple; the loop and conditional introduce only shallow nesting. Clarity of intent: Descriptive method names, docstrings, and security-related comments explain purpose well, although abbreviations such as ts_b36 and the loop-else require familiarity. Code length: Appropriately concise for the functionality; the longer hashing docstring provides useful context rather than unnecessary verbosity. Action granularity: Most statements perform one clear action, though the chained HMAC, hexadecimal conversion, and slicing combine several operations. Reading flow: Validation proceeds naturally from parsing to verification to expiration checking. Minor distractions include the awkward multiline slice formatting and a timestamp/uid comment that does not precisely match the implementation.
Run 2
Code Structure: Well-organized class with focused methods separating configuration, token creation, validation, and hashing. Nesting: Shallow overall; early returns keep validation straightforward, though the for-else construct requires familiarity. Clarity of intent: Descriptive names, docstrings, and comments explain both behavior and security rationale; abbreviations such as ts_b36 slightly reduce accessibility. Code length: Appropriately concise for the functionality, with useful rather than excessive documentation. Action granularity: Most statements perform one clear action, although chained HMAC generation and slicing combine several operations. Reading flow: Validation proceeds naturally from parsing to signature verification to expiration checks. Minor interruptions include the awkward multiline hexdigest slicing and indirect property definitions.
Run 3
Code Structure: Well-organized class with focused methods separating configuration, token generation, validation, and hashing. Nesting: Shallow control flow and early returns keep validation easy to follow; the loop-else construct adds minor complexity. Clarity of intent: Descriptive names, docstrings, and comments clearly explain purpose and security considerations, though abbreviations such as ts_b36 require interpretation. Code length: Appropriate for the functionality; lengthy documentation is useful rather than redundant, while property boilerplate adds some overhead. Action granularity: Most statements perform one clear action, although chained HMAC generation and slicing combine several operations. Reading flow: Validation progresses naturally from parsing to verification to expiration checks. The awkward multiline hexdigest slice and less-common loop-else syntax slightly interrupt otherwise smooth reading.