9731793428

Committed 15 Jun 2024 07:23AM UTC coverage: 97.01% (+0.3%) from 96.751%

Build # 9731793428

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #16 from zopefoundation/config-with-pure-python-template-42418b51

Add support for Python 3.12, drop 3.7

Run Details

64 of 67 branches covered (95.52%)

Branch coverage included in aggregate %.

0 of 1 new or added line in 1 file covered. (0.0%)

1 existing line in 1 file now uncovered.

228 of 234 relevant lines covered (97.44%)

0.97 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.58

/src/AuthEncoding/AuthEncoding.py

##############################################################################
#
# Copyright (c) 2002, 2015 Zope Foundation and Contributors.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE
#
##############################################################################

import binascii
# Use the system PRNG if possible
import random
import time
import warnings
from binascii import a2b_base64
from binascii import b2a_base64
from hashlib import sha1 as sha
from hashlib import sha256
from os import getpid
from os import urandom

from .compat import b
from .compat import u


try:
    random = random.SystemRandom()
    using_sysrandom = True
except NotImplementedError:  # pragma: no cover
    using_sysrandom = False


def _reseed():
    if not using_sysrandom:
        # This is ugly, and a hack, but it makes things better than
        # the alternative of predictability. This re-seeds the PRNG
        # using a value that is hard for an attacker to predict, every
        # time a random string is required. This may change the
        # properties of the chosen random sequence slightly, but this
        # is better than absolute predictability.
        random.seed(sha256(  # pragma: no cover
            f'{random.getstate()}{time.time()}{getpid()}'
        ).digest())


def _choice(c):
    _reseed()
    return random.choice(c)


def _randrange(r):
    _reseed()
    return random.randrange(r)


def constant_time_compare(val1, val2):
    """
    Returns True if the two strings are equal, False otherwise.

    The time taken is independent of the number of characters that match.
    """
    if len(val1) != len(val2):
        return False
    result = 0
    for x, y in zip(iter(val1), iter(val2)):
        result |= x ^ y
    return result == 0


class PasswordEncryptionScheme:  # An Interface

    def encrypt(pw):
        """
        Encrypt the provided plain text password.
        """

    def validate(reference, attempt):
        """
        Validate the provided password string.  Reference is the
        correct password, which may be encrypted; attempt is clear text
        password attempt.
        """


_schemes = []


def registerScheme(id, s):
    '''
    Registers an LDAP password encoding scheme.
    '''
    _schemes.append((id, '{%s}' % id, s))


def listSchemes():
    return [id for id, prefix, scheme in _getSortedSchemes()]


def _getSortedSchemes():
    """ Return a reversed sorted sequence of encryption schemes.

    Several places iterate over schemes and compare the prefix with the start
    of a password string. Using a reverse-sorted sequence makes sure that e.g.
    'SHA256' is always tested before 'SHA' to prevent bad matches.
    """
    return sorted(_schemes, reverse=True)


class SSHADigestScheme:
    '''
    SSHA is a modification of the SHA digest scheme with a salt
    starting at byte 20 of the base64-encoded string.
    '''
    # Source: http://developer.netscape.com/docs/technote/ldap/pass_sha.html

    def generate_salt(self):
        # Salt can be any length, but not more than about 37 characters
        # because of limitations of the binascii module.
        # 7 is what Netscape's example used and should be enough.
        # All 256 characters are available.
        return urandom(7)

    def encrypt(self, pw):
        return self._encrypt_with_salt(pw, self.generate_salt())

    def validate(self, reference, attempt):
        try:
            ref = a2b_base64(reference)
        except binascii.Error:  # pragma: no cover
            # Not valid base64.
            return 0
        salt = ref[20:]
        compare = self._encrypt_with_salt(attempt, salt)
        return constant_time_compare(compare, reference)

    def _encrypt_with_salt(self, pw, salt):
        pw = b(pw)
        return b2a_base64(sha(pw + salt).digest() + salt)[:-1]


registerScheme('SSHA', SSHADigestScheme())


class SHADigestScheme:

    def encrypt(self, pw):
        return self._encrypt(pw)

    def validate(self, reference, attempt):
        compare = self._encrypt(attempt)
        return constant_time_compare(compare, reference)

    def _encrypt(self, pw):
        pw = b(pw)
        return b2a_base64(sha(pw).digest())[:-1]


registerScheme('SHA', SHADigestScheme())


class SHA256DigestScheme:

    def encrypt(self, pw):
        return b(sha256(b(pw)).hexdigest())

    def validate(self, reference, attempt):
        a = self.encrypt(attempt)
        return constant_time_compare(a, reference)


registerScheme('SHA256', SHA256DigestScheme())


# Bcrypt support may not have been requested at installation time
# - installed via the 'bcrypt' extra
try:
    import bcrypt
