def test_class_type_and_prefix(self):
"""
Verify the simple classmethods getClassType and getClassPrefix
"""
from linotp.lib.tokens.yubikeytoken import YubikeyTokenClass
self.assertEqual(YubikeyTokenClass.getClassType(), "yubikey")
self.assertEqual(YubikeyTokenClass.getClassPrefix(), "UBAM")
def test_class_info(self):
"""
Test the classmethod getClassInfo
"""
from linotp.lib.tokens.yubikeytoken import YubikeyTokenClass
full_class_info = {
'selfservice': {},
'description': 'Yubico token to run the AES OTP mode.',
'title': 'YubiKey in Yubico Mode',
'type': 'yubikey',
'init': {},
'policy': {},
'config': {}
}
class_info = YubikeyTokenClass.getClassInfo()
self.assertEquals(full_class_info, class_info)
self.assertEquals(
"YubiKey in Yubico Mode",
YubikeyTokenClass.getClassInfo(key='title')
)
self.assertEquals(
full_class_info,
YubikeyTokenClass.getClassInfo(key='some_non_existent_key')
)
self.assertEquals(
"some_random_value",
YubikeyTokenClass.getClassInfo(
key="some_non_existent_key",
ret="some_random_value"
)
)
def test_class_type_and_prefix(self):
"""
Verify the simple classmethods getClassType and getClassPrefix
"""
from linotp.lib.tokens.yubikeytoken import YubikeyTokenClass
self.assertEqual(YubikeyTokenClass.getClassType(), "yubikey")
self.assertEqual(YubikeyTokenClass.getClassPrefix(), "UBAM")
def test_class_info(self):
"""
Test the classmethod getClassInfo
"""
from linotp.lib.tokens.yubikeytoken import YubikeyTokenClass
full_class_info = {
'selfservice': {},
'description': 'Yubico token to run the AES OTP mode.',
'title': 'YubiKey in Yubico Mode',
'type': 'yubikey',
'init': {},
'policy': {},
'config': {}
}
class_info = YubikeyTokenClass.getClassInfo()
self.assertEquals(full_class_info, class_info)
self.assertEquals(
"YubiKey in Yubico Mode",
YubikeyTokenClass.getClassInfo(key='title')
)
self.assertEquals(
full_class_info,
YubikeyTokenClass.getClassInfo(key='some_non_existent_key')
)
self.assertEquals(
"some_random_value",
YubikeyTokenClass.getClassInfo(
key="some_non_existent_key",
ret="some_random_value"
)
)
def setUp(self):
# Without this logging in the tested class fails
logging.basicConfig()
# All these values were generated/tested with a real Yubikey
aes_key = "9163508031b20d2fbb1868954e041729" #hex format
serial = "UBAM01382015_1"
self.private_uid = "adb0ee7dd24a" #hex format
self.public_uid = "ecebeeejedecebeg" #modhex format. In decimal: 01382015
# Initialize mock objects
secret_obj = MagicMock(spec=linotp.lib.crypt.SecretObj)
secret_obj.aes_decrypt = _aes_decrypt_constructor(aes_key)
model_token = MagicMock(spec=[
"getSerial", "getHOtpKey", "getInfo", "setInfo", "setType",
"LinOtpCountWindow"
]) # linotp.model.Token
model_token.getSerial.return_value = serial
model_token.getHOtpKey.return_value = secret_obj
model_token.getInfo.return_value = u'' + '{\n"yubikey.tokenid": "' + self.private_uid + '"\n}'
model_token.LinOtpCountWindow = None # Not required in the Yubikey Token
model_token.LinOtpCount = 0
model_token.LinOtpOtpLen = 32
self.model_token = model_token
self.yubikey_token = YubikeyTokenClass(model_token)
model_token.setType.assert_called_once_with("yubikey")
def setUp(self):
from linotp.lib.tokens.yubikeytoken import YubikeyTokenClass
import linotp.lib.crypto
# Without this logging in the tested class fails
logging.basicConfig()
# All these values were generated/tested with a real Yubikey
# aes_key in hex format
aes_key = "9163508031b20d2fbb1868954e041729"
serial = "UBAM01382015_1"
# private_uid in hex format
self.private_uid = "adb0ee7dd24a"
# public_uid in modhex format. In decimal: 01382015
self.public_uid = "ecebeeejedecebeg"
# Initialize mock objects
secret_obj = MagicMock(spec=linotp.lib.crypto.SecretObj)
secret_obj.aes_decrypt = _aes_decrypt_constructor(aes_key)
# mock the linotp.model.Token
model_token = MagicMock(
spec=[
"getSerial",
"getHOtpKey",
"getInfo",
"setInfo",
"setType",
"LinOtpCountWindow"
]
)
model_token.getSerial.return_value = serial
model_token.getInfo.return_value = json.dumps({"yubikey.tokenid": self.private_uid })
# LinOtpCountWindow is not required in the Yubikey Token
model_token.LinOtpCountWindow = None
model_token.LinOtpCount = 0
model_token.LinOtpOtpLen = 32
self.model_token = model_token
# create the yubike with the mocked model_token
self.yubikey_token = YubikeyTokenClass(model_token)
def _get_secret_object():
return secret_obj
setattr(self.yubikey_token, '_get_secret_object', _get_secret_object)
model_token.setType.assert_called_once_with("yubikey")
def setUp(self):
from linotp.lib.tokens.yubikeytoken import YubikeyTokenClass
import linotp.lib.crypt
# Without this logging in the tested class fails
logging.basicConfig()
# All these values were generated/tested with a real Yubikey
aes_key = "9163508031b20d2fbb1868954e041729" #hex format
serial = "UBAM01382015_1"
self.private_uid = "adb0ee7dd24a" #hex format
self.public_uid = "ecebeeejedecebeg" #modhex format. In decimal: 01382015
# Initialize mock objects
secret_obj = MagicMock(spec=linotp.lib.crypt.SecretObj)
secret_obj.aes_decrypt = _aes_decrypt_constructor(aes_key)
model_token = MagicMock(
spec=[
"getSerial",
"getHOtpKey",
"getInfo",
"setInfo",
"setType",
"LinOtpCountWindow"
]
) # linotp.model.Token
model_token.getSerial.return_value = serial
model_token.getHOtpKey.return_value = secret_obj
model_token.getInfo.return_value = u'' + '{\n"yubikey.tokenid": "' + self.private_uid + '"\n}'
model_token.LinOtpCountWindow = None # Not required in the Yubikey Token
model_token.LinOtpCount = 0
model_token.LinOtpOtpLen = 32
self.model_token = model_token
self.yubikey_token = YubikeyTokenClass(model_token)
model_token.setType.assert_called_once_with("yubikey")
def setUp(self):
from linotp.lib.tokens.yubikeytoken import YubikeyTokenClass
import linotp.lib.crypt
# Without this logging in the tested class fails
logging.basicConfig()
# All these values were generated/tested with a real Yubikey
# aes_key in hex format
aes_key = "9163508031b20d2fbb1868954e041729"
serial = "UBAM01382015_1"
# private_uid in hex format
self.private_uid = "adb0ee7dd24a"
# public_uid in modhex format. In decimal: 01382015
self.public_uid = "ecebeeejedecebeg"
# Initialize mock objects
secret_obj = MagicMock(spec=linotp.lib.crypt.SecretObj)
secret_obj.aes_decrypt = _aes_decrypt_constructor(aes_key)
# mock the linotp.model.Token
model_token = MagicMock(
spec=[
"getSerial",
"getHOtpKey",
"getInfo",
"setInfo",
"setType",
"LinOtpCountWindow"
]
)
model_token.getSerial.return_value = serial
model_token.getInfo.return_value = json.dumps({"yubikey.tokenid": self.private_uid })
# LinOtpCountWindow is not required in the Yubikey Token
model_token.LinOtpCountWindow = None
model_token.LinOtpCount = 0
model_token.LinOtpOtpLen = 32
self.model_token = model_token
# create the yubike with the mocked model_token
self.yubikey_token = YubikeyTokenClass(model_token)
def _get_secret_object():
return secret_obj
setattr(self.yubikey_token, '_get_secret_object', _get_secret_object)
model_token.setType.assert_called_once_with("yubikey")
def setUp(self):
# Without this logging in the tested class fails
logging.basicConfig()
# All these values were generated/tested with a real Yubikey
aes_key = "9163508031b20d2fbb1868954e041729" #hex format
serial = "UBAM01382015_1"
self.private_uid = "adb0ee7dd24a" #hex format
self.public_uid = "ecebeeejedecebeg" #modhex format. In decimal: 01382015
# Initialize mock objects
secret_obj = MagicMock(spec=linotp.lib.crypt.SecretObj)
secret_obj.aes_decrypt = _aes_decrypt_constructor(aes_key)
model_token = MagicMock(spec=linotp.model.Token)
model_token.getSerial.return_value = serial
model_token.getHOtpKey.return_value = secret_obj
model_token.getInfo.return_value = u'' + '{\n"yubikey.tokenid": "' + self.private_uid + '"\n}'
model_token.LinOtpCount = 0
self.model_token = model_token
self.yubikey_token = YubikeyTokenClass(model_token)
class YubikeyTokenClassTestCase(unittest.TestCase):
"""
This class tests the YubikeyTokenClass in isolation by mocking out
all dependencies on other classes. Therefore the tests can be run without
requiring an installed server.
"""
def setUp(self):
from linotp.lib.tokens.yubikeytoken import YubikeyTokenClass
import linotp.lib.crypto
# Without this logging in the tested class fails
logging.basicConfig()
# All these values were generated/tested with a real Yubikey
# aes_key in hex format
aes_key = "9163508031b20d2fbb1868954e041729"
serial = "UBAM01382015_1"
# private_uid in hex format
self.private_uid = "adb0ee7dd24a"
# public_uid in modhex format. In decimal: 01382015
self.public_uid = "ecebeeejedecebeg"
# Initialize mock objects
secret_obj = MagicMock(spec=linotp.lib.crypto.SecretObj)
secret_obj.aes_decrypt = _aes_decrypt_constructor(aes_key)
# mock the linotp.model.Token
model_token = MagicMock(
spec=[
"getSerial",
"getHOtpKey",
"getInfo",
"setInfo",
"setType",
"LinOtpCountWindow"
]
)
model_token.getSerial.return_value = serial
model_token.getInfo.return_value = json.dumps({"yubikey.tokenid": self.private_uid })
# LinOtpCountWindow is not required in the Yubikey Token
model_token.LinOtpCountWindow = None
model_token.LinOtpCount = 0
model_token.LinOtpOtpLen = 32
self.model_token = model_token
# create the yubike with the mocked model_token
self.yubikey_token = YubikeyTokenClass(model_token)
def _get_secret_object():
return secret_obj
setattr(self.yubikey_token, '_get_secret_object', _get_secret_object)
model_token.setType.assert_called_once_with("yubikey")
def test_checkotp_positive(self):
"""
Verify that correct OTP values are decrypted and accepted
"""
# The counter we use is calculated with the session_counter and usage_counter
# contained in the OTP. counter = usage_counter*256 + session_counter
# See the Yubikey documentation for an explanation of both counters.
otp_counter_dict = {
self.public_uid + "fcniufvgvjturjgvinhebbbertjnihit": 256,
self.public_uid + "tbkfkdhnfjbjnkcbtbcckklhvgkljifu": 257,
self.public_uid + "ktvkekfgufndgbfvctgfrrkinergbtdj": 258,
self.public_uid + "jbefledlhkvjjcibvrdfcfetnjdjitrn": 259,
self.public_uid + "druecevifbfufgdegglttghghhvhjcbh": 260,
self.public_uid + "nvfnejvhkcililuvhntcrrulrfcrukll": 261,
self.public_uid + "kttkktdergcenthdredlvbkiulrkftuk": 262,
self.public_uid + "hutbgchjucnjnhlcnfijckbniegbglrt": 512,
self.public_uid + "vneienejjnedbfnjnnrfhhjudjgghckl": 513,
self.public_uid + "krgevltjnujcnuhtngjndbhbiiufbnki": 514,
self.public_uid + "kehbefcrnlfejedfdulubuldfbhdlicc": 768,
self.public_uid + "ljlhjbkejkctubnejrhuvljkvglvvlbk": 769,
self.public_uid + "eihtnehtetluntirtirrvblfkttbjuih": 770
}
# Test positive cases (otp_counter_dict)
for otp in otp_counter_dict:
counter_expected = otp_counter_dict[otp]
counter_actual = self.yubikey_token.checkOtp(otp)
self.assertEqual(
counter_expected,
counter_actual,
"Counter for OTP: " + otp + " is incorrect. Should be " +
str(counter_expected) + " and is " + str(counter_actual)
)
def test_checkotp_old_otp(self):
"""
Verify that an old OTP value (smaller the the stored counter) is not accepted.
"""
self.model_token.LinOtpCount = 300
otp = self.public_uid + "fcniufvgvjturjgvinhebbbertjnihit" # counter 256
counter_expected = -1
counter_actual = self.yubikey_token.checkOtp(otp)
self.assertEqual(counter_expected, counter_actual,
"OTP: " + otp + " should no longer be accepted.")
def test_checkotp_wrong_crc(self):
"""
Verify that an OTP with corrupt data is not accepted
"""
# Passing in a random (wrong) OTP should fail because of the CRC
otp = self.public_uid + "fcniufvgvjturjgvinhebbvvvvvvvvvv"
counter_expected = -3
# We want to suppress the warning generated because of the wrong CRC
logger = logging.getLogger("linotp.lib.tokens.yubikeytoken")
logger.disabled = True
counter_actual = self.yubikey_token.checkOtp(otp)
logger.disabled = False
self.assertEqual(counter_expected, counter_actual,
"CRC verification for OTP: " + otp + " should fail.")
def test_checkotp_no_tokenid(self):
"""
Verify that if the yubikey.tokenid is not set, then the corresponding function for
setting it is called.
"""
# yubikey.tokenid is not set
self.model_token.getInfo.return_value = '{}'
otp = self.public_uid + "fcniufvgvjturjgvinhebbbertjnihit"
self.yubikey_token.checkOtp(otp)
# Verify that the tokenid is passed onto linotp.model.Token
expected_tokeninfo = u'' + '{\n"yubikey.tokenid": "' + self.private_uid + '"\n}'
self.model_token.setInfo.assert_called_once_with(expected_tokeninfo)
def test_checkotp_wrong_tokenid(self):
"""
Verify that if the stored uid differs from the one contained in the OTP then an error
is returned.
"""
self.model_token.getInfo.return_value = u'' + '{\n"yubikey.tokenid": "wrong-value"\n}'
otp = self.public_uid + "fcniufvgvjturjgvinhebbbertjnihit"
counter_expected = -2
# We want to suppress the warning generated because of the wrong CRC
logger = logging.getLogger("linotp.lib.tokens.yubikeytoken")
logger.disabled = True
counter_actual = self.yubikey_token.checkOtp(otp)
logger.disabled = False
self.assertEqual(counter_expected, counter_actual,
"(private) uid should not be accepted for OTP: " + otp)
def test_class_type_and_prefix(self):
"""
Verify the simple classmethods getClassType and getClassPrefix
"""
from linotp.lib.tokens.yubikeytoken import YubikeyTokenClass
self.assertEqual(YubikeyTokenClass.getClassType(), "yubikey")
self.assertEqual(YubikeyTokenClass.getClassPrefix(), "UBAM")
def test_class_info(self):
"""
Test the classmethod getClassInfo
"""
from linotp.lib.tokens.yubikeytoken import YubikeyTokenClass
full_class_info = {
'selfservice': {},
'description': 'Yubico token to run the AES OTP mode.',
'title': 'YubiKey in Yubico Mode',
'type': 'yubikey',
'init': {},
'policy': {},
'config': {}
}
class_info = YubikeyTokenClass.getClassInfo()
self.assertEquals(full_class_info, class_info)
self.assertEquals(
"YubiKey in Yubico Mode",
YubikeyTokenClass.getClassInfo(key='title')
)
self.assertEquals(
full_class_info,
YubikeyTokenClass.getClassInfo(key='some_non_existent_key')
)
self.assertEquals(
"some_random_value",
YubikeyTokenClass.getClassInfo(
key="some_non_existent_key",
ret="some_random_value"
)
)
def test_check_otp_exist(self):
"""
Test method check_otp_exist()
"""
otp = self.public_uid + "fcniufvgvjturjgvinhebbbertjnihit"
counter_expected = 256
self.yubikey_token.incOtpCounter = MagicMock()
counter_actual = self.yubikey_token.check_otp_exist(otp)
self.yubikey_token.incOtpCounter.assert_called_once_with(counter_expected)
self.assertEquals(counter_expected, counter_actual)
# invalid (old) value
self.model_token.LinOtpCount = 300
otp = self.public_uid + "fcniufvgvjturjgvinhebbbertjnihit" # counter 256
self.yubikey_token.incOtpCounter.reset_mock()
counter_actual = self.yubikey_token.check_otp_exist(otp)
self.assertEquals(0, self.yubikey_token.incOtpCounter.call_count)
self.assertEquals(-1, counter_actual)
def test_is_challenge_request(self):
"""
Test is_challenge_request() method
"""
patcher = patch('linotp.lib.tokens.yubikeytoken.check_pin', spec=True)
check_pin_mock = patcher.start()
check_pin_mock.return_value = True
self.assertTrue(
self.yubikey_token.is_challenge_request(
"a-pin",
user="******"
)
)
check_pin_mock.return_value = False
self.assertFalse(
self.yubikey_token.is_challenge_request(
"not-a-pin",
user="******"
)
)
patcher.stop()
class YubikeyTokenClassTestCase(unittest.TestCase):
"""
This class tests the YubikeyTokenClass in isolation by mocking out
all dependencies on other classes. Therefore the tests can be run without
requiring an installed server.
"""
def setUp(self):
from linotp.lib.tokens.yubikeytoken import YubikeyTokenClass
import linotp.lib.crypt
# Without this logging in the tested class fails
logging.basicConfig()
# All these values were generated/tested with a real Yubikey
# aes_key in hex format
aes_key = "9163508031b20d2fbb1868954e041729"
serial = "UBAM01382015_1"
# private_uid in hex format
self.private_uid = "adb0ee7dd24a"
# public_uid in modhex format. In decimal: 01382015
self.public_uid = "ecebeeejedecebeg"
# Initialize mock objects
secret_obj = MagicMock(spec=linotp.lib.crypt.SecretObj)
secret_obj.aes_decrypt = _aes_decrypt_constructor(aes_key)
# mock the linotp.model.Token
model_token = MagicMock(
spec=[
"getSerial",
"getHOtpKey",
"getInfo",
"setInfo",
"setType",
"LinOtpCountWindow"
]
)
model_token.getSerial.return_value = serial
model_token.getInfo.return_value = json.dumps({"yubikey.tokenid": self.private_uid })
# LinOtpCountWindow is not required in the Yubikey Token
model_token.LinOtpCountWindow = None
model_token.LinOtpCount = 0
model_token.LinOtpOtpLen = 32
self.model_token = model_token
# create the yubike with the mocked model_token
self.yubikey_token = YubikeyTokenClass(model_token)
def _get_secret_object():
return secret_obj
setattr(self.yubikey_token, '_get_secret_object', _get_secret_object)
model_token.setType.assert_called_once_with("yubikey")
def test_checkotp_positive(self):
"""
Verify that correct OTP values are decrypted and accepted
"""
# The counter we use is calculated with the session_counter and usage_counter
# contained in the OTP. counter = usage_counter*256 + session_counter
# See the Yubikey documentation for an explanation of both counters.
otp_counter_dict = {
self.public_uid + "fcniufvgvjturjgvinhebbbertjnihit": 256,
self.public_uid + "tbkfkdhnfjbjnkcbtbcckklhvgkljifu": 257,
self.public_uid + "ktvkekfgufndgbfvctgfrrkinergbtdj": 258,
self.public_uid + "jbefledlhkvjjcibvrdfcfetnjdjitrn": 259,
self.public_uid + "druecevifbfufgdegglttghghhvhjcbh": 260,
self.public_uid + "nvfnejvhkcililuvhntcrrulrfcrukll": 261,
self.public_uid + "kttkktdergcenthdredlvbkiulrkftuk": 262,
self.public_uid + "hutbgchjucnjnhlcnfijckbniegbglrt": 512,
self.public_uid + "vneienejjnedbfnjnnrfhhjudjgghckl": 513,
self.public_uid + "krgevltjnujcnuhtngjndbhbiiufbnki": 514,
self.public_uid + "kehbefcrnlfejedfdulubuldfbhdlicc": 768,
self.public_uid + "ljlhjbkejkctubnejrhuvljkvglvvlbk": 769,
self.public_uid + "eihtnehtetluntirtirrvblfkttbjuih": 770
}
# Test positive cases (otp_counter_dict)
for otp in otp_counter_dict:
counter_expected = otp_counter_dict[otp]
counter_actual = self.yubikey_token.checkOtp(otp)
self.assertEqual(
counter_expected,
counter_actual,
"Counter for OTP: " + otp + " is incorrect. Should be " +
str(counter_expected) + " and is " + str(counter_actual)
)
def test_checkotp_old_otp(self):
"""
Verify that an old OTP value (smaller the the stored counter) is not accepted.
"""
self.model_token.LinOtpCount = 300
otp = self.public_uid + "fcniufvgvjturjgvinhebbbertjnihit" # counter 256
counter_expected = -1
counter_actual = self.yubikey_token.checkOtp(otp)
self.assertEqual(counter_expected, counter_actual,
"OTP: " + otp + " should no longer be accepted.")
def test_checkotp_wrong_crc(self):
"""
Verify that an OTP with corrupt data is not accepted
"""
# Passing in a random (wrong) OTP should fail because of the CRC
otp = self.public_uid + "fcniufvgvjturjgvinhebbvvvvvvvvvv"
counter_expected = -3
# We want to suppress the warning generated because of the wrong CRC
logger = logging.getLogger("linotp.lib.tokens.yubikeytoken")
logger.disabled = True
counter_actual = self.yubikey_token.checkOtp(otp)
logger.disabled = False
self.assertEqual(counter_expected, counter_actual,
"CRC verification for OTP: " + otp + " should fail.")
def test_checkotp_no_tokenid(self):
"""
Verify that if the yubikey.tokenid is not set, then the corresponding function for
setting it is called.
"""
# yubikey.tokenid is not set
self.model_token.getInfo.return_value = '{}'
otp = self.public_uid + "fcniufvgvjturjgvinhebbbertjnihit"
self.yubikey_token.checkOtp(otp)
# Verify that the tokenid is passed onto linotp.model.Token
expected_tokeninfo = u'' + '{\n"yubikey.tokenid": "' + self.private_uid + '"\n}'
self.model_token.setInfo.assert_called_once_with(expected_tokeninfo)
def test_checkotp_wrong_tokenid(self):
"""
Verify that if the stored uid differs from the one contained in the OTP then an error
is returned.
"""
self.model_token.getInfo.return_value = u'' + '{\n"yubikey.tokenid": "wrong-value"\n}'
otp = self.public_uid + "fcniufvgvjturjgvinhebbbertjnihit"
counter_expected = -2
# We want to suppress the warning generated because of the wrong CRC
logger = logging.getLogger("linotp.lib.tokens.yubikeytoken")
logger.disabled = True
counter_actual = self.yubikey_token.checkOtp(otp)
logger.disabled = False
self.assertEqual(counter_expected, counter_actual,
"(private) uid should not be accepted for OTP: " + otp)
def test_class_type_and_prefix(self):
"""
Verify the simple classmethods getClassType and getClassPrefix
"""
from linotp.lib.tokens.yubikeytoken import YubikeyTokenClass
self.assertEqual(YubikeyTokenClass.getClassType(), "yubikey")
self.assertEqual(YubikeyTokenClass.getClassPrefix(), "UBAM")
def test_class_info(self):
"""
Test the classmethod getClassInfo
"""
from linotp.lib.tokens.yubikeytoken import YubikeyTokenClass
full_class_info = {
'selfservice': {},
'description': 'Yubico token to run the AES OTP mode.',
'title': 'YubiKey in Yubico Mode',
'type': 'yubikey',
'init': {},
'policy': {},
'config': {}
}
class_info = YubikeyTokenClass.getClassInfo()
self.assertEquals(full_class_info, class_info)
self.assertEquals(
"YubiKey in Yubico Mode",
YubikeyTokenClass.getClassInfo(key='title')
)
self.assertEquals(
full_class_info,
YubikeyTokenClass.getClassInfo(key='some_non_existent_key')
)
self.assertEquals(
"some_random_value",
YubikeyTokenClass.getClassInfo(
key="some_non_existent_key",
ret="some_random_value"
)
)
def test_check_otp_exist(self):
"""
Test method check_otp_exist()
"""
otp = self.public_uid + "fcniufvgvjturjgvinhebbbertjnihit"
counter_expected = 256
self.yubikey_token.incOtpCounter = MagicMock()
counter_actual = self.yubikey_token.check_otp_exist(otp)
self.yubikey_token.incOtpCounter.assert_called_once_with(counter_expected)
self.assertEquals(counter_expected, counter_actual)
# invalid (old) value
self.model_token.LinOtpCount = 300
otp = self.public_uid + "fcniufvgvjturjgvinhebbbertjnihit" # counter 256
self.yubikey_token.incOtpCounter.reset_mock()
counter_actual = self.yubikey_token.check_otp_exist(otp)
self.assertEquals(0, self.yubikey_token.incOtpCounter.call_count)
self.assertEquals(-1, counter_actual)
def test_is_challenge_request(self):
"""
Test is_challenge_request() method
"""
patcher = patch('linotp.lib.tokens.yubikeytoken.check_pin', spec=True)
check_pin_mock = patcher.start()
check_pin_mock.return_value = True
self.assertTrue(
self.yubikey_token.is_challenge_request(
"a-pin",
user="******"
)
)
check_pin_mock.return_value = False
self.assertFalse(
self.yubikey_token.is_challenge_request(
"not-a-pin",
user="******"
)
)
patcher.stop()
def test_class_type_and_prefix(self):
"""
Verify the simple classmethods getClassType and getClassPrefix
"""
self.assertEqual(YubikeyTokenClass.getClassType(), "yubikey")
self.assertEqual(YubikeyTokenClass.getClassPrefix(), "UBAM")
def test_class_type_and_prefix(self):
"""
Verify the simple classmethods getClassType and getClassPrefix
"""
self.assertEqual(YubikeyTokenClass.getClassType(), "yubikey")
self.assertEqual(YubikeyTokenClass.getClassPrefix(), "UBAM")
