diff --git a/nethook_helpers.py b/nethook_helpers.py
new file mode 100644
index 00000000..a97c5a85
--- /dev/null
+++ b/nethook_helpers.py
@@ -0,0 +1,113 @@
+import sys
+import pathlib
+import shutil
+import os
+import typing as t
+import psutil
+import time
+from collections import Counter
+
+
+STEAM_PATH = R'C:\Program Files (x86)\Steam\steam.exe'
+GALAXY_PATH = R'C:\Program Files (x86)\GOG Galaxy\GalaxyClient.exe'
+NETHOOK_PATH = None  # R'C:COMPLETE_ME\\NetHook2\NetHook2.dll'
+
+
+def find_steam_ps(initial: t.Optional[psutil.Process]=None) -> t.Optional[psutil.Process]:
+    if initial and initial.is_running():
+        return initial
+    for p in psutil.process_iter(['exe'], ad_value=''):
+        if STEAM_PATH == p.info['exe']:
+            return p
+    return None
+
+
+def restart_steam():
+    p = psutil.Popen([STEAM_PATH, "-shutdown", "-silent"])
+    p.wait()
+    steam_ps = find_steam_ps()
+    if steam_ps:
+        steam_ps.wait(timeout=10)
+    return psutil.Popen(STEAM_PATH)
+
+
+def restart_galaxy():
+    p = psutil.Popen([GALAXY_PATH, '/command=shutdown'])
+    p.wait()
+    psutil.Popen(GALAXY_PATH)
+
+
+def inject_nethook(steam_ps=None):
+    """Requires running as admin"""
+    timeout = time.time() + 10
+    while True:
+        steam_ps = find_steam_ps(steam_ps)
+        assert steam_ps, 'NetHook requires Steam running'
+        if time.time() > timeout:
+            print('timeout on loading steamclint.dll by Steam')
+            break
+        if [dll for dll in steam_ps.memory_maps() if 'steamclient.dll' in dll.path]:
+            print('steamclient.dll loaded. Injecting nethook')
+            break
+    cmd = f'rundll32 "{NETHOOK_PATH}",Inject'
+    psutil.Popen(cmd)
+
+
+def copy_results_to_common_dir(dest_dir, must_include=''):
+    os.makedirs(dest_dir, exist_ok=True)
+    steam_nethook_dir = pathlib.PurePath(STEAM_PATH).parent / 'nethook'
+    for d in os.listdir(steam_nethook_dir):
+        if steam_nethook_dir.name == d:  # avoid recurssion
+            continue
+        for f in os.listdir(steam_nethook_dir / d):
+            if must_include not in f:
+                continue
+            src = steam_nethook_dir / d / f
+            dest = pathlib.PurePath(dest_dir) / (src.name + '_' + d + src.suffix)  # originalname_timestamp.bin
+            shutil.copy(src, dest)
+
+
+def print_statistics(first_signals=10):
+    steam_nethook_dir = pathlib.PurePath(STEAM_PATH).parent / 'nethook'
+    signals = Counter()
+    for root, dirs, files in os.walk(steam_nethook_dir):
+        signal_names = []
+        for i, f in enumerate(sorted(files)):
+            if i > first_signals:
+                break
+            signal_names.append(f.split('_')[-1])
+        signals.update(signal_names)
+    print(signals)
+
+
+def main():
+    if NETHOOK_PATH is None:
+        print('set up nethook path in script first')
+
+    try:
+        no = int(sys.argv[1])
+    except (IndexError, ValueError):
+        print('Usage: <script> <number_of_restarts> <path_to_copy_chosen_signals>')
+        return
+
+    try:
+        output = sys.argv[2]
+    except IndexError:
+        output = 'output_nethook'
+
+    for i in range(no):
+        try:
+            print(f'Running {i+1}. time...')
+            steam_proc: psutil.Popen = restart_steam()
+            inject_nethook(steam_proc)
+            time.sleep(12)  # Steam startup
+        except Exception as e:
+            print(repr(e))
+            continue
+
+    print_statistics()
+    copy_results_to_common_dir(output, must_include='ClientLogOnResponse')
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/local_machine_cache.py b/src/local_machine_cache.py
new file mode 100644
index 00000000..0cac35e1
--- /dev/null
+++ b/src/local_machine_cache.py
@@ -0,0 +1,25 @@
+import base64
+import logging
+
+from persistent_cache_state import PersistentCacheState
+
+
+logger = logging.getLogger(__name__)
+
+
+class LocalMachineCache:
+
+    def __init__(self, persistent_cache: dict, cache_state: PersistentCacheState):
+        self._cache_state = cache_state
+        self._persistent_cache = persistent_cache
+
+    @property
+    def machine_id(self) -> bytes:
+        return base64.b64decode(self._persistent_cache.get('machine_id', ''))
+
+    @machine_id.setter
+    def machine_id(self, machine_id: bytes):
+        self._persistent_cache['machine_id'] = base64.b64encode(machine_id).decode('utf-8')
+        self._cache_state.modified = True
+        logger.info("Set new machine ID: %s" % machine_id)
+
diff --git a/src/plugin.py b/src/plugin.py
index a41722b2..ba95d42c 100755
--- a/src/plugin.py
+++ b/src/plugin.py
@@ -24,6 +24,7 @@
     StateFlags, local_games_list, get_state_changes, get_client_executable,
     load_vdf, get_library_folders, get_app_manifests, app_id_from_manifest_path
 )
