source4/dsdb/tests/python/password_settings.py

   1 #!/usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3 #
   4 # Tests for Password Settings Objects.
   5 #
   6 # This also tests the default password complexity (i.e. pwdProperties),
   7 # minPwdLength, pwdHistoryLength settings as a side-effect.
   8 #
   9 # Copyright (C) Andrew Bartlett <abartlet@samba.org> 2018
  10 #
  11 # This program is free software; you can redistribute it and/or modify
  12 # it under the terms of the GNU General Public License as published by
  13 # the Free Software Foundation; either version 3 of the License, or
  14 # (at your option) any later version.
  15 #
  16 # This program is distributed in the hope that it will be useful,
  17 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19 # GNU General Public License for more details.
  20 #
  21 # You should have received a copy of the GNU General Public License
  22 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  23 #
  24
  25 #
  26 # Usage:
  27 #  export SERVER_IP=target_dc
  28 #  export SUBUNITRUN=$samba4srcdir/scripting/bin/subunitrun
  29 #  PYTHONPATH="$PYTHONPATH:$samba4srcdir/dsdb/tests/python" $SUBUNITRUN \
  30 #       password_settings -U"$DOMAIN/$DC_USERNAME"%"$DC_PASSWORD"
  31 #
  32
  33 import samba.tests
  34 import ldb
  35 from ldb import FLAG_MOD_DELETE, FLAG_MOD_ADD, FLAG_MOD_REPLACE
  36 from samba import dsdb
  37 import time
  38 from samba.tests.password_test import PasswordTestCase
  39 from samba.tests.pso import TestUser
  40 from samba.tests.pso import PasswordSettings
  41 from samba.tests import env_get_var_value
  42 from samba.credentials import Credentials
  43 from samba import gensec
  44 import base64
  45
  46
  47 class PasswordSettingsTestCase(PasswordTestCase):
  48     def setUp(self):
  49         super(PasswordSettingsTestCase, self).setUp()
  50
  51         self.host_url = "ldap://%s" % env_get_var_value("SERVER_IP")
  52         self.ldb = samba.tests.connect_samdb(self.host_url)
  53
  54         # create a temp OU to put this test's users into
  55         self.ou = samba.tests.create_test_ou(self.ldb, "password_settings")
  56
  57         # update DC to allow password changes for the duration of this test
  58         self.allow_password_changes()
  59
  60         # store the current password-settings for the domain
  61         self.pwd_defaults = PasswordSettings(None, self.ldb)
  62         self.test_objs = []
  63
  64     def tearDown(self):
  65         super(PasswordSettingsTestCase, self).tearDown()
  66
  67         # remove all objects under the top-level OU
  68         self.ldb.delete(self.ou, ["tree_delete:1"])
  69
  70         # PSOs can't reside within an OU so they get cleaned up separately
  71         for obj in self.test_objs:
  72             self.ldb.delete(obj)
  73
  74     def add_obj_cleanup(self, dn_list):
  75         """Handles cleanup of objects outside of the test OU in the tearDown"""
  76         self.test_objs.extend(dn_list)
  77
  78     def add_group(self, group_name):
  79         """Creates a new group"""
  80         dn = "CN=%s,%s" % (group_name, self.ou)
  81         self.ldb.add({"dn": dn, "objectclass": "group"})
  82         return dn
  83
  84     def set_attribute(self, dn, attr, value, operation=FLAG_MOD_ADD,
  85                       samdb=None):
  86         """Modifies an attribute for an object"""
  87         if samdb is None:
  88             samdb = self.ldb
  89         m = ldb.Message()
  90         m.dn = ldb.Dn(samdb, dn)
  91         m[attr] = ldb.MessageElement(value, operation, attr)
  92         samdb.modify(m)
  93
  94     def add_user(self, username):
  95         # add a new user to the DB under our top-level OU
  96         userou = "ou=%s" % self.ou.get_component_value(0)
  97         return TestUser(username, self.ldb, userou=userou)
  98
  99     def assert_password_invalid(self, user, password):
 100         """
 101         Check we can't set a password that violates complexity or length
 102         constraints
 103         """
 104         try:
 105             user.set_password(password)
 106             # fail the test if no exception was encountered
 107             self.fail("Password '%s' should have been rejected" % password)
 108         except ldb.LdbError as e:
 109             (num, msg) = e.args
 110             self.assertEquals(num, ldb.ERR_CONSTRAINT_VIOLATION, msg)
 111             self.assertTrue('0000052D' in msg, msg)
 112
 113     def assert_password_valid(self, user, password):
 114         """Checks that we can set a password successfully"""
 115         try:
 116             user.set_password(password)
 117         except ldb.LdbError as e:
 118             (num, msg) = e.args
 119             # fail the test (rather than throw an error)
 120             self.fail("Password '%s' unexpectedly rejected: %s" % (password,
 121                                                                    msg))
 122
 123     def assert_PSO_applied(self, user, pso):
 124         """
 125         Asserts the expected PSO is applied by checking the msDS-ResultantPSO
 126         attribute, as well as checking the corresponding password-length,
 127         complexity, and history are enforced correctly
 128         """
 129         resultant_pso = user.get_resultant_PSO()
 130         self.assertTrue(resultant_pso == pso.dn,
 131                         "Expected PSO %s, not %s" % (pso.name,
 132                                                      str(resultant_pso)))
 133
 134         # we're mirroring the pwd_history for the user, so make sure this is
 135         # up-to-date, before we start making password changes
 136         if user.last_pso:
 137             user.pwd_history_change(user.last_pso.history_len, pso.history_len)
 138         user.last_pso = pso
 139
 140         # check if we can set a sufficiently long, but non-complex, password.
 141         # (We use the history-size to generate a unique password for each
 142         # assertion - otherwise, if the password is already in the history,
 143         # then it'll be rejected)
 144         unique_char = chr(ord('a') + len(user.all_old_passwords))
 145         noncomplex_pwd = "%cabcdefghijklmnopqrst" % unique_char
 146
 147         if pso.complexity:
 148             self.assert_password_invalid(user, noncomplex_pwd)
 149         else:
 150             self.assert_password_valid(user, noncomplex_pwd)
 151
 152         # use a unique and sufficiently complex base-string to check pwd-length
 153         pass_phrase = "%d#AaBbCcDdEeFfGgHhIi" % len(user.all_old_passwords)
 154
 155         # check that passwords less than the specified length are rejected
 156         for i in range(3, pso.password_len):
 157             self.assert_password_invalid(user, pass_phrase[:i])
 158
 159         # check we can set a password that's exactly the minimum length
 160         self.assert_password_valid(user, pass_phrase[:pso.password_len])
 161
 162         # check the password history is enforced correctly.
 163         # first, check the last n items in the password history are invalid
 164         invalid_passwords = user.old_invalid_passwords(pso.history_len)
 165         for pwd in invalid_passwords:
 166             self.assert_password_invalid(user, pwd)
 167
 168         # next, check any passwords older than the history-len can be re-used
 169         valid_passwords = user.old_valid_passwords(pso.history_len)
 170         for pwd in valid_passwords:
 171             self.assert_set_old_password(user, pwd, pso)
 172
 173     def password_is_complex(self, password):
 174         # non-complex passwords used in the tests are all lower-case letters
 175         # If it's got a number in the password, assume it's complex
 176         return any(c.isdigit() for c in password)
 177
 178     def assert_set_old_password(self, user, password, pso):
 179         """
 180         Checks a user password can be set (if the password conforms to the PSO
 181         settings). Used to check an old password that falls outside the history
 182         length, but might still be invalid for other reasons.
 183         """
 184         if self.password_is_complex(password):
 185             # check password conforms to length requirements
 186             if len(password) < pso.password_len:
 187                 self.assert_password_invalid(user, password)
 188             else:
 189                 self.assert_password_valid(user, password)
 190         else:
 191             # password is not complex, check PSO handles it appropriately
 192             if pso.complexity:
 193                 self.assert_password_invalid(user, password)
 194             else:
 195                 self.assert_password_valid(user, password)
 196
 197     def test_pso_basics(self):
 198         """Simple tests that a PSO takes effect when applied to a group/user"""
 199
 200         # create some PSOs that vary in priority and basic password-len
 201         best_pso = PasswordSettings("highest-priority-PSO", self.ldb,
 202                                     precedence=5, password_len=16,
 203                                     history_len=6)
 204         medium_pso = PasswordSettings("med-priority-PSO", self.ldb,
 205                                       precedence=15, password_len=10,
 206                                       history_len=4)
 207         worst_pso = PasswordSettings("lowest-priority-PSO", self.ldb,
 208                                      precedence=100, complexity=False,
 209                                      password_len=4, history_len=2)
 210
 211         # handle PSO clean-up (as they're outside the top-level test OU)
 212         self.add_obj_cleanup([worst_pso.dn, medium_pso.dn, best_pso.dn])
 213
 214         # create some groups and apply the PSOs to the groups
 215         group1 = self.add_group("Group-1")
 216         group2 = self.add_group("Group-2")
 217         group3 = self.add_group("Group-3")
 218         group4 = self.add_group("Group-4")
 219         worst_pso.apply_to(group1)
 220         medium_pso.apply_to(group2)
 221         best_pso.apply_to(group3)
 222         worst_pso.apply_to(group4)
 223
 224         # create a user and check the default settings apply to it
 225         user = self.add_user("testuser")
 226         self.assert_PSO_applied(user, self.pwd_defaults)
 227
 228         # add user to a group. Check that the group's PSO applies to the user
 229         self.set_attribute(group1, "member", user.dn)
 230         self.assert_PSO_applied(user, worst_pso)
 231
 232         # add the user to a group with a higher precedence PSO and and check
 233         # that now trumps the previous PSO
 234         self.set_attribute(group2, "member", user.dn)
 235         self.assert_PSO_applied(user, medium_pso)
 236
 237         # add the user to the remaining groups. The highest precedence PSO
 238         # should now take effect
 239         self.set_attribute(group3, "member", user.dn)
 240         self.set_attribute(group4, "member", user.dn)
 241         self.assert_PSO_applied(user, best_pso)
 242
 243         # delete a group membership and check the PSO changes
 244         self.set_attribute(group3, "member", user.dn,
 245                            operation=FLAG_MOD_DELETE)
 246         self.assert_PSO_applied(user, medium_pso)
 247
 248         # apply the low-precedence PSO directly to the user
 249         # (directly applied PSOs should trump higher precedence group PSOs)
 250         worst_pso.apply_to(user.dn)
 251         self.assert_PSO_applied(user, worst_pso)
 252
 253         # remove applying the PSO directly to the user and check PSO changes
 254         worst_pso.unapply(user.dn)
 255         self.assert_PSO_applied(user, medium_pso)
 256
 257         # remove all appliesTo and check we have the default settings again
 258         worst_pso.unapply(group1)
 259         medium_pso.unapply(group2)
 260         worst_pso.unapply(group4)
 261         self.assert_PSO_applied(user, self.pwd_defaults)
 262
 263     def test_pso_nested_groups(self):
 264         """PSOs operate correctly when applied to nested groups"""
 265
 266         # create some PSOs that vary in priority and basic password-len
 267         group1_pso = PasswordSettings("group1-PSO", self.ldb, precedence=50,
 268                                       password_len=12, history_len=3)
 269         group2_pso = PasswordSettings("group2-PSO", self.ldb, precedence=25,
 270                                       password_len=10, history_len=5,
 271                                       complexity=False)
 272         group3_pso = PasswordSettings("group3-PSO", self.ldb, precedence=10,
 273                                       password_len=6, history_len=2)
 274
 275         # create some groups and apply the PSOs to the groups
 276         group1 = self.add_group("Group-1")
 277         group2 = self.add_group("Group-2")
 278         group3 = self.add_group("Group-3")
 279         group4 = self.add_group("Group-4")
 280         group1_pso.apply_to(group1)
 281         group2_pso.apply_to(group2)
 282         group3_pso.apply_to(group3)
 283
 284         # create a PSO and apply it to a group that the user is not a member
 285         # of - it should not have any effect on the user
 286         unused_pso = PasswordSettings("unused-PSO", self.ldb, precedence=1,
 287                                       password_len=20)
 288         unused_pso.apply_to(group4)
 289
 290         # handle PSO clean-up (as they're outside the top-level test OU)
 291         self.add_obj_cleanup([group1_pso.dn, group2_pso.dn, group3_pso.dn,
 292                               unused_pso.dn])
 293
 294         # create a user and check the default settings apply to it
 295         user = self.add_user("testuser")
 296         self.assert_PSO_applied(user, self.pwd_defaults)
 297
 298         # add user to a group. Check that the group's PSO applies to the user
 299         self.set_attribute(group1, "member", user.dn)
 300         self.set_attribute(group2, "member", group1)
 301         self.assert_PSO_applied(user, group2_pso)
 302
 303         # add another level to the group heirachy & check this PSO takes effect
 304         self.set_attribute(group3, "member", group2)
 305         self.assert_PSO_applied(user, group3_pso)
 306
 307         # invert the PSO precedence and check the new lowest value takes effect
 308         group1_pso.set_precedence(3)
 309         group2_pso.set_precedence(13)
 310         group3_pso.set_precedence(33)
 311         self.assert_PSO_applied(user, group1_pso)
 312
 313         # delete a PSO and check it no longer applies
 314         self.ldb.delete(group1_pso.dn)
 315         self.test_objs.remove(group1_pso.dn)
 316         self.assert_PSO_applied(user, group2_pso)
 317
 318     def get_guid(self, dn):
 319         res = self.ldb.search(base=dn, attrs=["objectGUID"],
 320                               scope=ldb.SCOPE_BASE)
 321         return res[0]['objectGUID'][0]
 322
 323     def guid_string(self, guid):
 324         return self.ldb.schema_format_value("objectGUID", guid)
 325
 326     def PSO_with_lowest_GUID(self, pso_list):
 327         """Returns the PSO object in the list with the lowest GUID"""
 328         # go through each PSO and fetch its GUID
 329         guid_list = []
 330         mapping = {}
 331         for pso in pso_list:
 332             guid = self.get_guid(pso.dn)
 333             guid_list.append(guid)
 334             # remember which GUID maps to what PSO
 335             mapping[guid] = pso
 336
 337         # sort the GUID list to work out the lowest/best GUID
 338         guid_list.sort()
 339         best_guid = guid_list[0]
 340
 341         # sanity-check the mapping between GUID and DN is correct
 342         best_pso_dn = mapping[best_guid].dn
 343         self.assertEqual(self.guid_string(self.get_guid(best_pso_dn)),
 344                          self.guid_string(best_guid))
 345
 346         # return the PSO that this GUID corresponds to
 347         return mapping[best_guid]
 348
 349     def test_pso_equal_precedence(self):
 350         """Tests expected PSO wins when several have the same precedence"""
 351
 352         # create some PSOs that vary in priority and basic password-len
 353         pso1 = PasswordSettings("PSO-1", self.ldb, precedence=5, history_len=1,
 354                                 password_len=11)
 355         pso2 = PasswordSettings("PSO-2", self.ldb, precedence=5, history_len=2,
 356                                 password_len=8)
 357         pso3 = PasswordSettings("PSO-3", self.ldb, precedence=5, history_len=3,
 358                                 password_len=5, complexity=False)
 359         pso4 = PasswordSettings("PSO-4", self.ldb, precedence=5, history_len=4,
 360                                 password_len=13, complexity=False)
 361
 362         # handle PSO clean-up (as they're outside the top-level test OU)
 363         self.add_obj_cleanup([pso1.dn, pso2.dn, pso3.dn, pso4.dn])
 364
 365         # create some groups and apply the PSOs to the groups
 366         group1 = self.add_group("Group-1")
 367         group2 = self.add_group("Group-2")
 368         group3 = self.add_group("Group-3")
 369         group4 = self.add_group("Group-4")
 370         pso1.apply_to(group1)
 371         pso2.apply_to(group2)
 372         pso3.apply_to(group3)
 373         pso4.apply_to(group4)
 374
 375         # create a user and check the default settings apply to it
 376         user = self.add_user("testuser")
 377         self.assert_PSO_applied(user, self.pwd_defaults)
 378
 379         # add the user to all the groups
 380         self.set_attribute(group1, "member", user.dn)
 381         self.set_attribute(group2, "member", user.dn)
 382         self.set_attribute(group3, "member", user.dn)
 383         self.set_attribute(group4, "member", user.dn)
 384
 385         # precedence is equal, so the PSO with lowest GUID gets applied
 386         pso_list = [pso1, pso2, pso3, pso4]
 387         best_pso = self.PSO_with_lowest_GUID(pso_list)
 388         self.assert_PSO_applied(user, best_pso)
 389
 390         # excluding the winning PSO, apply the other PSOs directly to the user
 391         pso_list.remove(best_pso)
 392         for pso in pso_list:
 393             pso.apply_to(user.dn)
 394
 395         # we should now have a different PSO applied (the 2nd lowest GUID)
 396         next_best_pso = self.PSO_with_lowest_GUID(pso_list)
 397         self.assertTrue(next_best_pso is not best_pso)
 398         self.assert_PSO_applied(user, next_best_pso)
 399
 400         # bump the precedence of another PSO and it should now win
 401         pso_list.remove(next_best_pso)
 402         best_pso = pso_list[0]
 403         best_pso.set_precedence(4)
 404         self.assert_PSO_applied(user, best_pso)
 405
 406     def test_pso_invalid_location(self):
 407         """Tests that PSOs in an invalid location have no effect"""
 408
 409         # PSOs should only be able to be created within a Password Settings
 410         # Container object. Trying to create one under an OU should fail
 411         try:
 412             rogue_pso = PasswordSettings("rogue-PSO", self.ldb, precedence=1,
 413                                          complexity=False, password_len=20,
 414                                          container=self.ou)
 415             self.fail()
 416         except ldb.LdbError as e:
 417             (num, msg) = e.args
 418             self.assertEquals(num, ldb.ERR_NAMING_VIOLATION, msg)
 419             # Windows returns 2099 (Illegal superior), Samba returns 2037
 420             # (Naming violation - "not a valid child class")
 421             self.assertTrue('00002099' in msg or '00002037' in msg, msg)
 422
 423         # we can't create Password Settings Containers under an OU either
 424         try:
 425             rogue_psc = "CN=Rogue-PSO-container,%s" % self.ou
 426             self.ldb.add({"dn": rogue_psc,
 427                           "objectclass": "msDS-PasswordSettingsContainer"})
 428             self.fail()
 429         except ldb.LdbError as e:
 430             (num, msg) = e.args
 431             self.assertEquals(num, ldb.ERR_NAMING_VIOLATION, msg)
 432             self.assertTrue('00002099' in msg or '00002037' in msg, msg)
 433
 434         base_dn = self.ldb.get_default_basedn()
 435         rogue_psc = "CN=Rogue-PSO-container,CN=Computers,%s" % base_dn
 436         self.ldb.add({"dn": rogue_psc,
 437                       "objectclass": "msDS-PasswordSettingsContainer"})
 438
 439         rogue_pso = PasswordSettings("rogue-PSO", self.ldb, precedence=1,
 440                                      container=rogue_psc, password_len=20)
 441         self.add_obj_cleanup([rogue_pso.dn, rogue_psc])
 442
 443         # apply the PSO to a group and check it has no effect on the user
 444         user = self.add_user("testuser")
 445         group = self.add_group("Group-1")
 446         rogue_pso.apply_to(group)
 447         self.set_attribute(group, "member", user.dn)
 448         self.assert_PSO_applied(user, self.pwd_defaults)
 449
 450         # apply the PSO directly to the user and check it has no effect
 451         rogue_pso.apply_to(user.dn)
 452         self.assert_PSO_applied(user, self.pwd_defaults)
 453
 454     # the PSOs created in these test-cases all use a default min-age of zero.
 455     # This is the only test case that checks the PSO's min-age is enforced
 456     def test_pso_min_age(self):
 457         """Tests that a PSO's min-age is enforced"""
 458         pso = PasswordSettings("min-age-PSO", self.ldb, password_len=10,
 459                                password_age_min=2, complexity=False)
 460         self.add_obj_cleanup([pso.dn])
 461
 462         # create a user and apply the PSO
 463         user = self.add_user("testuser")
 464         pso.apply_to(user.dn)
 465         self.assertTrue(user.get_resultant_PSO() == pso.dn)
 466
 467         # changing the password immediately should fail, even if the password
 468         # is valid
 469         valid_password = "min-age-passwd"
 470         self.assert_password_invalid(user, valid_password)
 471         # then trying the same password later should succeed
 472         time.sleep(pso.password_age_min + 0.5)
 473         self.assert_password_valid(user, valid_password)
 474
 475     def test_pso_max_age(self):
 476         """Tests that a PSO's max-age is used"""
 477
 478         # create PSOs that use the domain's max-age +/- 1 day
 479         domain_max_age = self.pwd_defaults.password_age_max
 480         day_in_secs = 60 * 60 * 24
 481         higher_max_age = domain_max_age + day_in_secs
 482         lower_max_age = domain_max_age - day_in_secs
 483         longer_pso = PasswordSettings("longer-age-PSO", self.ldb, precedence=5,
 484                                       password_age_max=higher_max_age)
 485         shorter_pso = PasswordSettings("shorter-age-PSO", self.ldb,
 486                                        precedence=1,
 487                                        password_age_max=lower_max_age)
 488         self.add_obj_cleanup([longer_pso.dn, shorter_pso.dn])
 489
 490         user = self.add_user("testuser")
 491
 492         # we can't wait around long enough for the max-age to expire, so
 493         # instead just check the msDS-UserPasswordExpiryTimeComputed for
 494         # the user
 495         attrs = ['msDS-UserPasswordExpiryTimeComputed']
 496         res = self.ldb.search(user.dn, attrs=attrs)
 497         domain_expiry = int(res[0]['msDS-UserPasswordExpiryTimeComputed'][0])
 498
 499         # apply the longer PSO and check the expiry-time becomes longer
 500         longer_pso.apply_to(user.dn)
 501         self.assertTrue(user.get_resultant_PSO() == longer_pso.dn)
 502         res = self.ldb.search(user.dn, attrs=attrs)
 503         new_expiry = int(res[0]['msDS-UserPasswordExpiryTimeComputed'][0])
 504
 505         # use timestamp diff of 1 day - 1 minute. The new expiry should still
 506         # be greater than this, without getting into nano-second granularity
 507         approx_timestamp_diff = (day_in_secs - 60) * (1e7)
 508         self.assertTrue(new_expiry > domain_expiry + approx_timestamp_diff)
 509
 510         # apply the shorter PSO and check the expiry-time is shorter
 511         shorter_pso.apply_to(user.dn)
 512         self.assertTrue(user.get_resultant_PSO() == shorter_pso.dn)
 513         res = self.ldb.search(user.dn, attrs=attrs)
 514         new_expiry = int(res[0]['msDS-UserPasswordExpiryTimeComputed'][0])
 515         self.assertTrue(new_expiry < domain_expiry - approx_timestamp_diff)
 516
 517     def test_pso_special_groups(self):
 518         """Checks applying a PSO to built-in AD groups takes effect"""
 519
 520         # create some PSOs that will apply to special groups
 521         default_pso = PasswordSettings("default-PSO", self.ldb, precedence=20,
 522                                        password_len=8, complexity=False)
 523         guest_pso = PasswordSettings("guest-PSO", self.ldb, history_len=4,
 524                                      precedence=5, password_len=5)
 525         builtin_pso = PasswordSettings("builtin-PSO", self.ldb, history_len=9,
 526                                        precedence=1, password_len=9)
 527         admin_pso = PasswordSettings("admin-PSO", self.ldb, history_len=0,
 528                                      precedence=2, password_len=10)
 529         self.add_obj_cleanup([default_pso.dn, guest_pso.dn, admin_pso.dn,
 530                               builtin_pso.dn])
 531         base_dn = self.ldb.domain_dn()
 532         domain_users = "CN=Domain Users,CN=Users,%s" % base_dn
 533         domain_guests = "CN=Domain Guests,CN=Users,%s" % base_dn
 534         admin_users = "CN=Domain Admins,CN=Users,%s" % base_dn
 535
 536         # if we apply a PSO to Domain Users (which all users are a member of)
 537         # then that PSO should take effect on a new user
 538         default_pso.apply_to(domain_users)
 539         user = self.add_user("testuser")
 540         self.assert_PSO_applied(user, default_pso)
 541
 542         # Apply a PSO to a builtin group. 'Domain Users' should be a member of
 543         # Builtin/Users, but builtin groups should be excluded from the PSO
 544         # calculation, so this should have no effect
 545         builtin_pso.apply_to("CN=Users,CN=Builtin,%s" % base_dn)
 546         builtin_pso.apply_to("CN=Administrators,CN=Builtin,%s" % base_dn)
 547         self.assert_PSO_applied(user, default_pso)
 548
 549         # change the user's primary group to another group (the primaryGroupID
 550         # is a little odd in that there's no memberOf backlink for it)
 551         self.set_attribute(domain_guests, "member", user.dn)
 552         user.set_primary_group(domain_guests)
 553         # No PSO is applied to the Domain Guests yet, so the default PSO should
 554         # still apply
 555         self.assert_PSO_applied(user, default_pso)
 556
 557         # now apply a PSO to the guests group, which should trump the default
 558         # PSO (because the guest PSO has a better precedence)
 559         guest_pso.apply_to(domain_guests)
 560         self.assert_PSO_applied(user, guest_pso)
 561
 562         # create a new group that's a member of Admin Users
 563         nested_group = self.add_group("nested-group")
 564         self.set_attribute(admin_users, "member", nested_group)
 565         # set the user's primary-group to be the new group
 566         self.set_attribute(nested_group, "member", user.dn)
 567         user.set_primary_group(nested_group)
 568         # we've only changed group membership so far, not the PSO
 569         self.assert_PSO_applied(user, guest_pso)
 570
 571         # now apply the best-precedence PSO to Admin Users and check it applies
 572         # to the user (via the nested-group's membership)
 573         admin_pso.apply_to(admin_users)
 574         self.assert_PSO_applied(user, admin_pso)
 575
 576         # restore the default primaryGroupID so we can safely delete the group
 577         user.set_primary_group(domain_users)
 578
 579     def test_pso_none_applied(self):
 580         """Tests cases where no Resultant PSO should be returned"""
 581
 582         # create a PSO that we will check *doesn't* get returned
 583         dummy_pso = PasswordSettings("dummy-PSO", self.ldb, password_len=20)
 584         self.add_obj_cleanup([dummy_pso.dn])
 585
 586         # you can apply a PSO to other objects (like OUs), but the resultantPSO
 587         # attribute should only be returned for users
 588         dummy_pso.apply_to(str(self.ou))
 589         res = self.ldb.search(self.ou, attrs=['msDS-ResultantPSO'])
 590         self.assertFalse('msDS-ResultantPSO' in res[0])
 591
 592         # create a dummy user and apply the PSO
 593         user = self.add_user("testuser")
 594         dummy_pso.apply_to(user.dn)
 595         self.assertTrue(user.get_resultant_PSO() == dummy_pso.dn)
 596
 597         # now clear the ADS_UF_NORMAL_ACCOUNT flag for the user, which should
 598         # mean a resultant PSO is no longer returned (we're essentially turning
 599         # the user into a DC here, which is a little overkill but tests
 600         # behaviour as per the Windows specification)
 601         self.set_attribute(user.dn, "userAccountControl",
 602                            str(dsdb.UF_WORKSTATION_TRUST_ACCOUNT),
 603                            operation=FLAG_MOD_REPLACE)
 604         self.assertIsNone(user.get_resultant_PSO())
 605
 606         # reset it back to a normal user account
 607         self.set_attribute(user.dn, "userAccountControl",
 608                            str(dsdb.UF_NORMAL_ACCOUNT),
 609                            operation=FLAG_MOD_REPLACE)
 610         self.assertTrue(user.get_resultant_PSO() == dummy_pso.dn)
 611
 612         # no PSO should be returned if RID is equal to DOMAIN_USER_RID_KRBTGT
 613         # (note this currently fails against Windows due to a Windows bug)
 614         krbtgt_user = "CN=krbtgt,CN=Users,%s" % self.ldb.domain_dn()
 615         dummy_pso.apply_to(krbtgt_user)
 616         res = self.ldb.search(krbtgt_user, attrs=['msDS-ResultantPSO'])
 617         self.assertFalse('msDS-ResultantPSO' in res[0])
 618
 619     def get_ldb_connection(self, username, password, ldaphost):
 620         """Returns an LDB connection using the specified user's credentials"""
 621         creds = self.get_credentials()
 622         creds_tmp = Credentials()
 623         creds_tmp.set_username(username)
 624         creds_tmp.set_password(password)
 625         creds_tmp.set_domain(creds.get_domain())
 626         creds_tmp.set_realm(creds.get_realm())
 627         creds_tmp.set_workstation(creds.get_workstation())
 628         features = creds_tmp.get_gensec_features() | gensec.FEATURE_SEAL
 629         creds_tmp.set_gensec_features(features)
 630         return samba.tests.connect_samdb(ldaphost, credentials=creds_tmp)
 631
 632     def test_pso_permissions(self):
 633         """Checks that regular users can't modify/view PSO objects"""
 634
 635         user = self.add_user("testuser")
 636
 637         # get an ldb connection with the new user's privileges
 638         user_ldb = self.get_ldb_connection("testuser", user.get_password(),
 639                                            self.host_url)
 640
 641         # regular users should not be able to create a PSO (at least, not in
 642         # the default Password Settings container)
 643         try:
 644             priv_pso = PasswordSettings("priv-PSO", user_ldb, password_len=20)
 645             self.fail()
 646         except ldb.LdbError as e:
 647             (num, msg) = e.args
 648             self.assertEquals(num, ldb.ERR_INSUFFICIENT_ACCESS_RIGHTS, msg)
 649
 650         # create a PSO as the admin user
 651         priv_pso = PasswordSettings("priv-PSO", self.ldb, password_len=20)
 652         self.add_obj_cleanup([priv_pso.dn])
 653
 654         # regular users should not be able to apply a PSO to a user
 655         try:
 656             self.set_attribute(priv_pso.dn, "msDS-PSOAppliesTo", user.dn,
 657                                samdb=user_ldb)
 658             self.fail()
 659         except ldb.LdbError as e:
 660             (num, msg) = e.args
 661             self.assertEquals(num, ldb.ERR_INSUFFICIENT_ACCESS_RIGHTS, msg)
 662             self.assertTrue('00002098' in msg, msg)
 663
 664         self.set_attribute(priv_pso.dn, "msDS-PSOAppliesTo", user.dn,
 665                            samdb=self.ldb)
 666
 667         # regular users should not be able to change a PSO's precedence
 668         try:
 669             priv_pso.set_precedence(100, samdb=user_ldb)
 670             self.fail()
 671         except ldb.LdbError as e:
 672             (num, msg) = e.args
 673             self.assertEquals(num, ldb.ERR_INSUFFICIENT_ACCESS_RIGHTS, msg)
 674             self.assertTrue('00002098' in msg, msg)
 675
 676         priv_pso.set_precedence(100, samdb=self.ldb)
 677
 678         # regular users should not be able to view a PSO's settings
 679         pso_attrs = ["msDS-PSOAppliesTo", "msDS-PasswordSettingsPrecedence",
 680                      "msDS-PasswordHistoryLength", "msDS-LockoutThreshold",
 681                      "msDS-PasswordComplexityEnabled"]
 682
 683         # users can see the PSO object's DN, but not its attributes
 684         res = user_ldb.search(priv_pso.dn, scope=ldb.SCOPE_BASE,
 685                               attrs=pso_attrs)
 686         self.assertTrue(str(priv_pso.dn) == str(res[0].dn))
 687         for attr in pso_attrs:
 688             self.assertFalse(attr in res[0])
 689
 690         # whereas admin users can see everything
 691         res = self.ldb.search(priv_pso.dn, scope=ldb.SCOPE_BASE,
 692                               attrs=pso_attrs)
 693         for attr in pso_attrs:
 694             self.assertTrue(attr in res[0])
 695
 696         # check replace/delete operations can't be performed by regular users
 697         operations = [FLAG_MOD_REPLACE, FLAG_MOD_DELETE]
 698
 699         for oper in operations:
 700             try:
 701                 self.set_attribute(priv_pso.dn, "msDS-PSOAppliesTo", user.dn,
 702                                    samdb=user_ldb, operation=oper)
 703                 self.fail()
 704             except ldb.LdbError as e:
 705                 (num, msg) = e.args
 706                 self.assertEquals(num, ldb.ERR_INSUFFICIENT_ACCESS_RIGHTS, msg)
 707                 self.assertTrue('00002098' in msg, msg)
 708
 709             # ...but can be performed by the admin user
 710             self.set_attribute(priv_pso.dn, "msDS-PSOAppliesTo", user.dn,
 711                                samdb=self.ldb, operation=oper)
 712
 713     def format_password_for_ldif(self, password):
 714         """Encodes/decodes the password so that it's accepted in an LDIF"""
 715         pwd = '"{}"'.format(password)
 716         return base64.b64encode(pwd.encode('utf-16-le')).decode('utf8')
 717
 718     # The 'user add' case is a bit more complicated as you can't really query
 719     # the msDS-ResultantPSO attribute on a user that doesn't exist yet (it
 720     # won't have any group membership or PSOs applied directly against it yet).
 721     # In theory it's possible to still get an applicable PSO via the user's
 722     # primaryGroupID (i.e. 'Domain Users' by default). However, testing aginst
 723     # Windows shows that the PSO doesn't take effect during the user add
 724     # operation. (However, the Windows GUI tools presumably adds the user in 2
 725     # steps, because it does enforce the PSO for users added via the GUI).
 726     def test_pso_add_user(self):
 727         """Tests against a 'Domain Users' PSO taking effect on a new user"""
 728
 729         # create a PSO that will apply to users by default
 730         default_pso = PasswordSettings("default-PSO", self.ldb, precedence=20,
 731                                        password_len=12, complexity=False)
 732         self.add_obj_cleanup([default_pso.dn])
 733
 734         # apply the PSO to Domain Users (which all users are a member of). In
 735         # theory, this PSO *could* take effect on a new user (but it doesn't)
 736         domain_users = "CN=Domain Users,CN=Users,%s" % self.ldb.domain_dn()
 737         default_pso.apply_to(domain_users)
 738
 739         # first try to add a user with a password that doesn't meet the domain
 740         # defaults, to prove that the DC will reject bad passwords during a
 741         # user add
 742         userdn = "CN=testuser,%s" % self.ou
 743         password = self.format_password_for_ldif('abcdef')
 744
 745         # Note we use an LDIF operation to ensure that the password gets set
 746         # as part of the 'add' operation (whereas self.add_user() adds the user
 747         # first, then sets the password later in a 2nd step)
 748         try:
 749             ldif = """
 750 dn: %s
 751 objectClass: user
 752 sAMAccountName: testuser
 753 unicodePwd:: %s
 754 """ % (userdn, password)
 755             self.ldb.add_ldif(ldif)
 756             self.fail()
 757         except ldb.LdbError as e:
 758                 (num, msg) = e.args
 759                 # error codes differ between Samba and Windows
 760                 self.assertTrue(num == ldb.ERR_UNWILLING_TO_PERFORM or
 761                                 num == ldb.ERR_CONSTRAINT_VIOLATION, msg)
 762                 self.assertTrue('0000052D' in msg, msg)
 763
 764         # now use a password that meets the domain defaults, but doesn't meet
 765         # the PSO requirements. Note that Windows allows this, i.e. it doesn't
 766         # honour the PSO during the add operation
 767         password = self.format_password_for_ldif('abcde12#')
 768         ldif = """
 769 dn: %s
 770 objectClass: user
 771 sAMAccountName: testuser
 772 unicodePwd:: %s
 773 """ % (userdn, password)
 774         self.ldb.add_ldif(ldif)
 775
 776         # Now do essentially the same thing, but set the password in a 2nd step
 777         # which proves that the same password doesn't meet the PSO requirements
 778         userdn = "CN=testuser2,%s" % self.ou
 779         ldif = """
 780 dn: %s
 781 objectClass: user
 782 sAMAccountName: testuser2
 783 """ % userdn
 784         self.ldb.add_ldif(ldif)
 785
 786         # now that the user exists, assert that the PSO is honoured
 787         try:
 788             ldif = """
 789 dn: %s
 790 changetype: modify
 791 delete: unicodePwd
 792 add: unicodePwd
 793 unicodePwd:: %s
 794 """ % (userdn, password)
 795             self.ldb.modify_ldif(ldif)
 796             self.fail()
 797         except ldb.LdbError as e:
 798                 (num, msg) = e.args
 799                 self.assertEquals(num, ldb.ERR_CONSTRAINT_VIOLATION, msg)
 800                 self.assertTrue('0000052D' in msg, msg)
 801
 802         # check setting a password that meets the PSO settings works
 803         password = self.format_password_for_ldif('abcdefghijkl')
 804         ldif = """
 805 dn: %s
 806 changetype: modify
 807 delete: unicodePwd
 808 add: unicodePwd
 809 unicodePwd:: %s
 810 """ % (userdn, password)
 811         self.ldb.modify_ldif(ldif)
 812
 813     def set_domain_pwdHistoryLength(self, value):
 814         m = ldb.Message()
 815         m.dn = ldb.Dn(self.ldb, self.ldb.domain_dn())
 816         m["pwdHistoryLength"] = ldb.MessageElement(value,
 817                                                    ldb.FLAG_MOD_REPLACE,
 818                                                    "pwdHistoryLength")
 819         self.ldb.modify(m)
 820
 821     def test_domain_pwd_history(self):
 822         """Non-PSO test for domain's pwdHistoryLength setting"""
 823
 824         # restore the current pwdHistoryLength setting after the test completes
 825         curr_hist_len = str(self.pwd_defaults.history_len)
 826         self.addCleanup(self.set_domain_pwdHistoryLength, curr_hist_len)
 827
 828         self.set_domain_pwdHistoryLength("4")
 829         user = self.add_user("testuser")
 830
 831         initial_pwd = user.get_password()
 832         passwords = ["First12#", "Second12#", "Third12#", "Fourth12#"]
 833
 834         # we should be able to set the password to new values OK
 835         for pwd in passwords:
 836             self.assert_password_valid(user, pwd)
 837
 838         # the 2nd time round it should fail because they're in the history now
 839         for pwd in passwords:
 840             self.assert_password_invalid(user, pwd)
 841
 842         # but the initial password is now outside the history, so should be OK
 843         self.assert_password_valid(user, initial_pwd)
 844
 845         # if we set the history to zero, all the old passwords should now be OK
 846         self.set_domain_pwdHistoryLength("0")
 847         for pwd in passwords:
 848             self.assert_password_valid(user, pwd)
 849
 850     def test_domain_pwd_history_zero(self):
 851         """Non-PSO test for pwdHistoryLength going from zero to non-zero"""
 852
 853         # restore the current pwdHistoryLength setting after the test completes
 854         curr_hist_len = str(self.pwd_defaults.history_len)
 855         self.addCleanup(self.set_domain_pwdHistoryLength, curr_hist_len)
 856
 857         self.set_domain_pwdHistoryLength("0")
 858         user = self.add_user("testuser")
 859
 860         self.assert_password_valid(user, "NewPwd12#")
 861         # we can set the exact same password again because there's no history
 862         self.assert_password_valid(user, "NewPwd12#")
 863
 864         # There is a difference in behaviour here between Windows and Samba.
 865         # When going from zero to non-zero password-history, Windows treats
 866         # the current user's password as invalid (even though the password has
 867         # not been altered since the setting changed). Whereas Samba accepts
 868         # the current password (because it's not in the history until the
 869         # *next* time the user's password changes.
 870         self.set_domain_pwdHistoryLength("1")
 871         self.assert_password_invalid(user, "NewPwd12#")