except ModuleNotFoundError:
    bcrypt = None


class BCRYPTHashingScheme:
    """A BCRYPT hashing scheme."""

    @staticmethod
    def _ensure_bytes(pw, encoding='utf-8'):
        """Ensures the given password `pw` is returned as bytes."""
        if isinstance(pw, str):
            pw = pw.encode(encoding)
        return pw

    def encrypt(self, pw):
        return bcrypt.hashpw(self._ensure_bytes(pw), bcrypt.gensalt())

    def validate(self, reference, attempt):
        try:
            return bcrypt.checkpw(self._ensure_bytes(attempt), reference)
        except ValueError:
            # Usually due to an invalid salt
            return False


if bcrypt is not None:
    registerScheme('BCRYPT', BCRYPTHashingScheme())


# Suppress deprecation warnings on Python 3.11 and up
with warnings.catch_warnings():
    warnings.simplefilter('ignore')

    # crypt is not available on all platforms
    try:
        from crypt import crypt
    except ImportError:
        crypt = None


if crypt is not None:

    class CryptDigestScheme:

        def generate_salt(self):
            choices = ("ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                       "abcdefghijklmnopqrstuvwxyz"
                       "0123456789./")
            return _choice(choices) + _choice(choices)

        def encrypt(self, pw):
            return b(crypt(self._recode_password(pw), self.generate_salt()))

        def validate(self, reference, attempt):
            attempt = self._recode_password(attempt)
            a = b(crypt(attempt, reference[:2].decode('ascii')))
            return constant_time_compare(a, reference)

        def _recode_password(self, pw):
            # crypt always requires `str`
            return u(pw)

    registerScheme('CRYPT', CryptDigestScheme())


class MySQLDigestScheme:

    def encrypt(self, pw):
        pw = u(pw)
        nr = 1345345333
        add = 7
        nr2 = int(0x12345671)
        for i in pw:
            if i == ' ' or i == '\t':
                continue
            nr ^= (((nr & 63) + add) * ord(i)) + (nr << 8)
            nr2 += (nr2 << 8) ^ nr
            add += ord(i)
        r0 = nr & ((1 << 31) - 1)
        r1 = nr2 & ((1 << 31) - 1)
        return f'{r0:08x}{r1:08x}'.encode('ascii')

    def validate(self, reference, attempt):
        a = self.encrypt(attempt)
        return constant_time_compare(a, reference)


registerScheme('MYSQL', MySQLDigestScheme())


def pw_validate(reference, attempt):
    """Validate the provided password string, which uses LDAP-style encoding
    notation.  Reference is the correct password, attempt is clear text
    password attempt."""
    reference = b(reference)
    for id, prefix, scheme in _getSortedSchemes():
        lp = len(prefix)
        if reference[:lp] == b(prefix):
            return scheme.validate(reference[lp:], attempt)
    # Assume cleartext.
    return constant_time_compare(reference, b(attempt))


def is_encrypted(pw):
    pw = b(pw)
    for id, prefix, scheme in _getSortedSchemes():
        lp = len(prefix)
        if pw[:lp] == b(prefix):
            return 1
    return 0


def pw_encrypt(pw, encoding='SSHA'):
    """Encrypt the provided plain text password using the encoding if provided
    and return it in an LDAP-style representation."""
    encoding = u(encoding)
    for id, prefix, scheme in _getSortedSchemes():
        if encoding == id:
            return b(prefix) + scheme.encrypt(pw)
    raise ValueError('Not supported: %s' % encoding)


pw_encode = pw_encrypt  # backward compatibility