+from local_machine_cache import LocalMachineCache
 from websocket_list import WebSocketList
 from presence import presence_from_user_info
 from friends_cache import FriendsCache
@@ -131,9 +132,10 @@ async def user_presence_update_handler(user_id: str, proto_user_info: ProtoUserI
     def handshake_complete(self):
         websocket_list = WebSocketList(self._client)
         ownership_ticket_cache = OwnershipTicketCache(self.persistent_cache, self._persistent_storage_state)
+        local_machine_cache = LocalMachineCache(self.persistent_cache, self._persistent_storage_state)
         self._steam_client = WebSocketClient(self._client, self._ssl_context, websocket_list, self._friends_cache,
                                              self._games_cache, self._translations_cache, self._stats_cache,
-                                             self._times_cache, self._user_info_cache, ownership_ticket_cache)
+                                             self._times_cache, self._user_info_cache, local_machine_cache, ownership_ticket_cache)
 
     async def shutdown(self):
         self._regmon.close()
diff --git a/src/protocol/consts.py b/src/protocol/consts.py
index 52a3f5c9..ee8cba23 100644
--- a/src/protocol/consts.py
+++ b/src/protocol/consts.py
@@ -1862,6 +1862,10 @@ class EOSType(enum.IntEnum):
     MacOS1010 = -87
     MacOS1011 = -86
     MacOS1012 = -85
+    MacOS1013 = -84
+    MacOS1014 = -83
+    MacOS1015 = -82
+    MacOS1016 = -81
     MacOSMax = -1
     LinuxUnknown = -203
     Linux22 = -202
diff --git a/src/protocol/protobuf_client.py b/src/protocol/protobuf_client.py
index 06f55df2..f5926790 100644
--- a/src/protocol/protobuf_client.py
+++ b/src/protocol/protobuf_client.py
@@ -1,22 +1,24 @@
 import asyncio
-import ipaddress
-import struct
 import gzip
+import hashlib
+import ipaddress
 import json
 import logging
+import socket
+import struct
 from itertools import count
-from typing import Awaitable, Callable,Dict, Optional, Any
-from galaxy.api.errors import UnknownBackendResponse
+from typing import Awaitable, Callable, Dict, Optional, Any
 from typing import List, NamedTuple
 
-from protocol.messages import steammessages_base_pb2, steammessages_clientserver_login_pb2, steammessages_player_pb2, \
-    steammessages_clientserver_friends_pb2, steammessages_clientserver_pb2, steamui_libraryroot_pb2, steammessages_clientserver_2_pb2
+import vdf
+from galaxy.api.errors import UnknownBackendResponse
+
 from protocol.consts import EMsg, EResult, EAccountType, EFriendRelationship, EPersonaState
