def __init__(self, aToken):
'''
constructor - create a token object
:param aToken: instance of the orm db object
:type aToken: orm object
'''
TokenClass.__init__(self, aToken)
self.setType(u"TOTP")
self.hKeyRequired = True
''' timeStep defines the granularity: '''
self.timeStep = getFromConfig("totp.timeStep", 30) or 30
''' window size in seconds:
30 seconds with as step width of 30 seconds results
in a window of 1 which is one attempt
'''
self.timeWindow = getFromConfig("totp.timeWindow", 180) or 180
'''the time shift is specified in seconds - and could be
positive and negative
'''
self.timeShift = getFromConfig("totp.timeShift", 0)
'''we support various hashlib methods, but only on create
which is effectively set in the update
'''
self.hashlibStr = getFromConfig("totp.hashlib", u'sha1') or 'sha1'
return
def __init__(self, aToken):
'''
constructor - create a token object
:param aToken: instance of the orm db object
:type aToken: orm object
'''
TokenClass.__init__(self, aToken)
self.setType(u"TOTP")
self.hKeyRequired = True
''' timeStep defines the granularity: '''
self.timeStep = getFromConfig("totp.timeStep", 30) or 30
''' window size in seconds:
30 seconds with as step width of 30 seconds results
in a window of 1 which is one attempt
'''
self.timeWindow = getFromConfig("totp.timeWindow", 180) or 180
'''the time shift is specified in seconds - and could be
positive and negative
'''
self.timeShift = getFromConfig("totp.timeShift", 0)
'''we support various hashlib methods, but only on create
which is effectively set in the update
'''
self.hashlibStr = getFromConfig("totp.hashlib", u'sha1') or 'sha1'
return
def __init__(self, aToken):
"""
constructor - create a token object
:param aToken: instance of the orm db object
:type aToken: orm object
"""
TokenClass.__init__(self, aToken)
self.setType("TOTP")
self.hKeyRequired = True
# timeStep defines the granularity:
self._timeStep = getFromConfig("totp.timeStep", 30) or 30
# window size in seconds:
# 30 seconds with as step width of 30 seconds results
# in a window of 1 which is one attempt
self.timeWindow = getFromConfig("totp.timeWindow", 180) or 180
# the time shift is specified in seconds - and could be
# positive and negative
self.timeShift = getFromConfig("totp.timeShift", 0)
# we support various hashlib methods, but only on create
# which is effectively set in the update
self.hashlibStr = getFromConfig("totp.hashlib", "sha1") or "sha1"
self.otplen = int(self.token.LinOtpOtpLen)
# ------------------------------------------------------------------ --
# load token settings from the token info if available
info = self.getTokenInfo()
if info:
self.hashlibStr = info.get("hashlib", self.hashlibStr) or "sha1"
self.timeStepping = int(info.get("timeStep", self._timeStep) or 30)
self.window = int(info.get("timeWindow", self.timeWindow) or 180)
self.shift = int(info.get("timeShift", self.timeShift) or 0)
log.debug(
"[checkOTP] timestep: %i, timeWindow: %i, timeShift: %i",
self.timeStepping,
self.window,
self.shift,
)
return
def __init__(self, aToken):
'''
getInfo - return the status of the token rollout
:return: info of the ocra token state
:rtype: dict
'''
TokenClass.__init__(self, aToken)
self.setType(u"ocra")
self.transId = 0
return
def __init__(self, a_token):
'''
constructor - create a token object
:param a_token: instance of the orm db object
:type a_token: orm object
'''
TokenClass.__init__(self, a_token)
self.setType(u"mOTP")
return
def __init__(self, a_token):
'''
constructor - create a token object
:param a_token: instance of the orm db object
:type a_token: orm object
'''
TokenClass.__init__(self, a_token)
self.setType(u"mOTP")
return
def __init__(self, aToken):
'''
getInfo - return the status of the token rollout
:return: info of the ocra token state
:rtype: dict
'''
TokenClass.__init__(self, aToken)
self.setType(u"ocra")
self.transId = 0
return
def __init__(self, aToken):
"""
constructor - create a token object
:param aToken: instance of the orm db object
:type aToken: orm object
"""
TokenClass.__init__(self, aToken)
self.setType(u"u2f")
self.mode = ['challenge'] # This is a challenge response token
self.supports_offline_mode = True
def __init__(self, aToken):
"""
constructor - create a token object
:param aToken: instance of the orm db object
:type aToken: orm object
"""
TokenClass.__init__(self, aToken)
self.setType(u"u2f")
self.mode = ['challenge'] # This is a challenge response token
self.supports_offline_mode = True
def __init__(self, aToken):
"""
constructor - create a token class object with it's db token binding
:param aToken: the db bound token
"""
TokenClass.__init__(self, aToken)
self.setType("forward")
self.forwardSerial = None
self.mode = ["authenticate", "challenge"]
self.targetToken = None
self.target_otp_count = -1
def __init__(self, aToken):
"""
constructor - create a token class object with it's db token binding
:param aToken: the db bound token
"""
TokenClass.__init__(self, aToken)
self.setType(u"forward")
self.forwardSerial = None
self.mode = ['authenticate', 'challenge']
self.targetToken = None
self.target_otp_count = -1
def __init__(self, aToken):
"""
constructor - create a token class object with it's db token binding
:param aToken: the db bound token
"""
TokenClass.__init__(self, aToken)
self.setType(u"remote")
self.remoteServer = ""
self.remoteLocalCheckpin = None
self.remoteSerial = None
self.remoteUser = None
self.remoteRealm = None
self.remoteResConf = None
self.mode = ['authenticate', 'challenge']
self.isRemoteChallengeRequest = False
self.local_pin_check = None
def __init__(self, a_token):
'''
constructor - create a token object
:param aToken: instance of the orm db object
:type aToken: orm object
'''
TokenClass.__init__(self, a_token)
self.setType("HMAC")
self.hKeyRequired = True
self.authenticated = None
# we support various hashlib methods, but only on create
# which is effectively set in the update
self.hashlibStr = self.getFromTokenInfo(
"hashlib", getFromConfig("hotp.hashlib", 'sha1'))
def __init__(self, aToken):
"""
constructor - create a token class object with it's db token binding
:param aToken: the db bound token
"""
TokenClass.__init__(self, aToken)
self.setType(u"remote")
self.remoteServer = ""
self.remoteLocalCheckpin = None
self.remoteSerial = None
self.remoteUser = None
self.remoteRealm = None
self.remoteResConf = None
self.mode = ['authenticate', 'challenge']
self.isRemoteChallengeRequest = False
self.local_pin_check = None
def __init__(self, a_token):
'''
constructor - create a token object
:param aToken: instance of the orm db object
:type aToken: orm object
'''
TokenClass.__init__(self, a_token)
self.setType(u"HMAC")
self.hKeyRequired = True
self.authenticated = None
# we support various hashlib methods, but only on create
# which is effectively set in the update
self.hashlibStr = u"sha1"
try:
self.hashlibStr = getFromConfig("hotp.hashlib", u'sha1')
except Exception as ex:
log.exception('[init] Failed to get the hotp.hashlib (%r)' % (ex))
raise Exception(ex)
def __init__(self, aToken):
TokenClass.__init__(self, aToken)
self.setType(u"vasco")
self.hKeyRequired = True
def __init__(self, aToken):
TokenClass.__init__(self, aToken)
self.setType(u"vasco")
self.hKeyRequired = True
def __init__(self, aToken):
TokenClass.__init__(self, aToken)
self.setType(u"yubico")
self.tokenid = ""
def __init__(self, aToken):
TokenClass.__init__(self, aToken)
self.setType(u"spass")
self.mode = ['authenticate']
def __init__(self, token_model_object):
TokenClass.__init__(self, token_model_object)
self.setType("push")
self.mode = ["challenge"]
self.supports_offline_mode = False
def __init__(self, aToken):
TokenClass.__init__(self, aToken)
self.setType(u"spass")
self.mode = ['authenticate']
def __init__(self, token_model_object):
TokenClass.__init__(self, token_model_object)
self.setType(u'push')
self.mode = ['challenge']
self.supports_offline_mode = False
def __init__(self, aToken):
TokenClass.__init__(self, aToken)
self.hKeyRequired = True
self.setType("pw")
def __init__(self, aToken):
TokenClass.__init__(self, aToken)
self.setType(u"yubikey")
self.hKeyRequired = True
return
def __init__(self, token_model_object):
TokenClass.__init__(self, token_model_object)
self.setType(u'push')
self.mode = ['challenge']
self.supports_offline_mode = False
def __init__(self, aToken):
TokenClass.__init__(self, aToken)
self.setType("yubico")
self.tokenid = ""
def __init__(self, aToken):
TokenClass.__init__(self, aToken)
self.setType(u"yubikey")
self.hKeyRequired = True
return