def encrypt_credential_v1(self, raw):
if sys.version_info < (3, 0):
raw = bytes(py2_encode(raw))
else:
raw = bytes(raw, 'utf-8')
aes = pyaes.AESModeOfOperationCTR(self.get_device_id_v1())
return Util.base64enc(aes.encrypt(raw))
def get_device_id_v1(self):
if self.usedevkey:
from libs.uuid_device import get_crypt_key
dev_key = get_crypt_key()
else:
dev_key = HbogoConstants.fallback_ck
return Util.hash256_bytes(dev_key + self.addon_id + '.credentials.v1.' + codecs.encode(dev_key, 'rot_13'))
def exclude_url_from_cache(self, url):
try:
cur = self.db.cursor()
cur.execute("INSERT INTO request_cache_exclude(url_hash) VALUES (?)", (Util.hash256_string(url), ), )
self.db.commit()
except Exception:
self.log("Exclude from cache WARNING: " + traceback.format_exc())
def get_from_hbogo(self, url, response_format='json', use_cache=True, retry=0):
self.log("GET FROM HBO URL: " + url)
self.log("GET FROM HBO RESPONSE FORMAT: " + response_format)
if not self.use_cache:
use_cache = False
url_hash = Util.hash256_string(url)
if use_cache:
self.log("GET FROM HBO USING CACHE...")
cached_data = self.get_from_cache(url_hash)
if cached_data is not None and cached_data is not False:
self.log("GET FROM HBO Serving from cache...")
if response_format == 'json':
return json.loads(py2_encode(cached_data))
elif response_format == 'xml':
return ET.fromstring(py2_encode(cached_data))
if cached_data is False:
self.log("GET FROM HBO, URL on exclude list, cache disabled...")
use_cache = False
try:
self.log("GET FROM HBO, requesting from Hbo Go...")
r = requests.get(url, headers=self.loggedin_headers)
self.log("GET FROM HBO STATUS: " + str(r.status_code))
if int(r.status_code) != 200:
if retry < self.max_comm_retry:
self.log("RETURNED STATUS " + str(r.status_code) + " resetting login and retrying request...")
self.del_login()
self.login()
return self.get_from_hbogo(url, response_format, use_cache, retry + 1)
xbmcgui.Dialog().ok(self.LB_ERROR, self.language(30008) + str(r.status_code))
return False
if use_cache:
try:
self.log("SAVING URL TO CACHE")
self.cache(url_hash, r.text)
except Exception:
self.log("Caching WARNING: " + traceback.format_exc())
if response_format == 'json':
return r.json()
elif response_format == 'xml':
return ET.fromstring(py2_encode(r.text))
except requests.RequestException as e:
self.log("GET FROM HBO ERROR: " + repr(e))
xbmcgui.Dialog().ok(self.LB_ERROR, self.language(30005))
return False
except Exception:
self.log("GET TO HBO UNEXPECTED ERROR: " + traceback.format_exc())
xbmcgui.Dialog().ok(self.LB_ERROR, self.language(30004))
return False
def decrypt_credential_v1(self, enc):
try:
enc = Util.base64dec_bytes(enc)
aes = pyaes.AESModeOfOperationCTR(self.get_device_id_v1())
if sys.version_info < (3, 0):
return py2_decode(aes.decrypt(enc))
return aes.decrypt(enc).decode('utf8')
except Exception:
self.log("Decrypt credentials error: " + traceback.format_exc())
return None
def login(self):
username = self.getCredential('username')
password = self.getCredential('password')
headers = {
'Host':
self.API_HOST,
'User-Agent':
self.UA,
'Accept':
'*/*',
'Accept-Language':
self.ACCEPT_LANGUAGE,
'Accept-Encoding':
'gzip, deflate, br',
'Referer':
self.API_HOST_GATEWAY_REFERER,
'Content-Type':
'application/xml',
'Authorization':
'Basic ' +
Util.base64enc(username + ":" + Util.base64enc(password)),
'Origin':
self.API_HOST_GATEWAY,
'Connection':
'keep-alive',
}
self.API_DEVICE_ID = self.addon.getSetting('individualization')
if self.API_DEVICE_ID == "":
self.log("NO REGISTRED DEVICE - generating")
self.API_DEVICE_ID = self.generate_device_id()
self.addon.setSetting('individualization', str(self.API_DEVICE_ID))
self.log("DEVICE ID: " + self.API_DEVICE_ID)
login_hash = Util.hash256_string(self.API_DEVICE_ID + username +
password)
self.log("LOGIN HASH: " + login_hash)
loaded_session = self.load_obj(self.addon_id + "_es_session")
if loaded_session is not None:
self.log("SAVED SESSION LOADED")
if loaded_session["hash"] == login_hash:
self.log("HASH IS VALID")
if time.time() < (loaded_session["time"] +
(self.SESSION_VALIDITY * 60 * 60)):
self.log("NOT EXPIRED RESTORING...")
self.API_DEVICE_TOKEN = loaded_session["API_DEVICE_TOKEN"]
self.API_IDENTITY_GUID = loaded_session[
"API_IDENTITY_GUID"]
self.API_ACCOUNT_GUID = loaded_session["API_ACCOUNT_GUID"]
self.init_api()
loaded_session['time'] = time.time()
self.save_obj(loaded_session,
self.addon_id + "_es_session")
return True
data = '<device><type>web</type><deviceId>' + self.API_DEVICE_ID + '</deviceId></device>'
response = self.post_to_hbogo(
self.API_URL_AUTH_WEBBASIC, headers, data, 'xml', self.
max_comm_retry) # last parameter prevent retry on failed login
if response is False:
return False
if response.find('status').text == 'Success':
self.API_DEVICE_TOKEN = response.find('token').text
self.API_IDENTITY_GUID = response.find('identityGuid').text
self.API_ACCOUNT_GUID = response.find('accountGuid').text
self.init_api()
login_hash = Util.hash256_string(
str(self.API_DEVICE_ID) + str(username) + str(password))
self.log("LOGIN HASH: " + login_hash)
saved_session = {
"hash": login_hash,
"API_DEVICE_TOKEN": self.API_DEVICE_TOKEN,
"API_IDENTITY_GUID": self.API_IDENTITY_GUID,
"API_ACCOUNT_GUID": self.API_ACCOUNT_GUID,
"time": time.time()
}
self.save_obj(saved_session, self.addon_id + "_es_session")
return True
return False