+from protocol.messages import steammessages_base_pb2, steammessages_clientserver_login_pb2, steammessages_player_pb2, \
+    steammessages_clientserver_friends_pb2, steammessages_clientserver_pb2, steamui_libraryroot_pb2, \
+    steammessages_clientserver_2_pb2
 from protocol.types import SteamId, ProtoUserInfo
 
-import vdf
-import hashlib
-
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.INFO)
 LOG_SENSITIVE_DATA = False
@@ -31,6 +33,8 @@ class ProtobufClient:
     _PROTO_MASK = 0x80000000
     _ACCOUNT_ID_MASK = 0x0110000100000000
     _IP_OBFUSCATION_MASK = 0x606573A4
+    _MSG_PROTOCOL_VERSION = 65580
+    _MSG_CLIENT_PACKAGE_VERSION = 1561159470
 
     def __init__(self, set_socket):
         self._socket = set_socket
@@ -107,22 +111,15 @@ async def get_app_ownership_ticket(self, app_id: int):
     async def register_auth_ticket_with_cm(self, ticket: bytes):
         message = steammessages_clientserver_pb2.CMsgClientRegisterAuthTicketWithCM()
         message.ticket = ticket
-        message.protocol_version = 65580
-        message.client_instance_id = 0  # ??
+        message.protocol_version = self._MSG_PROTOCOL_VERSION
         await self._send(EMsg.ClientRegisterAuthTicketWithCM, message)
 
-    async def log_on_password(self, account_name, password, two_factor, two_factor_type):
+    async def log_on_password(self, account_name, password, two_factor, two_factor_type, machine_id, os_value, sentry):
         def sanitize_password(password):
             return ''.join([i if ord(i) < 128 else '' for i in password])
 
-        message = steammessages_clientserver_login_pb2.CMsgClientLogon()
-        message.account_name = account_name
-        message.protocol_version = 65580
+        message = self._prepare_log_on_msg(account_name, machine_id, os_value, sentry)
         message.password = sanitize_password(password)
-        message.should_remember_password = True
-        message.supports_rate_limit_response = True
-        message.obfuscated_private_ip.v4 = self._get_obfuscated_private_ip()
-
         if two_factor:
             if two_factor_type == 'email':
                 message.auth_code = two_factor
@@ -131,25 +128,36 @@ def sanitize_password(password):
         logger.info("Sending log on message using credentials")
         await self._send(EMsg.ClientLogon, message)
 
-    async def log_on_token(self, steam_id, account_name, token, used_server_cell_id):
+    async def log_on_token(self, account_name, token, used_server_cell_id, machine_id, os_value, sentry):
+        message = self._prepare_log_on_msg(account_name, machine_id, os_value, sentry)
+        message.cell_id = used_server_cell_id
+        message.login_key = token
+        logger.info("Sending log on message using token")
+        await self._send(EMsg.ClientLogon, message)
+
+    def _prepare_log_on_msg(self, account_name: str, machine_id: bytes, os_value: int, sentry) -> "steammessages_clientserver_login_pb2.CMsgClientLogon":
         message = steammessages_clientserver_login_pb2.CMsgClientLogon()
         message.account_name = account_name
-        message.cell_id = used_server_cell_id
-        message.protocol_version = 65580
+        message.protocol_version = self._MSG_PROTOCOL_VERSION
+        message.client_package_version = self._MSG_CLIENT_PACKAGE_VERSION
+        message.client_language = "english"
         message.should_remember_password = True
         message.supports_rate_limit_response = True
-        message.login_key = token
+        message.steamguard_dont_remember_computer = False
         message.obfuscated_private_ip.v4 = self._get_obfuscated_private_ip()
+        message.qos_level = 3
+        message.machine_name = socket.gethostname()
+        message.client_os_type = os_value if os_value >= 0 else 0
+        message.machine_id = machine_id
 
-        sentry = await self.sentry()
         if sentry:
             logger.info("Sentry present")
             message.eresult_sentryfile = EResult.OK
             message.sha_sentryfile = sentry
