def test_10_check_conditions_tokentype(self):
uhandler = UserNotificationEventHandler()
# check if tokenrealm is contained
builder = EnvironBuilder(method='POST',
data={'user': "******"},
headers={})
tok = init_token({"serial": "oath1234", "type": "spass"},
user=User("cornelius", "realm1"))
env = builder.get_environ()
req = Request(env)
req.all_data = {"user": "******",
"serial": "oath1234"}
req.User = User("cornelius", "realm1")
resp = Response()
resp.data = """{"result": {"value": true}}"""
r = uhandler.check_condition(
{"g": {},
"handler_def": {"conditions": {"tokentype": "totp,spass,oath,"}},
"request": req,
"response": resp
}
)
# Serial matches the regexp
self.assertEqual(r, True)
def test_08_check_conditions_serial(self):
uhandler = UserNotificationEventHandler()
# check a serial with regexp
builder = EnvironBuilder(method='POST',
data={'user': "******"},
headers={})
env = builder.get_environ()
req = Request(env)
req.all_data = {"user": "******", "serial": "OATH123456"}
req.User = User("cornelius", "realm1")
resp = Response()
resp.data = """{"result": {"value": true}}"""
r = uhandler.check_condition({
"g": {},
"handler_def": {
"conditions": {
"serial": "^OATH.*"
}
},
"request": req,
"response": resp
})
# Serial matches the regexp
self.assertEqual(r, True)
def test_06_check_conditions_realm(self):
uhandler = UserNotificationEventHandler()
# check a locked token with maxfail = failcount
builder = EnvironBuilder(method='POST',
data={'user': "******"},
headers={})
env = builder.get_environ()
req = Request(env)
req.all_data = {"user": "******"}
req.User = User("cornelius", "realm1")
resp = Response()
resp.data = """{"result": {"value": false}}"""
r = uhandler.check_condition({
"g": {},
"handler_def": {
"conditions": {
"realm": "realm2"
}
},
"request": req,
"response": resp
})
# wrong realm
self.assertEqual(r, False)
def test_10_check_conditions_token_has_owner(self):
uhandler = UserNotificationEventHandler()
# check if tokenrealm is contained
builder = EnvironBuilder(method='POST',
data={'user': "******"},
headers={})
tok = init_token({
"serial": "oath1234",
"type": "spass"
},
user=User("cornelius", "realm1"))
env = builder.get_environ()
req = Request(env)
req.all_data = {"user": "******", "serial": "oath1234"}
req.User = User("cornelius", "realm1")
resp = Response()
resp.data = """{"result": {"value": true}}"""
r = uhandler.check_condition({
"g": {},
"handler_def": {
"conditions": {
CONDITION.TOKEN_HAS_OWNER: "True"
}
},
"request": req,
"response": resp
})
# Token has an owner
self.assertEqual(r, True)
r = uhandler.check_condition({
"g": {},
"handler_def": {
"conditions": {
CONDITION.TOKEN_HAS_OWNER: "False"
}
},
"request": req,
"response": resp
})
# Token has an owner, but the condition is wrong
self.assertEqual(r, False)
# unassign token, no owner
unassign_token("oath1234")
r = uhandler.check_condition({
"g": {},
"handler_def": {
"conditions": {
CONDITION.TOKEN_HAS_OWNER: "False"
}
},
"request": req,
"response": resp
})
# The condition was, token-not-assigned and the token has no user
self.assertEqual(r, True)
def test_14_send_to_adminrealm(self):
# setup realms
self.setUp_user_realms()
r = add_smtpserver(identifier="myserver", server="1.2.3.4", tls=False)
self.assertTrue(r > 0)
smtpmock.setdata(response={"*****@*****.**": (200, "OK")},
support_tls=False)
g = FakeFlaskG()
audit_object = FakeAudit()
audit_object.audit_data["serial"] = "123456"
g.logged_in_user = {"user": "******", "role": "admin", "realm": ""}
g.audit_object = audit_object
builder = EnvironBuilder(method='POST',
data={'serial': "OATH123456"},
headers={})
env = builder.get_environ()
# Set the remote address so that we can filter for it
env["REMOTE_ADDR"] = "10.0.0.1"
g.client_ip = env["REMOTE_ADDR"]
req = Request(env)
req.all_data = {"serial": "SomeSerial", "user": "******"}
req.User = User("cornelius", self.realm1)
resp = Response()
resp.data = """{"result": {"value": true},
"detail": {"registrationcode": "12345678910"}
}
"""
# send email to user in adminrealm "realm1"
# Although this is no admin realm, but this realm contains some email
# addresses.
options = {
"g": g,
"request": req,
"response": resp,
"handler_def": {
"conditions": {
"serial": "123.*"
},
"options": {
"body": "your {registrationcode}",
"emailconfig": "myserver",
"To": NOTIFY_TYPE.ADMIN_REALM,
"To " + NOTIFY_TYPE.ADMIN_REALM: "realm1"
}
}
}
un_handler = UserNotificationEventHandler()
res = un_handler.do("sendmail", options=options)
self.assertTrue(res)
def test_03_sendsms(self):
# setup realms
self.setUp_user_realms()
r = set_smsgateway(identifier="myGW",
providermodule="privacyidea.lib.smsprovider."
"SmtpSMSProvider.SmtpSMSProvider",
options={
"SMTPIDENTIFIER": "myserver",
"MAILTO": "*****@*****.**"
})
self.assertTrue(r > 0)
smtpmock.setdata(response={"*****@*****.**": (200, "OK")},
support_tls=False)
g = FakeFlaskG()
audit_object = FakeAudit()
audit_object.audit_data["serial"] = "123456"
g.logged_in_user = {"user": "******", "role": "admin", "realm": ""}
g.audit_object = audit_object
builder = EnvironBuilder(method='POST',
data={'serial': "OATH123456"},
headers={})
env = builder.get_environ()
# Set the remote address so that we can filter for it
env["REMOTE_ADDR"] = "10.0.0.1"
g.client_ip = env["REMOTE_ADDR"]
req = Request(env)
req.all_data = {"serial": "SomeSerial", "user": "******"}
req.User = User("cornelius", self.realm1)
resp = Response()
resp.data = """{"result": {"value": true}}"""
options = {
"g": g,
"request": req,
"response": resp,
"handler_def": {
"options": {
"smsconfig": "myGW"
}
}
}
un_handler = UserNotificationEventHandler()
res = un_handler.do("sendsms", options=options)
self.assertTrue(res)
def get_handler_object(handlername):
"""
Return an event handler object based on the Name of the event handler class
:param handlername: The identifier of the Handler Class
:type hanldername: basestring
:return:
"""
# TODO: beautify and make this work with several different handlers
from privacyidea.lib.eventhandler.usernotification import \
UserNotificationEventHandler
from privacyidea.lib.eventhandler.tokenhandler import TokenEventHandler
from privacyidea.lib.eventhandler.scripthandler import ScriptEventHandler
from privacyidea.lib.eventhandler.federationhandler import \
FederationEventHandler
h_obj = None
if handlername == "UserNotification":
h_obj = UserNotificationEventHandler()
if handlername == "Token":
h_obj = TokenEventHandler()
if handlername == "Script":
h_obj = ScriptEventHandler()
if handlername == "Federation":
h_obj = FederationEventHandler()
return h_obj
def test_07_locked_token_wrong_pin(self):
tok = init_token({
"serial": "lock2",
"type": "spass",
"pin": "pin"
},
user=User("cornelius", "realm1"))
# lock it
tok.set_failcount(10)
uhandler = UserNotificationEventHandler()
resp = Response()
resp.data = """{"result": {"value": false}}"""
builder = EnvironBuilder(method='POST')
env = builder.get_environ()
req = Request(env)
req.all_data = {"user": "******", "pass": "******"}
req.User = User("cornelius", self.realm1)
# check the do action.
g = FakeFlaskG()
audit_object = FakeAudit()
audit_object.audit_data["serial"] = None
g.audit_object = audit_object
options = {
"g": g,
"handler_def": {
"conditions": {
"token_locked": "True"
}
},
"response": resp,
"request": req
}
r = add_smtpserver(identifier="myserver", server="1.2.3.4", tls=False)
self.assertTrue(r > 0)
smtpmock.setdata(response={"*****@*****.**": (200, "OK")},
support_tls=False)
r = uhandler.check_condition(options)
self.assertEqual(r, True)
r = uhandler.do("sendmail", options=options)
self.assertEqual(r, True)
def test_02_sendmail(self):
# setup realms
self.setUp_user_realms()
r = add_smtpserver(identifier="myserver", server="1.2.3.4", tls=False)
self.assertTrue(r > 0)
smtpmock.setdata(response={"*****@*****.**": (200, "OK")},
support_tls=False)
g = FakeFlaskG()
audit_object = FakeAudit()
audit_object.audit_data["serial"] = "123456"
g.logged_in_user = {"user": "******", "role": "admin", "realm": ""}
g.audit_object = audit_object
builder = EnvironBuilder(method='POST',
data={'serial': "OATH123456"},
headers={})
env = builder.get_environ()
# Set the remote address so that we can filter for it
env["REMOTE_ADDR"] = "10.0.0.1"
g.client_ip = env["REMOTE_ADDR"]
req = Request(env)
req.all_data = {"serial": "SomeSerial", "user": "******"}
req.User = User("cornelius", self.realm1)
resp = Response()
resp.data = """{"result": {"value": true}}"""
options = {
"g": g,
"request": req,
"response": resp,
"handler_def": {
"options": {
"emailconfig": "myserver"
}
}
}
un_handler = UserNotificationEventHandler()
res = un_handler.do("sendmail", options=options)
self.assertTrue(res)
def test_03_sendsms(self):
# setup realms
self.setUp_user_realms()
r = set_smsgateway(identifier="myGW",
providermodule="privacyidea.lib.smsprovider."
"SmtpSMSProvider.SmtpSMSProvider",
options={"SMTPIDENTIFIER": "myserver",
"MAILTO": "*****@*****.**"})
self.assertTrue(r > 0)
smtpmock.setdata(response={"*****@*****.**": (200, "OK")},
support_tls=False)
g = FakeFlaskG()
audit_object = FakeAudit()
audit_object.audit_data["serial"] = "123456"
g.logged_in_user = {"user": "******",
"role": "admin",
"realm": ""}
g.audit_object = audit_object
builder = EnvironBuilder(method='POST',
data={'serial': "OATH123456"},
headers={})
env = builder.get_environ()
# Set the remote address so that we can filter for it
env["REMOTE_ADDR"] = "10.0.0.1"
g.client_ip = env["REMOTE_ADDR"]
req = Request(env)
req.all_data = {"serial": "SomeSerial",
"user": "******"}
options = {"g": g,
"request": req,
"smsconfig": "myGW"}
un_handler = UserNotificationEventHandler()
res = un_handler.do("sendsms", options=options)
self.assertTrue(res)
def test_02_sendmail(self):
# setup realms
self.setUp_user_realms()
r = add_smtpserver(identifier="myserver", server="1.2.3.4", tls=False)
self.assertTrue(r > 0)
smtpmock.setdata(response={"*****@*****.**": (200, "OK")},
support_tls=False)
g = FakeFlaskG()
audit_object = FakeAudit()
audit_object.audit_data["serial"] = "123456"
g.logged_in_user = {"user": "******",
"role": "admin",
"realm": ""}
g.audit_object = audit_object
builder = EnvironBuilder(method='POST',
data={'serial': "OATH123456"},
headers={})
env = builder.get_environ()
# Set the remote address so that we can filter for it
env["REMOTE_ADDR"] = "10.0.0.1"
g.client_ip = env["REMOTE_ADDR"]
req = Request(env)
req.all_data = {"serial": "SomeSerial",
"user": "******"}
options = {"g": g,
"request": req,
"emailconfig": "myserver"}
un_handler = UserNotificationEventHandler()
res = un_handler.do("sendmail", options=options)
self.assertTrue(res)
def get_handler_object(handlername):
"""
Return an event handler object based on the Name of the event handler class
:param handlername: The identifier of the Handler Class
:type hanldername: basestring
:return:
"""
# TODO: beautify and make this work with several different handlers
from privacyidea.lib.eventhandler.usernotification import \
UserNotificationEventHandler
from privacyidea.lib.eventhandler.tokenhandler import TokenEventHandler
from privacyidea.lib.eventhandler.scripthandler import ScriptEventHandler
from privacyidea.lib.eventhandler.federationhandler import \
FederationEventHandler
from privacyidea.lib.eventhandler.counterhandler import CounterEventHandler
from privacyidea.lib.eventhandler.requestmangler import RequestManglerEventHandler
from privacyidea.lib.eventhandler.responsemangler import ResponseManglerEventHandler
from privacyidea.lib.eventhandler.logginghandler import LoggingEventHandler
from privacyidea.lib.eventhandler.customuserattributeshandler import CustomUserAttributesHandler
h_obj = None
if handlername == "UserNotification":
h_obj = UserNotificationEventHandler()
elif handlername == "Token":
h_obj = TokenEventHandler()
elif handlername == "Script":
h_obj = ScriptEventHandler()
elif handlername == "Federation":
h_obj = FederationEventHandler()
elif handlername == "Counter":
h_obj = CounterEventHandler()
elif handlername == "RequestMangler":
h_obj = RequestManglerEventHandler()
elif handlername == "ResponseMangler":
h_obj = ResponseManglerEventHandler()
elif handlername == "Logging":
h_obj = LoggingEventHandler()
elif handlername == "CustomUserAttributes":
h_obj = CustomUserAttributesHandler()
return h_obj
def test_01_basefunctions(self):
actions = UserNotificationEventHandler().actions
self.assertTrue("sendmail" in actions)
def test_05_check_conditions(self):
uhandler = UserNotificationEventHandler()
resp = Response()
resp.data = """{"result": {"value": false}}"""
builder = EnvironBuilder(method='POST')
env = builder.get_environ()
req = Request(env)
req.all_data = {}
req.User = User()
r = uhandler.check_condition(
{"g": {},
"handler_def": {"conditions": {"logged_in_user": "******"}},
"response": resp,
"request": req})
self.assertEqual(r, False)
r = uhandler.check_condition(
{"g": {},
"handler_def": {"conditions": {"result_value": True}},
"response": resp,
"request": req})
self.assertEqual(r, False)
# check a locked token with maxfail = failcount
builder = EnvironBuilder(method='POST',
data={'serial': "OATH123456"},
headers={})
req.all_data = {"user": "******"}
resp.data = """{"result": {"value": false},
"detail": {"serial": "lockedtoken"}
}
"""
tok = init_token({"serial": "lockedtoken", "type": "spass"})
r = uhandler.check_condition(
{"g": {},
"handler_def": {"conditions": {"token_locked": "True"}},
"response": resp,
"request": req
}
)
# not yet locked
self.assertEqual(r, False)
# lock it
tok.set_failcount(10)
options = {"g": {},
"handler_def": {"conditions": {"token_locked": "True"}},
"response": resp,
"request": req
}
r = uhandler.check_condition(options)
# now locked
self.assertEqual(r, True)
# check the do action.
g = FakeFlaskG()
audit_object = FakeAudit()
audit_object.audit_data["serial"] = "123456"
g.audit_object = audit_object
options = {"g": g,
"handler_def": {"conditions": {"token_locked": "True"}},
"response": resp,
"request": req
}
r = add_smtpserver(identifier="myserver", server="1.2.3.4", tls=False)
self.assertTrue(r > 0)
smtpmock.setdata(response={"*****@*****.**": (200, "OK")},
support_tls=False)
r = uhandler.do("sendmail", options=options)
self.assertEqual(r, True)
def test_04_conditions(self):
c = UserNotificationEventHandler().conditions
self.assertTrue("logged_in_user" in c)
self.assertTrue("result_value" in c)