def init_with_options(cls, options):
if cls._securenative is None:
cls._securenative = SecureNative(options)
return cls._securenative
else:
Logger.debug('This SDK was already initialized.')
raise SecureNativeSDKException(u'This SDK was already initialized.')
def encrypt(cls, text, cipher_key):
try:
key = cipher_key[:cls.KEY_SIZE]
iv = Random.new().read(AES.block_size)
cipher = AES.new(key.encode("utf8"), AES.MODE_CBC, iv)
raw = str(cls._pad(text))
return hexlify(iv + cipher.encrypt(raw.encode("utf8")))
except Exception as e:
Logger.error("Could not encrypt text {}; {}".format(text, e))
return None
def read_resource_file(cls, resource_path):
try:
cls.config.read(resource_path)
except Exception as e:
Logger.debug("Invalid config file; {}, using default options".format(e))
properties = {}
for key, value in cls.config.defaults().items():
properties[key.upper()] = value
return properties
def init_with_api_key(cls, api_key):
if Utils.is_null_or_empty(api_key):
raise SecureNativeConfigException("You must pass your SecureNative api key")
if cls._securenative is None:
options = SecureNativeOptions(api_key=api_key)
cls._securenative = SecureNative(options)
return cls._securenative
else:
Logger.debug('This SDK was already initialized.')
raise SecureNativeSDKException(u'This SDK was already initialized.')
def __init__(self, options):
if Utils.is_null_or_empty(options.api_key):
raise SecureNativeSDKException("You must pass your SecureNative api key")
self._options = options
self._event_manager = EventManager(self._options)
if self._options.api_url:
self._event_manager.start_event_persist()
self._api_manager = ApiManager(self._event_manager, self._options)
Logger.init_logger(self._options.log_level)
def verify(self, event_options):
Logger.debug("Verify event call")
event = SDKEvent(event_options, self.options)
try:
res = json.loads(
self.event_manager.send_sync(event,
ApiRoute.VERIFY.value).text)
return VerifyResult(res["riskLevel"], res["score"],
res["triggers"])
except Exception as e:
Logger.debug("Failed to call verify; {}".format(e))
if self.options.fail_over_strategy is FailOverStrategy.FAIL_OPEN.value:
return VerifyResult(RiskLevel.LOW.value, 0, [])
return VerifyResult(RiskLevel.HIGH.value, 1, [])
def send_async(self, event, resource_path):
if self.options.disable:
Logger.warning("SDK is disabled. no operation will be performed")
return
item = QueueItem(
resource_path,
json.dumps(EventManager.serialize(event)),
False
)
self.queue.append(item)
if self._is_queue_full():
self.queue = self.queue[:len(self.queue - 1)]
def decrypt(cls, encrypted, cipher_key):
try:
key = cipher_key[:cls.KEY_SIZE]
content = unhexlify(encrypted)
iv = content[:cls.BLOCK_SIZE]
cipher_text = content[cls.BLOCK_SIZE:]
aes = AES.new(key.encode("utf8"), AES.MODE_CBC, iv)
rv = aes.decrypt(cipher_text).decode("utf-8").strip()
secret = json.loads(rv)
return ClientToken(secret.get("cid"), secret.get("vid"),
secret.get("fp"))
except Exception as e:
Logger.error("Could not decrypt str {}; {}".format(encrypted, e))
return None
def run(self):
while True:
if len(self.queue) > 0 and self.send_enabled:
for item in self.queue:
try:
res = self.http_client.post(item.url, item.body)
if res.status_code == 401:
item.retry = False
elif res.status_code != 200:
item.retry = True
self.queue.remove(item)
Logger.debug("Event successfully sent; {}".format(item.body))
except Exception as e:
Logger.error("Failed to send event; {}".format(e))
if item.retry:
if len(self.coefficients) == self.attempt + 1:
self.attempt = 0
back_off = self.coefficients[self.attempt] * self.options.interval
Logger.debug("Automatic back-off of {}".format(back_off))
self.send_enabled = False
time.sleep(back_off)
self.send_enabled = True
time.sleep(self.interval/1000)
def stop_event_persist(self):
if self.send_enabled:
Logger.debug("Attempting to stop automatic event persistence")
try:
self.flush()
if self.thread:
self.thread.stop()
except ValueError as e:
Logger.error("Could not stop event scheduler; {}".format(e))
Logger.debug("Stopped event persistence")
def send_sync(self, event, resource_path):
if self.options.disable:
Logger.warning("SDK is disabled. no operation will be performed")
return
Logger.debug("Attempting to send event {}".format(event))
res = self.http_client.post(
resource_path,
json.dumps(EventManager.serialize(event))
)
if res is None or res.status_code != 200:
Logger.info("SecureNative failed to call endpoint {} with event {}.".format(resource_path, event))
return res
def track(self, event_options):
Logger.debug("Track event call")
event = SDKEvent(event_options, self.options)
return self.event_manager.send_async(event, ApiRoute.TRACK.value)
def start_event_persist(self):
Logger.debug("Starting automatic event persistence")
if self.options.auto_send or self.send_enabled:
self.send_enabled = True
else:
Logger.debug("Automatic event persistence is disabled, you should persist events manually")