+        else:
+            message.eresult_sentryfile = EResult.FileNotFound
 
-        self.steam_id = steam_id
-        logger.info("Sending log on message using token")
-        await self._send(EMsg.ClientLogon, message)
+        return message
 
     def _get_obfuscated_private_ip(self) -> int:
         host, port = self._socket.local_address
@@ -224,9 +232,10 @@ async def get_presence_localization(self, appid, language='english'):
         message.language = language
 
         job_id = next(self._job_id_iterator)
-        await self._send(EMsg.ServiceMethodCallFromClient, message, job_id, None,  target_job_name='Community.GetAppRichPresenceLocalization#1')
+        await self._send(EMsg.ServiceMethodCallFromClient, message, job_id, None,
+                         target_job_name='Community.GetAppRichPresenceLocalization#1')
 
-    async def accept_update_machine_auth(self,jobid_target, sha_hash, offset, filename, cubtowrite):
+    async def accept_update_machine_auth(self, jobid_target, sha_hash, offset, filename, cubtowrite):
         message = steammessages_clientserver_2_pb2.CMsgClientUpdateMachineAuthResponse()
         message.filename = filename
         message.eresult = EResult.OK
@@ -244,12 +253,12 @@ async def accept_new_login_token(self, unique_id, jobid_target):
         await self._send(EMsg.ClientNewLoginKeyAccepted, message, None, jobid_target, None)
 
     async def _send(
-            self,
-            emsg,
-            message,
-            source_job_id=None,
-            target_job_id=None,
-            target_job_name=None
+        self,
+        emsg,
+        message,
+        source_job_id=None,
+        target_job_id=None,
+        target_job_name=None
     ):
         proto_header = steammessages_base_pb2.CMsgProtoBufHeader()
         if self.steam_id is not None:
diff --git a/src/protocol/protocol_client.py b/src/protocol/protocol_client.py
index e00c9d2b..0e53e425 100644
--- a/src/protocol/protocol_client.py
+++ b/src/protocol/protocol_client.py
@@ -1,10 +1,14 @@
 import asyncio
 import logging
 import enum
+import platform
+
 import galaxy.api.errors
+import secrets
 
+from local_machine_cache import LocalMachineCache
 from protocol.protobuf_client import ProtobufClient, SteamLicense
-from protocol.consts import EResult, EFriendRelationship, EPersonaState, STEAM_CLIENT_APP_ID
+from protocol.consts import EResult, EFriendRelationship, EPersonaState, STEAM_CLIENT_APP_ID, EOSType
 from friends_cache import FriendsCache
 from games_cache import GamesCache
 from stats_cache import StatsCache
@@ -17,6 +21,41 @@
 
 logger = logging.getLogger(__name__)
 
