def join_group(self, group_hashtag):
if not group_hashtag.startswith("#"):
group_hashtag = "#" + group_hashtag
groups_suggestions = self.find_groups_suggestions(group_hashtag)
if groups_suggestions is None or len(groups_suggestions.match) == 0:
return None
group_to_join = groups_suggestions.match[0]
group_to_join_name = group_to_join.display_data.hashtag
if group_to_join_name.lower() != group_hashtag.lower():
self._log("[!] The group '{}' does not match exactly to the requested group '{}', so not joining."
.format(group_to_join_name, group_hashtag))
return None
self._log("[+] Joining group '{}' with {} members...".format(group_to_join_name, group_to_join.member_count))
join_token = group_to_join.group_join_token.token
join_token = base64.b64encode(join_token, b"-_").decode()
if join_token.endswith("="):
join_token = join_token[:join_token.index("=")]
data = ('<iq type="set" id="{}">'
'<query xmlns="kik:groups:admin">'
'<g jid="{}" action="join">'
'<code>{}</code>'
'<token>{}</token>'
'</g></query></iq>') \
.format(CryptographicUtils.make_kik_uuid(),
self._resolve_group(group_to_join.jid.local_part),
group_hashtag,
join_token)
self._make_request(data)
response = self._get_response()
if response.error:
self._log("[-] Error when trying to join group:", DebugLevel.ERROR)
self._log(response.error.prettify(), DebugLevel.ERROR)
raise KikErrorException(response.error, "Unable to join group '{}'".format(group_hashtag))
if response.find("type") is None:
self._log("[-] Can't find results")
return None
self._log("[+] Joined to group '{}'".format(group_hashtag))
return group_to_join
def serialize(self) -> bytes:
password_key = CryptographicUtils.key_from_password(
self.username, self.password)
captcha = captcha_element.format(
self.captcha_result) if self.captcha_result else ''
if '@' in self.username:
tag = ('<email>{}</email>' '<passkey-e>{}</passkey-e>')
else:
tag = ('<username>{}</username>' '<passkey-u>{}</passkey-u>')
data = (
'<iq type="set" id="{}">'
'<query xmlns="jabber:iq:register">'
'{}'
'<device-id>{}</device-id>'
'<install-referrer>utm_source=google-play&utm_medium=organic</install-referrer>'
'<operator>{}</operator>'
'<install-date>{}</install-date>'
'<device-type>android</device-type>'
'<brand>{}</brand>'
'<logins-since-install>{}</logins-since-install>'
'<version>{}</version>'
'<lang>en_US</lang>'
'<android-sdk>{}</android-sdk>'
'<registrations-since-install>{}</registrations-since-install>'
'<prefix>CAN</prefix>'
'<android-id>{}</android-id>'
'<model>{}</model>'
'{}'
'</query>'
'</iq>').format(
self.message_id, tag.format(self.username, password_key),
self.device_id_override
if self.device_id_override else device_id,
self.operator_override if self.operator_override else operator,
self.install_date_override
if self.install_date_override else install_date,
self.brand_override if self.brand_override else brand,
self.logins_since_install_override if
self.logins_since_install_override else logins_since_install,
kik_version, self.android_sdk_override
if self.android_sdk_override else android_sdk,
self.registrations_since_install_override
if self.registrations_since_install_override else
registrations_since_install, self.android_id_override
if self.android_id_override else android_id,
self.model_override if self.model_override else model, captcha)
return data.encode()
def send_is_typing(self, username, is_typing, groupchat=False):
self._log('[+] Sending is_typing = {}...'.format(is_typing))
jid = username if groupchat else self._resolve_username(username)
unix_timestamp = str(int(time.time() * 1000))
uuid = CryptographicUtils.make_kik_uuid()
group_type = "groupchat" if groupchat else "is-typing"
data = '<message type="{}" to="{}" id="{}">' \
'{}' \
'<kik push="false" qos="false" timestamp="{}" />' \
'<is-typing ' \
'val="{}" />' \
'</message>'.format(group_type, jid, uuid, "<pb></pb>" if groupchat else "", unix_timestamp, is_typing)
self._make_request(data)
self._log("[+] Okay")
def serialize(self):
jid = self.node + "@talk.kik.com"
jid_with_resource = jid + "/CAN" + (
self.device_id_override if self.device_id_override else device_id)
timestamp = str(CryptographicUtils.make_kik_timestamp())
sid = CryptographicUtils.make_kik_uuid()
# some super secret cryptographic stuff
signature = rsa.sign(
"{}:{}:{}:{}".format(jid, kik_version, timestamp, sid).encode(),
private_key, 'SHA-256')
signature = base64.b64encode(signature,
'-_'.encode()).decode().rstrip('=')
hmac_data = timestamp + ":" + jid
hmac_secret_key = CryptographicUtils.build_hmac_key()
cv = binascii.hexlify(
hmac.new(hmac_secret_key, hmac_data.encode(),
hashlib.sha1).digest()).decode()
password_key = CryptographicUtils.key_from_password(
self.username, self.password)
the_map = {
'from': jid_with_resource,
'to': 'talk.kik.com',
'p': password_key,
'cv': cv,
'v': kik_version,
'sid': sid,
'n': '1',
'conn': 'WIFI',
'ts': timestamp,
'lang': 'en_US',
'signed': signature
}
packet = CryptographicUtils.make_connection_payload(
*CryptographicUtils.sort_kik_map(the_map))
return packet.encode()
def login(self, username, password, establish_session_on_success=True):
self._log("[+] Logging in (username: "******", password: "******")...")
device_id = self.device_id
password_key = CryptographicUtils.key_from_password(username, password)
data = ('<iq type="set" id="{}">'
'<query xmlns="jabber:iq:register">'
'<username>{}</username>'
'<passkey-u>{}</passkey-u>'
'<device-id>{}</device-id>'
'<install-referrer>utm_source=google-play&utm_medium=organic</install-referrer>'
'<operator>310260</operator>'
'<install-date>1494078709023</install-date>'
'<device-type>android</device-type>'
'<brand>generic</brand>'
'<logins-since-install>1</logins-since-install>'
'<version>{}</version>'
'<lang>en_US</lang>'
'<android-sdk>19</android-sdk>'
'<registrations-since-install>0</registrations-since-install>'
'<prefix>CAN</prefix>'
'<android-id>c10d47ba7ee17193</android-id>'
'<model>Samsung Galaxy S5 - 4.4.4 - API 19 - 1080x1920</model>'
'</query>'
'</iq>').format(CryptographicUtils.make_kik_uuid(), username, password_key, device_id,
self.kik_version)
self._make_request(data)
response = self._get_response()
if response.error:
if response.find('password-mismatch'):
self._log("[-] Password mismatch, can't login", DebugLevel.ERROR)
raise KikLoginException(response.error, "Password mismatch")
elif response.error.find('not-registered'):
self._log("[-] User not registered, can't login", DebugLevel.ERROR)
raise KikLoginException(response.error, "Not registered")
else:
captcha = response.find('captcha-url')
if captcha:
self._log("[-} Encountered a captcha. URL: " + captcha.string, DebugLevel.ERROR)
raise KikCaptchaException(response.error, "Captcha when trying to log in! URL: " + captcha.string,
captcha.string)
else:
self._log("[-] Kik error code: {}".format(response.error['code']), DebugLevel.ERROR)
self._log(response.error.prettify(), DebugLevel.ERROR)
raise KikLoginException(response.error, "Kik error code: {}".format(response.error['code']))
if response.find("kik:error"):
captcha = response.find('captcha-type')
if captcha:
self._log("[-} Encountered a captcha. URL: " + captcha.string, DebugLevel.ERROR)
raise KikLoginException(response, "Captcha! URL:" + captcha.string)
user_info = dict()
user_info["node"] = response.find('node').text
user_info["username"] = response.find('username').text
user_info["email"] = response.find('email').text
user_info["first"] = response.find('first').text
user_info["last"] = response.find('last').text
pubkey = response.find('record', {'pk': 'messaging_pub_key'})
if pubkey:
user_info["public_key"] = pubkey.text
user_info["private_key"] = response.find('record', {'pk': 'enc_messaging_priv_key'}).text
if response.find('record', {'pk': 'chat_list_bins'}):
user_info["chat_list"] = self._parse_chat_list_bin(
Utilities.decode_base64(response.find('record', {'pk': 'chat_list_bins'}).text.encode('UTF-8')))
self._log("[+] Logged in.")
if self.debug_level == DebugLevel.VERBOSE:
Utilities.print_dictionary(user_info)
self.user_info = user_info
if establish_session_on_success:
self.establish_session(self.user_info["username"], self.user_info["node"], password)
return self.user_info
def __init__(self):
self.message_id = CryptographicUtils.make_kik_uuid()
self.content_id = CryptographicUtils.make_kik_uuid() #Creating a seprate uuid for content as kik does the same.
