def create_challenge(token, options=None, challenge_id=None, id_postfix=''):
"""
dedicated method to create a challenge to support the implementation
of challenge policies in future
:param options: optional parameters for token specific tokens
eg. request a signed challenge
:return: a tuple of (boolean, and a dict, which contains the
{'challenge' : challenge} description)
"""
# response dict, describing the challenge reply
challenge = {}
# the allocated db challenge object
challenge_obj = None
retry_counter = 0
reason = None
hsm = context['hsm'].get('obj')
id_length = int(
context.get('Config', None).get('TransactionIdLength', 12)) - \
len(id_postfix)
while True:
try:
if not challenge_id:
transactionid = "%s%s" % (
Challenge.createTransactionId(length=id_length), id_postfix)
else:
transactionid = challenge_id
num_challenges = Session.query(Challenge). \
filter(Challenge.transid == transactionid).count()
if num_challenges == 0:
challenge_obj = Challenge(transid=transactionid,
tokenserial=token.getSerial())
if challenge_obj is not None:
break
except Exception as exce:
log.info("Failed to create Challenge: %r", exce)
reason = exce
# prevent an unlimited loop
retry_counter = retry_counter + 1
if retry_counter > 100:
log.info(
"Failed to create Challenge for %d times: %r -quiting!",
retry_counter, reason)
raise Exception('Failed to create challenge %r' % reason)
expired_challenges, valid_challenges = Challenges.get_challenges(token)
# carefully create a new challenge
try:
# we got a challenge object allocated and initialize the challenge
(res, open_transactionid, message, attributes) = \
token.initChallenge(transactionid,
challenges=valid_challenges,
options=options)
if res is False:
# if a different transid is returned, this indicates, that there
# is already an outstanding challenge we can refere to
if open_transactionid != transactionid:
transactionid = open_transactionid
else:
# in case the init was successfull, we preserve no the
# challenge data to support the implementation of a blocking
# based on the previous stored data
challenge_obj.setChallenge(message)
challenge_obj.save()
(res, message, data, attributes) = \
token.createChallenge(transactionid, options=options)
if res is True:
# persist the final challenge data + message
challenge_obj.setChallenge(message)
challenge_obj.setData(data)
challenge_obj.signChallenge(hsm)
challenge_obj.save()
else:
transactionid = ''
reason = Exception(message)
except Exception as exce:
reason = exce
res = False
# if something goes wrong with the challenge, remove it
if res is False and challenge_obj is not None:
try:
log.debug("deleting session")
Session.delete(challenge_obj)
Session.commit()
except Exception as exx:
log.debug("deleting session failed: %r" % exx)
try:
Session.expunge(challenge_obj)
Session.commit()
except Exception as exx:
log.debug("expunge session failed: %r" % exx)
# in case that create challenge fails, we must raise this reason
if reason is not None:
message = "%r" % reason
log.error("Failed to create or init challenge %r " % reason)
raise reason
# prepare the response for the user
if transactionid is not None:
challenge['transactionid'] = transactionid
if message is not None:
challenge['message'] = message
if attributes is not None and type(attributes) == dict:
challenge.update(attributes)
return (res, challenge)
def create_challenge(token, options=None):
"""
dedicated method to create a challenge to support the implementation
of challenge policies in future
:param options: optional parameters for token specific tokens
eg. request a signed challenge
:return: a tuple of (boolean, and a dict, which contains the
{'challenge' : challenge} description)
"""
## response dict, describing the challenge reply
challenge = {}
## the allocated db challenge object
challenge_obj = None
retry_counter = 0
reason = None
id_length = int(getFromConfig("TransactionIdLength", 12))
while True:
try:
transactionid = Challenge.createTransactionId(length=id_length)
num_challenges = Session.query(Challenge).filter(Challenge.transid == transactionid).count()
if num_challenges == 0:
challenge_obj = Challenge(transid=transactionid, tokenserial=token.getSerial())
if challenge_obj is not None:
break
except Exception as exce:
LOG.info("Failed to create Challenge: %r", exce)
reason = exce
## prevent an unlimited loop
retry_counter = retry_counter + 1
if retry_counter > 100:
LOG.info("Failed to create Challenge for %d times: %r -quiting!", retry_counter, reason)
raise Exception("Failed to create challenge %r" % reason)
challenges = get_challenges(serial=token.getSerial())
## carefully create a new challenge
try:
## we got a challenge object allocated and initialize the challenge
(res, open_transactionid, message, attributes) = token.initChallenge(
transactionid, challenges=challenges, options=options
)
if res == False:
## if a different transid is returned, this indicates, that there
## is already an outstanding challenge we can refere to
if open_transactionid != transactionid:
transactionid = open_transactionid
else:
## in case the init was successfull, we preserve no the challenge data
## to support the implementation of a blocking based on the previous
## stored data
challenge_obj.setChallenge(message)
challenge_obj.save()
(res, message, data, attributes) = token.createChallenge(transactionid, options=options)
if res == True:
## persist the final challenge data + message
challenge_obj.setChallenge(message)
challenge_obj.setData(data)
challenge_obj.save()
else:
transactionid = ""
except Exception as exce:
reason = exce
res = False
## if something goes wrong with the challenge, remove it
if res == False and challenge_obj is not None:
try:
LOG.debug("deleting session")
Session.delete(challenge_obj)
Session.commit()
except Exception as exx:
LOG.debug("deleting session failed: %r" % exx)
try:
Session.expunge(challenge_obj)
Session.commit()
except Exception as exx:
LOG.debug("expunge session failed: %r" % exx)
## in case that create challenge fails, we must raise this reason
if reason is not None:
message = "%r" % reason
LOG.error("Failed to create or init challenge %r " % reason)
raise reason
## prepare the response for the user
if transactionid is not None:
challenge["transactionid"] = transactionid
if message is not None:
challenge["message"] = message
if attributes is not None and type(attributes) == dict:
challenge.update(attributes)
return (res, challenge)
def create_challenge(token, options=None):
"""
dedicated method to create a challenge to support the implementation
of challenge policies in future
:param options: optional parameters for token specific tokens
eg. request a signed challenge
:return: a tuple of (boolean, and a dict, which contains the
{'challenge' : challenge} description)
"""
## response dict, describing the challenge reply
challenge = {}
## the allocated db challenge object
challenge_obj = None
retry_counter = 0
reason = None
id_length = int(getFromConfig('TransactionIdLength', 12))
while True:
try:
transactionid = Challenge.createTransactionId(length=id_length)
num_challenges = Session.query(Challenge).\
filter(Challenge.transid == transactionid).count()
if num_challenges == 0:
challenge_obj = Challenge(transid=transactionid,
tokenserial=token.getSerial())
if challenge_obj is not None:
break
except Exception as exce:
LOG.info("Failed to create Challenge: %r", exce)
reason = exce
## prevent an unlimited loop
retry_counter = retry_counter + 1
if retry_counter > 100:
LOG.info("Failed to create Challenge for %d times: %r -quiting!",
retry_counter, reason)
raise Exception('Failed to create challenge %r' % reason)
challenges = get_challenges(serial=token.getSerial())
## carefully create a new challenge
try:
## we got a challenge object allocated and initialize the challenge
(res, open_transactionid, message, attributes) = \
token.initChallenge(transactionid,
challenges=challenges,
options=options)
if res == False:
## if a different transid is returned, this indicates, that there
## is already an outstanding challenge we can refere to
if open_transactionid != transactionid:
transactionid = open_transactionid
else:
## in case the init was successfull, we preserve no the challenge data
## to support the implementation of a blocking based on the previous
## stored data
challenge_obj.setChallenge(message)
challenge_obj.save()
(res, message, data, attributes) = \
token.createChallenge(transactionid, options=options)
if res == True:
## persist the final challenge data + message
challenge_obj.setChallenge(message)
challenge_obj.setData(data)
challenge_obj.save()
else:
transactionid = ''
except Exception as exce:
reason = exce
res = False
## if something goes wrong with the challenge, remove it
if res == False and challenge_obj is not None:
try:
LOG.debug("deleting session")
Session.delete(challenge_obj)
Session.commit()
except Exception as exx:
LOG.debug("deleting session failed: %r" % exx)
try:
Session.expunge(challenge_obj)
Session.commit()
except Exception as exx:
LOG.debug("expunge session failed: %r" % exx)
## in case that create challenge fails, we must raise this reason
if reason is not None:
message = "%r" % reason
LOG.error("Failed to create or init challenge %r " % reason)
raise reason
## prepare the response for the user
if transactionid is not None:
challenge['transactionid'] = transactionid
if message is not None:
challenge['message'] = message
if attributes is not None and type(attributes) == dict:
challenge.update(attributes)
return (res, challenge)
def create_challenge(token,
options=None,
challenge_id=None,
id_postfix=''):
"""
dedicated method to create a challenge to support the implementation
of challenge policies in future
:param options: optional parameters for token specific tokens
eg. request a signed challenge
:return: a tuple of (boolean, and a dict, which contains the
{'challenge' : challenge} description)
"""
# response dict, describing the challenge reply
challenge = {}
# the allocated db challenge object
challenge_obj = None
retry_counter = 0
reason = None
ReasonException = Exception()
hsm = context['hsm'].get('obj')
transid_len = Challenges.get_tranactionid_length()
id_length = transid_len - len(id_postfix)
while True:
try:
if not challenge_id:
transactionid = "%s%s" % (Challenge.createTransactionId(
length=id_length), id_postfix)
else:
transactionid = challenge_id
num_challenges = Challenge.query.filter_by(
transid=transactionid).count()
if num_challenges == 0:
challenge_obj = Challenge(transid=transactionid,
tokenserial=token.getSerial())
if challenge_obj is not None:
break
except Exception as exce:
log.exception("Failed to create challenge: %r", exce)
reason = "%r" % exce
ReasonException = exce
# prevent an unlimited loop
retry_counter = retry_counter + 1
if retry_counter > 100:
log.error(
"Failed to create challenge for %d times: %r - quiting!",
retry_counter, reason)
raise Exception('Failed to create challenge %r' % reason)
expired_challenges, valid_challenges = Challenges.get_challenges(token)
# carefully create a new challenge
try:
# we got a challenge object allocated and initialize the challenge
(res, open_transactionid, message, attributes) = \
token.initChallenge(transactionid,
challenges=valid_challenges,
options=options)
if res is False:
# if a different transid is returned, this indicates, that there
# is already an outstanding challenge we can refere to
if open_transactionid != transactionid:
transactionid = open_transactionid
else:
# in case the init was successful, we preserve no the
# challenge data to support the implementation of a blocking
# based on the previous stored data
challenge_obj.setChallenge(message)
challenge_obj.save()
(res, message, data, attributes) = \
token.createChallenge(transactionid, options=options)
if res is True:
# persist the final challenge data + message
challenge_obj.setChallenge(message)
challenge_obj.setData(data)
challenge_obj.signChallenge(hsm)
challenge_obj.save()
else:
transactionid = ''
reason = message
ReasonException = Exception(message)
except Exception as exce:
log.exception("Failed to create challenge: %r", exce)
reason = "%r" % exce
ReasonException = exce
res = False
# if something goes wrong with the challenge, remove it
if res is False and challenge_obj is not None:
try:
log.debug("Deleting challenge from database session, because "
"of earlier error")
db.session.delete(challenge_obj)
db.session.commit()
except Exception as exx:
log.debug(
"Deleting challenge from database session failed. "
"Retrying with expunge. Exception was: %r", exx)
try:
db.session.expunge(challenge_obj)
db.session.commit()
except Exception as exx:
log.debug(
"Expunging challenge from database session "
"failed. Exception was: %r", exx)
# in case that create challenge fails, we must raise this reason
if reason is not None:
log.error("Failed to create or init challenge. Reason was %r ",
reason)
raise ReasonException
# prepare the response for the user
if transactionid is not None:
challenge['transactionid'] = transactionid
if message is not None:
challenge['message'] = message
if attributes is not None and type(attributes) == dict:
challenge.update(attributes)
#
# add token specific info like tokentype and serial
#
challenge["linotp_tokenserial"] = token.getSerial()
challenge["linotp_tokentype"] = token.type
return (res, challenge)