+
+def get_os() -> EOSType:
+    system = platform.system()
+    if system == 'Windows':
+        release = platform.release()
+        releases = {
+            'XP': EOSType.WinXP,
+            'Vista': EOSType.WinVista,
+            '7': EOSType.Windows7,
+            '8': EOSType.Windows8,
+            '8.1': EOSType.Windows81,
+            '10': EOSType.Windows10,
+        }
+        return releases.get(release, EOSType.WinUnknown)
+    elif system == 'Darwin':
+        release = platform.mac_ver()[0]
+        releases = {
+            '10.4': EOSType.MacOS104,
+            '10.5': EOSType.MacOS105,
+            '10.6': EOSType.MacOS106,
+            '10.7': EOSType.MacOS107,
+            '10.8': EOSType.MacOS108,
+            '10.9': EOSType.MacOS109,
+            '10.10': EOSType.MacOS1010,
+            '10.11': EOSType.MacOS1011,
+            '10.12': EOSType.MacOS1012,
+            '10.13': EOSType.MacOS1013,
+            '10.14': EOSType.MacOS1014,
+            '10.15': EOSType.MacOS1015,
+            '10.16': EOSType.MacOS1016,
+        }
+        return releases.get(release, EOSType.MacOSUnknown)
+    return EOSType.Unknown
+
+
 def translate_error(result: EResult):
     assert result != EResult.OK
     data = {
@@ -101,6 +140,7 @@ def __init__(self,
         stats_cache: StatsCache,
         times_cache: TimesCache,
         user_info_cache: UserInfoCache,
+        local_machine_cache: LocalMachineCache,
         ownership_ticket_cache: OwnershipTicketCache,
         used_server_cell_id,
     ):
@@ -131,6 +171,14 @@ def __init__(self,
         self._auth_lost_handler = None
         self._login_future = None
         self._used_server_cell_id = used_server_cell_id
+        self._local_machine_cache = local_machine_cache
+        if not self._local_machine_cache.machine_id:
+            self._local_machine_cache.machine_id = self._generate_machine_id()
+        self._machine_id = self._local_machine_cache.machine_id
+
+    @staticmethod
+    def _generate_machine_id():
+        return secrets.token_bytes()
 
     async def close(self, is_socket_connected):
         await self._protobuf_client.close(is_socket_connected)
@@ -150,7 +198,11 @@ async def register_auth_ticket_with_cm(self, ticket: bytes):
     async def authenticate_password(self, account_name, password, two_factor, two_factor_type, auth_lost_handler):
         loop = asyncio.get_running_loop()
         self._login_future = loop.create_future()
-        await self._protobuf_client.log_on_password(account_name, password, two_factor, two_factor_type)
+        os_value = get_os()
+        sentry = await self._get_sentry()
+        await self._protobuf_client.log_on_password(
+            account_name, password, two_factor, two_factor_type, self._machine_id, os_value, sentry
+        )
         result = await self._login_future
         logger.info(result)
         if result == EResult.OK:
@@ -181,7 +233,12 @@ async def authenticate_password(self, account_name, password, two_factor, two_fa
     async def authenticate_token(self, steam_id, account_name, token, auth_lost_handler):
         loop = asyncio.get_running_loop()
         self._login_future = loop.create_future()
-        await self._protobuf_client.log_on_token(steam_id, account_name, token, self._used_server_cell_id)
+        self._protobuf_client.steam_id = steam_id
+        os_value = get_os()
+        sentry = await self._get_sentry()
+        await self._protobuf_client.log_on_token(
+            account_name, token, self._used_server_cell_id, self._machine_id, os_value, sentry
+        )
         result = await self._login_future
         if result == EResult.OK:
             self._auth_lost_handler = auth_lost_handler
diff --git a/src/protocol/websocket_client.py b/src/protocol/websocket_client.py
index b8506e00..c0fa2603 100644
--- a/src/protocol/websocket_client.py
+++ b/src/protocol/websocket_client.py
@@ -10,6 +10,7 @@
 from backend import SteamHttpClient
 from friends_cache import FriendsCache
 from games_cache import GamesCache
+from local_machine_cache import LocalMachineCache
 from ownership_ticket_cache import OwnershipTicketCache
 from protocol.protocol_client import ProtocolClient, UserActionRequired
 from stats_cache import StatsCache
@@ -24,6 +25,7 @@
 RECONNECT_INTERVAL_SECONDS = 20
 MAX_INCOMING_MESSAGE_SIZE = 2**24
 
+
 class WebSocketClient:
     def __init__(
         self,
@@ -36,6 +38,7 @@ def __init__(
         stats_cache: StatsCache,
         times_cache: TimesCache,
         user_info_cache: UserInfoCache,
+        local_machine_cache: LocalMachineCache,
         ownership_ticket_cache: OwnershipTicketCache
     ):
         self._backend_client = backend_client
@@ -49,13 +52,13 @@ def __init__(
         self._translations_cache = translations_cache
         self._stats_cache = stats_cache
         self._user_info_cache = user_info_cache
+        self._local_machine_cache = local_machine_cache
         self._steam_app_ownership_ticket_cache = ownership_ticket_cache
 
         self.communication_queues = {'plugin': asyncio.Queue(), 'websocket': asyncio.Queue(), 'errors': asyncio.Queue()}
         self._times_cache = times_cache
         self.used_server_cell_id = 0
 
-
     async def run(self):
         loop = asyncio.get_running_loop()
         while True:
@@ -177,7 +180,7 @@ async def _ensure_connected(self):
             for server in await self._websocket_list.get(self.used_server_cell_id):
                 try:
                     self._websocket = await asyncio.wait_for(websockets.connect(server, ssl=self._ssl_context, max_size=MAX_INCOMING_MESSAGE_SIZE), 5)
-                    self._protocol_client = ProtocolClient(self._websocket, self._friends_cache, self._games_cache, self._translations_cache, self._stats_cache, self._times_cache, self._user_info_cache, self._steam_app_ownership_ticket_cache, self.used_server_cell_id)
+                    self._protocol_client = ProtocolClient(self._websocket, self._friends_cache, self._games_cache, self._translations_cache, self._stats_cache, self._times_cache, self._user_info_cache, self._local_machine_cache, self._steam_app_ownership_ticket_cache, self.used_server_cell_id)
                     logger.info(f'Connected to Steam on CM {server} on cell_id {self.used_server_cell_id}')
                     return
                 except (asyncio.TimeoutError, OSError, websockets.InvalidURI, websockets.InvalidHandshake):
diff --git a/src/user_info_cache.py b/src/user_info_cache.py
index 9f9627dd..b225dd68 100644
--- a/src/user_info_cache.py
+++ b/src/user_info_cache.py
@@ -2,6 +2,7 @@
 import base64
 import logging as log
 
+
 class UserInfoCache:
     def __init__(self):
         self._steam_id = None
@@ -143,4 +144,3 @@ def sentry(self, val):
         self._sentry = val
         if not self.initialized.is_set():
             self._check_initialized()
-
diff --git a/src/version.py b/src/version.py
index 4b2f1eb5..39398547 100755
--- a/src/version.py
+++ b/src/version.py
@@ -1,5 +1,9 @@
-__version__ = "0.56"
+__version__ = "0.57"
 __changelog__ = {
+    "0.57": '''
+    - added helper script for injecting Nethook (for devs)
+    - improved login auth protobuf message for following attributes: client_package_version, machine_id, client_language, qos_level, machine_name, client_os_type
+    ''',
     "0.56": '''
     - fixed handling if libraryfolders.vdf was not found
     - connection stability improvement (no longer connects to servers from different regions) (#108 thanks @SparrowBrain!)
@@ -25,50 +29,50 @@
     - raise BackendError instead of BackendTimeout when couldn't login with token
     - register steam app ticket with CM before logging and save a new ticket after login
     ''',
-    "0.51.2":'''
+    "0.51.2": '''
     - Enhance local game sizes by returning downloading size if game is not fully installed yet
     - Drop attaching obfuscated private ip to login params.
     ''',
-    "0.51.1":'''
+    "0.51.1": '''
     - Fixup marking when games cache is ready in situations when part of the cache was already initialized
     - Optimize retrieving subscription status
     - Fixes for rich presence translations for certain games (dota, stellaris)
     ''',
-    "0.51":'''
+    "0.51": '''
     - Use package access token when retrieving package information, should fix some games not appearing
     ''',
-    "0.50.9":'''
+    "0.50.9": '''
     - Refactor games cache for readability and debugging purposses
     - Implement getting local game sizes
     ''',
-    "0.50.8":'''
+    "0.50.8": '''
     - Fix crash on potential looping rich presence translation
     - Fix possible 0 owned games sent issue occuring if previous retrieval was stopped mid-way
     ''',
-    "0.50.7":'''
+    "0.50.7": '''
     - Use LoginKeyAccepted message post auth
     - Retry using servers from a different cellid (update login params to handle cell id)
     ''',
-    "0.50.6":'''
+    "0.50.6": '''
     - Send log off call on plugin shutdown
     - More precise login parameters, up protocol version
     ''',
-    "0.50.5":'''
+    "0.50.5": '''
     - Don't get stuck on broken cache in subsequent runs, instead always reimport packages which didn't end up being resolved (Thanks Dugsdghk!)
     - Don't crash protobuf on bytes response in initial rich presence parsing (Thanks Dugsdghk!)
     ''',
-    "0.50.4":'''
+    "0.50.4": '''
     - Fix for owned games which are also present in one of family sharings being reported only as family shared. (Thanks for the help Svill and TM-CG!)
     ''',
-    "0.50.3":'''
+    "0.50.3": '''
     - Dont endlessly retry auth to not lock user out
     ''',
-    "0.50.2":'''
+    "0.50.2": '''
     - Fix missing achievement_id crashing protobuf_client (Thanks MartinCa!)
     - Extended supported result codes from steam auth
     - Increase logging of protobuf responses
     ''',
-    "0.50.1":'''
+    "0.50.1": '''
     - Ignore incompatible cache
     ''',
     "0.50": '''
diff --git a/tests/test_authentication.py b/tests/test_authentication.py
index b8277adc..be10b3df 100644
--- a/tests/test_authentication.py
+++ b/tests/test_authentication.py
@@ -14,7 +14,10 @@
 _TOKEN = "token"
 _SENTRY = b""
 
-serialized_creds = {'steam_id': 'MTIz', 'account_id': 'MjM=', 'token': 'dG9rZW4=', 'account_username': '8J+Yi+WtpuS4reaWh9Cd0LXMgdC60L7Rgg==', 'persona_name': 'UHRlc3Rlcg==', 'sentry': ''}
+serialized_creds = {'steam_id': 'MTIz', 'account_id': 'MjM=', 'token': 'dG9rZW4=',
+                    'account_username': '8J+Yi+WtpuS4reaWh9Cd0LXMgdC60L7Rgg==', 'persona_name': 'UHRlc3Rlcg==',
+                    'sentry': ''}
+
 
 @pytest.mark.asyncio
 async def test_credentials_cache_store():
@@ -65,6 +68,7 @@ async def test_login_finished(authenticated_plugin):
     authenticated_plugin._get_websocket_auth_step.assert_called()
     authenticated_plugin.store_credentials.assert_called()
 
+
 @pytest.mark.asyncio
 async def test_login_two_step(authenticated_plugin):
     credentials = {}
diff --git a/tests/test_protobuf_client.py b/tests/test_protobuf_client.py
new file mode 100644
index 00000000..56c05a67
--- /dev/null
+++ b/tests/test_protobuf_client.py
@@ -0,0 +1,67 @@
+from unittest.mock import MagicMock
+
+import pytest
+from galaxy.unittest.mock import AsyncMock
+
+from protocol.protobuf_client import ProtobufClient
+
+
+ACCOUNT_NAME = "john"
+PASSWORD = "testing123"
+TWO_FACTOR = "AbCdEf"
+TOKEN = "TOKEN"
+USED_SERVER_CELL_ID = 0
+MACHINE_ID = bytes('machine_id', 'utf-8')
+OS_VALUE = 1
+SENTRY = None
+PRIVATE_IP = 1
+HOST_NAME = "john pc"
+PROTOCOL_VERSION = ProtobufClient._MSG_PROTOCOL_VERSION
+CLIENT_PACKAGE_VERSION = ProtobufClient._MSG_CLIENT_PACKAGE_VERSION
+CLIENT_LANGUAGE = "english"
+TWO_FACTOR_TYPE = 'email'
+
+
+@pytest.fixture
+def websocket():
+    websocket_ = MagicMock()
+    websocket_.send = AsyncMock()
+    return websocket_
+
+
+@pytest.fixture
+async def client(websocket, mocker):
+    protobuf_client = ProtobufClient(websocket)
+    protobuf_client._get_obfuscated_private_ip = MagicMock(return_value=PRIVATE_IP)
+    mocker.patch(
+        "socket.gethostname", return_value=HOST_NAME
+    )
+    return protobuf_client
+
+
+@pytest.mark.asyncio
+async def test_log_on_token_message(client, websocket):
+    await client.log_on_token(ACCOUNT_NAME, TOKEN, USED_SERVER_CELL_ID, MACHINE_ID, OS_VALUE, SENTRY)
+    msg_to_send = str(websocket.send.call_args[0][0])
+    assert ACCOUNT_NAME in msg_to_send
+    assert TOKEN in msg_to_send
+    assert str(USED_SERVER_CELL_ID) in msg_to_send
+    assert MACHINE_ID.decode('utf-8') in msg_to_send
+    assert str(OS_VALUE) in msg_to_send
+    assert str(PRIVATE_IP) in msg_to_send
+    assert HOST_NAME in msg_to_send
+    assert CLIENT_LANGUAGE in msg_to_send
+
+
+@pytest.mark.asyncio
+async def test_log_on_password_message(client, websocket):
+    await client.log_on_password(ACCOUNT_NAME, PASSWORD, TWO_FACTOR, TWO_FACTOR_TYPE, MACHINE_ID,OS_VALUE, SENTRY)
+    msg_to_send = str(websocket.send.call_args[0][0])
+    assert ACCOUNT_NAME in msg_to_send
+    assert str(USED_SERVER_CELL_ID) in msg_to_send
+    assert MACHINE_ID.decode('utf-8') in msg_to_send
+    assert str(OS_VALUE) in msg_to_send
+    assert str(PRIVATE_IP) in msg_to_send
+    assert HOST_NAME in msg_to_send
+    assert CLIENT_LANGUAGE in msg_to_send
+    assert TWO_FACTOR in msg_to_send
diff --git a/tests/test_protocol_client.py b/tests/test_protocol_client.py
index 64c4d165..551592c2 100644
--- a/tests/test_protocol_client.py
+++ b/tests/test_protocol_client.py
@@ -43,6 +43,10 @@ def stats_cache():
 def user_info_cache():
     return AsyncMock()
 
+@pytest.fixture()
+def local_machine_cache():
+    return MagicMock()
+
 @pytest.fixture()
 def times_cache():
     return MagicMock()
@@ -60,8 +64,8 @@ def translations_cache():
     return dict()
 
 @pytest.fixture
-async def client(protobuf_client, friends_cache, games_cache, translations_cache, stats_cache, times_cache, user_info_cache, ownership_ticket_cache, used_server_cellid):
-    return ProtocolClient(protobuf_client, friends_cache, games_cache, translations_cache, stats_cache, times_cache, user_info_cache, ownership_ticket_cache, used_server_cellid)
+async def client(protobuf_client, friends_cache, games_cache, translations_cache, stats_cache, times_cache, user_info_cache, local_machine_cache, ownership_ticket_cache, used_server_cellid):
+    return ProtocolClient(protobuf_client, friends_cache, games_cache, translations_cache, stats_cache, times_cache, user_info_cache, local_machine_cache, ownership_ticket_cache, used_server_cellid)
 
 
 @pytest.mark.asyncio
diff --git a/tests/test_websocket_client.py b/tests/test_websocket_client.py
index 355cc080..841a6d6f 100644
--- a/tests/test_websocket_client.py
+++ b/tests/test_websocket_client.py
@@ -76,13 +76,17 @@ def translations_cache():
 def user_info_cache(mocker):
     return MagicMock(UserInfoCache)
 
+@pytest.fixture
+def local_machine_cache():
+    return MagicMock()
+
 @pytest.fixture
 def ownership_ticket_cache():
     return MagicMock(OwnershipTicketCache)
 
 @pytest.fixture
-async def client(backend_client, websocket_list, protocol_client, friends_cache, games_cache, translations_cache, stats_cache, times_cache, user_info_cache, ownership_ticket_cache):
-    return WebSocketClient(backend_client, MagicMock(), websocket_list, friends_cache, games_cache, translations_cache, stats_cache, times_cache, user_info_cache, ownership_ticket_cache)
+async def client(backend_client, websocket_list, protocol_client, friends_cache, games_cache, translations_cache, stats_cache, times_cache, user_info_cache, local_machine_cache, ownership_ticket_cache):
+    return WebSocketClient(backend_client, MagicMock(), websocket_list, friends_cache, games_cache, translations_cache, stats_cache, times_cache, user_info_cache, local_machine_cache, ownership_ticket_cache)
 
 
 @pytest.mark.asyncio