1	##############################################################################
2	#
3	# Copyright (c) 2002, 2015 Zope Foundation and Contributors.
4	#
5	# This software is subject to the provisions of the Zope Public License,
6	# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution.
7	# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
8	# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
9	# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
10	# FOR A PARTICULAR PURPOSE
11	#
12	##############################################################################
13
14	import binascii	1✔
15	# Use the system PRNG if possible
16	import random	1✔
17	import time	1✔
18	import warnings	1✔
19	from binascii import a2b_base64	1✔
20	from binascii import b2a_base64	1✔
21	from hashlib import sha1 as sha	1✔
22	from hashlib import sha256	1✔
23	from os import getpid	1✔
24	from os import urandom	1✔
25
26	from .compat import b	1✔
27	from .compat import u	1✔
28
29
30	try:	1✔
31	random = random.SystemRandom()	1✔
32	using_sysrandom = True	1✔
33	except NotImplementedError: # pragma: no cover
34	using_sysrandom = False
35
36
37	def _reseed():	1✔
38	if not using_sysrandom:	1✔
39	# This is ugly, and a hack, but it makes things better than
40	# the alternative of predictability. This re-seeds the PRNG
41	# using a value that is hard for an attacker to predict, every
42	# time a random string is required. This may change the
43	# properties of the chosen random sequence slightly, but this
44	# is better than absolute predictability.
45	random.seed(sha256( # pragma: no cover
46	f'{random.getstate()}{time.time()}{getpid()}'
47	).digest())
48
49
50	def _choice(c):	1✔
51	_reseed()	1✔
52	return random.choice(c)	1✔
53
54
55	def _randrange(r):	1✔
56	_reseed()	×
57	return random.randrange(r)	×
58
59
60	def constant_time_compare(val1, val2):	1✔
61	"""
62	Returns True if the two strings are equal, False otherwise.
63
64	The time taken is independent of the number of characters that match.
65	"""
66	if len(val1) != len(val2):	1✔
67	return False	1✔
68	result = 0	1✔
69	for x, y in zip(iter(val1), iter(val2)):	1✔
70	result \|= x ^ y	1✔
71	return result == 0	1✔
72
73
74	class PasswordEncryptionScheme: # An Interface	1✔
75
76	def encrypt(pw):	1✔
77	"""
78	Encrypt the provided plain text password.
79	"""
80
81	def validate(reference, attempt):	1✔
82	"""
83	Validate the provided password string. Reference is the
84	correct password, which may be encrypted; attempt is clear text
85	password attempt.
86	"""
87
88
89	_schemes = []	1✔
90
91
92	def registerScheme(id, s):	1✔
93	'''
94	Registers an LDAP password encoding scheme.
95	'''
96	_schemes.append((id, '{%s}' % id, s))	1✔
97
98
99	def listSchemes():	1✔
100	return [id for id, prefix, scheme in _getSortedSchemes()]	1✔
101
102
103	def _getSortedSchemes():	1✔
104	""" Return a reversed sorted sequence of encryption schemes.
105
106	Several places iterate over schemes and compare the prefix with the start
107	of a password string. Using a reverse-sorted sequence makes sure that e.g.
108	'SHA256' is always tested before 'SHA' to prevent bad matches.
109	"""
110	return sorted(_schemes, reverse=True)	1✔
111
112
113	class SSHADigestScheme:	1✔
114	'''
115	SSHA is a modification of the SHA digest scheme with a salt
116	starting at byte 20 of the base64-encoded string.
117	'''
118	# Source: http://developer.netscape.com/docs/technote/ldap/pass_sha.html
119
120	def generate_salt(self):	1✔
121	# Salt can be any length, but not more than about 37 characters
122	# because of limitations of the binascii module.
123	# 7 is what Netscape's example used and should be enough.
124	# All 256 characters are available.
125	return urandom(7)	1✔
126
127	def encrypt(self, pw):	1✔
128	return self._encrypt_with_salt(pw, self.generate_salt())	1✔
129
130	def validate(self, reference, attempt):	1✔
131	try:	1✔
132	ref = a2b_base64(reference)	1✔
133	except binascii.Error: # pragma: no cover
134	# Not valid base64.
135	return 0
136	salt = ref[20:]	1✔
137	compare = self._encrypt_with_salt(attempt, salt)	1✔
138	return constant_time_compare(compare, reference)	1✔
139
140	def _encrypt_with_salt(self, pw, salt):	1✔
141	pw = b(pw)	1✔
142	return b2a_base64(sha(pw + salt).digest() + salt)[:-1]	1✔
143
144
145	registerScheme('SSHA', SSHADigestScheme())	1✔
146
147
148	class SHADigestScheme:	1✔
149
150	def encrypt(self, pw):	1✔
151	return self._encrypt(pw)	1✔
152
153	def validate(self, reference, attempt):	1✔
154	compare = self._encrypt(attempt)	1✔
155	return constant_time_compare(compare, reference)	1✔
156
157	def _encrypt(self, pw):	1✔
158	pw = b(pw)	1✔
159	return b2a_base64(sha(pw).digest())[:-1]	1✔
160
161
162	registerScheme('SHA', SHADigestScheme())	1✔
163
164
165	class SHA256DigestScheme:	1✔
166
167	def encrypt(self, pw):	1✔
168	return b(sha256(b(pw)).hexdigest())	1✔
169
170	def validate(self, reference, attempt):	1✔
171	a = self.encrypt(attempt)	1✔
172	return constant_time_compare(a, reference)	1✔
173
174
175	registerScheme('SHA256', SHA256DigestScheme())	1✔
176
177
178	# Bcrypt support may not have been requested at installation time
179	# - installed via the 'bcrypt' extra
180	try:	1✔
181	import bcrypt	1✔
NEW 182	except ModuleNotFoundError:	×
UNCOV 183	bcrypt = None	×
184
185
186	class BCRYPTHashingScheme:	1✔
187	"""A BCRYPT hashing scheme."""
188
189	@staticmethod	1✔
190	def _ensure_bytes(pw, encoding='utf-8'):	1✔
191	"""Ensures the given password `pw` is returned as bytes."""
192	if isinstance(pw, str):	1✔
193	pw = pw.encode(encoding)	1✔
194	return pw	1✔
195
196	def encrypt(self, pw):	1✔
197	return bcrypt.hashpw(self._ensure_bytes(pw), bcrypt.gensalt())	1✔
198
199	def validate(self, reference, attempt):	1✔
200	try:	1✔
201	return bcrypt.checkpw(self._ensure_bytes(attempt), reference)	1✔
202	except ValueError:	×
203	# Usually due to an invalid salt
204	return False	×
205
206
207	if bcrypt is not None:	1!
208	registerScheme('BCRYPT', BCRYPTHashingScheme())	1✔
209
210
211	# Suppress deprecation warnings on Python 3.11 and up
212	with warnings.catch_warnings():	1✔
213	warnings.simplefilter('ignore')	1✔
214
215	# crypt is not available on all platforms
216	try:	1✔
217	from crypt import crypt	1✔
218	except ImportError:
219	crypt = None
220
221
222	if crypt is not None:	1!
223
224	class CryptDigestScheme:	1✔
225
226	def generate_salt(self):	1✔
227	choices = ("ABCDEFGHIJKLMNOPQRSTUVWXYZ"	1✔
228	"abcdefghijklmnopqrstuvwxyz"
229	"0123456789./")
230	return _choice(choices) + _choice(choices)	1✔
231
232	def encrypt(self, pw):	1✔
233	return b(crypt(self._recode_password(pw), self.generate_salt()))	1✔
234
235	def validate(self, reference, attempt):	1✔
236	attempt = self._recode_password(attempt)	1✔
237	a = b(crypt(attempt, reference[:2].decode('ascii')))	1✔
238	return constant_time_compare(a, reference)	1✔
239
240	def _recode_password(self, pw):	1✔
241	# crypt always requires `str`
242	return u(pw)	1✔
243
244	registerScheme('CRYPT', CryptDigestScheme())	1✔
245
246
247	class MySQLDigestScheme:	1✔
248
249	def encrypt(self, pw):	1✔
250	pw = u(pw)	1✔
251	nr = 1345345333	1✔
252	add = 7	1✔
253	nr2 = int(0x12345671)	1✔
254	for i in pw:	1✔
255	if i == ' ' or i == '\t':	1✔
256	continue	1✔
257	nr ^= (((nr & 63) + add) * ord(i)) + (nr << 8)	1✔
258	nr2 += (nr2 << 8) ^ nr	1✔
259	add += ord(i)	1✔
260	r0 = nr & ((1 << 31) - 1)	1✔
261	r1 = nr2 & ((1 << 31) - 1)	1✔
262	return f'{r0:08x}{r1:08x}'.encode('ascii')	1✔
263
264	def validate(self, reference, attempt):	1✔
265	a = self.encrypt(attempt)	1✔
266	return constant_time_compare(a, reference)	1✔
267
268
269	registerScheme('MYSQL', MySQLDigestScheme())	1✔
270
271
272	def pw_validate(reference, attempt):	1✔
273	"""Validate the provided password string, which uses LDAP-style encoding
274	notation. Reference is the correct password, attempt is clear text
275	password attempt."""
276	reference = b(reference)	1✔
277	for id, prefix, scheme in _getSortedSchemes():	1✔
278	lp = len(prefix)	1✔
279	if reference[:lp] == b(prefix):	1✔
280	return scheme.validate(reference[lp:], attempt)	1✔
281	# Assume cleartext.
282	return constant_time_compare(reference, b(attempt))	1✔
283
284
285	def is_encrypted(pw):	1✔
286	pw = b(pw)	1✔
287	for id, prefix, scheme in _getSortedSchemes():	1✔
288	lp = len(prefix)	1✔
289	if pw[:lp] == b(prefix):	1✔
290	return 1	1✔
291	return 0	1✔
292
293
294	def pw_encrypt(pw, encoding='SSHA'):	1✔
295	"""Encrypt the provided plain text password using the encoding if provided
296	and return it in an LDAP-style representation."""
297	encoding = u(encoding)	1✔
298	for id, prefix, scheme in _getSortedSchemes():	1✔
299	if encoding == id:	1✔
300	return b(prefix) + scheme.encrypt(pw)	1✔
301	raise ValueError('Not supported: %s' % encoding)	1✔
302
303
304	pw_encode = pw_encrypt # backward compatibility	1✔

zopefoundation / AuthEncoding / 9731793428

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous