private async void Connected(object sender, ConnectedEventArgs e) { if (InvokeRequired) { Invoke(_connected, sender, e); return; } HMessage remoteEndPointPkt = await Connection.Local.ReceivePacketAsync(); e.HotelServer = ConnectionPg.HotelServer = HotelEndPoint.Parse(remoteEndPointPkt.ReadString().Split('\0')[0], remoteEndPointPkt.ReadInteger()); e.IsFakingPolicyRequest = (e.HotelServer.Hotel == HHotel.Unknown); e.HotelServerSource.SetResult(e.HotelServer); ConnectionPg.IsReceiving = true; Text = $"Tanji ~ Connected[{e.HotelServer}]"; TopMost = PacketLoggerUI.TopMost; PacketLoggerUI.RevisionTxt.Text = ("Revision: " + Game.Revision); PacketLoggerUI.Show(); PacketLoggerUI.WindowState = FormWindowState.Normal; BringToFront(); }
public async Task Start() { _connection = new HConnection(); _connection.Connected += OnConnect; _connection.DataIncoming += OnIncomingData; _connection.DataOutgoing += OnOutgoingData; await _connection.InterceptAsync(HotelEndPoint.Parse(_host, _port)); }
public void HotelEndPoint_ShouldCreateForValidHostname() { const string HOSTNAME = "game-us.habbo.com"; var endpoint = HotelEndPoint.Create(HOSTNAME); Assert.Equal(HOSTNAME, endpoint.Host); Assert.Equal(HHotel.US, endpoint.Hotel); }
private void InterceptConnection() { string[] ports = Program.GameData.InfoPort.Split(','); if (ports.Length == 0 || !ushort.TryParse(ports[0], out ushort port) || !HotelEndPoint.TryParse(Program.GameData.InfoHost, port, out HotelEndPoint endpoint)) { throw new Exception("Failed to parse: " + Program.GameData.InfoPort); } Program.Connection.Intercept(endpoint); }
private void InjectGameClient(object sender, RequestInterceptedEventArgs e) { if (e.Request.RequestUri.Query.StartsWith("?Tanji-")) { Eavesdropper.RequestIntercepted -= InjectGameClient; Uri remoteUrl = e.Request.RequestUri; string clientPath = Path.GetFullPath($"Modified Clients/{remoteUrl.Host}/{remoteUrl.LocalPath}"); if (!string.IsNullOrWhiteSpace(CustomClientPath)) { clientPath = CustomClientPath; } #if !NO_CACHE if (!File.Exists(clientPath)) #else if (true) #endif { Status = INTERCEPTING_CLIENT; Eavesdropper.ResponseIntercepted += InterceptGameClient; } else { Status = DISASSEMBLING_CLIENT; App.Master.Game = new HGame(clientPath); App.Master.Game.Disassemble(); if (App.Master.Game.IsPostShuffle) { Status = GENERATING_MESSAGE_HASHES; App.Master.Game.GenerateMessageHashes(); } if (App.Master.GameData.Hotel == HHotel.Unknown && IsAutomaticServerExtraction) { Tuple <string, int?> endPoint = App.Master.Game.ExtractEndPoint(); if (!string.IsNullOrWhiteSpace(endPoint.Item1) || endPoint.Item2 != null) { string host = (!string.IsNullOrWhiteSpace(endPoint.Item1) ? endPoint.Item1 : HotelServer.Host); HotelServer = HotelEndPoint.Parse(host, endPoint.Item2 ?? HotelServer.Port); } } Status = SYNCHRONIZING_GAME; App.Master.Synchronize(App.Master.Game); TerminateProxy(); InterceptConnection(); e.Request = WebRequest.Create(new Uri(clientPath)); } } }
public async Task HotelEndPoint_ShouldParseValidHostnameAsync() { const string HOSTNAME = "game-us.habbo.com"; const int PORT = 30001; var endpoint = await HotelEndPoint.ParseAsync(HOSTNAME, PORT); Assert.Equal(PORT, endpoint.Port); Assert.Equal(HOSTNAME, endpoint.Host); Assert.Equal(HHotel.US, endpoint.Hotel); }
private void ConnectionOpened(object sender, ConnectedEventArgs e) { HPacket endPointPkt = Connection.Local.ReceivePacketAsync().Result; e.HotelServer = HotelServer = HotelEndPoint.Parse(endPointPkt.ReadUTF8().Split('\0')[0], endPointPkt.ReadInt32()); e.HotelServerSource.SetResult(HotelServer); _ui.SetStatusMessage(Constants.CONNECTED); Invoke((MethodInvoker) delegate { SearchBtn.Enabled = true; Resources.RenderButtonState(SearchBtn, SearchBtn.Enabled); }); }
private void ExtractVariables() { _variables.Clear(); MatchCollection matches = Regex.Matches(Source, FLASH_VAR_PATTERN, RegexOptions.Multiline); foreach (Match match in matches) { string value = match.Groups["value"].Value; string variable = match.Groups["variable"].Value; if (value.Contains("\\/")) { value = value.Replace("\\/", "/"); } _variables[variable] = value; } Hotel = HotelEndPoint.GetHotel(InfoHost); }
public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture) { string address = value.ToString(); string[] points = address.Split(':'); HotelEndPoint endpoint = null; if (points.Length == 2) { string[] ports = points[1].Split(','); if (ports.Length > 0 && ushort.TryParse(ports[0], out ushort port)) { HotelEndPoint.TryParse(points[0], port, out endpoint); } } return(endpoint); }
private void InterceptClientPage(object sender, ResponseInterceptedEventArgs e) { if (!e.Response.ContentType.Contains("text/html")) { return; } string body = Encoding.UTF8.GetString(e.Payload); if (!body.Contains("info.host") && !body.Contains("info.port")) { return; } Eavesdropper.ResponseIntercepted -= InterceptClientPage; App.Master.GameData.Source = body; if (IsAutomaticServerExtraction) { string[] ports = App.Master.GameData.InfoPort.Split(','); if (ports.Length == 0 || !ushort.TryParse(ports[0], out ushort port) || !HotelEndPoint.TryParse(App.Master.GameData.InfoHost, port, out HotelEndPoint endpoint)) { Cancel(null); return; } HotelServer = endpoint; } if (App.Master.GameData.Hotel != HHotel.Unknown) { body = body.Replace(App.Master.GameData.InfoHost, "127.0.0.1"); } body = body.Replace(".swf", $".swf?Tanji-{DateTime.Now.Ticks}"); Status = SYNCHRONIZING_GAME_DATA; App.Master.Synchronize(App.Master.GameData); e.Payload = Encoding.UTF8.GetBytes(body); Status = INJECTING_CLIENT; Eavesdropper.RequestIntercepted += InjectGameClient; }
public override object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture) { string address = value.ToString(); string[] points = address.Split(':'); if (points.Length < 2) { return(null); } ushort port = 0; HotelEndPoint endpoint = null; if (!ushort.TryParse(points[1], out port) || !HotelEndPoint.TryParse(points[0], port, out endpoint)) { return(null); } return(endpoint); }
public async Task InterceptAsync(HotelEndPoint endpoint) { _isIntercepting = true; int interceptCount = 0; while (!IsConnected && _isIntercepting) { try { Local = await HNode.AcceptAsync(endpoint.Port).ConfigureAwait(false); if (!_isIntercepting) { break; } if (++interceptCount == SocketSkip) { interceptCount = 0; continue; } byte[] buffer = await Local.PeekAsync(6).ConfigureAwait(false); if (!_isIntercepting) { break; } if (buffer.Length == 0) { interceptCount--; continue; } Remote = await HNode.ConnectNewAsync(endpoint).ConfigureAwait(false); if (!_isIntercepting) { break; } if (HFormat.WedgieOut.GetId(buffer) == 206) { Local.InFormat = HFormat.WedgieOut; Local.OutFormat = HFormat.WedgieIn; Remote.InFormat = HFormat.WedgieIn; Remote.OutFormat = HFormat.WedgieOut; } else if (HFormat.EvaWire.GetId(buffer) == 4000) { Local.InFormat = HFormat.EvaWire; Local.OutFormat = HFormat.EvaWire; Remote.InFormat = HFormat.EvaWire; Remote.OutFormat = HFormat.EvaWire; } else { buffer = await Local.ReceiveAsync(512).ConfigureAwait(false); await Remote.SendAsync(buffer).ConfigureAwait(false); buffer = await Remote.ReceiveAsync(1024).ConfigureAwait(false); await Local.SendAsync(buffer).ConfigureAwait(false); continue; } if (!_isIntercepting) { break; } IsConnected = true; OnConnected(EventArgs.Empty); _inSteps = 0; _outSteps = 0; Task interceptOutgoingTask = InterceptOutgoingAsync(); Task interceptIncomingTask = InterceptIncomingAsync(); } finally { if (!IsConnected) { Local?.Dispose(); Remote?.Dispose(); } } } HNode.StopListeners(endpoint.Port); _isIntercepting = false; }
public Task InterceptAsync(string host, int port) { return(InterceptAsync(HotelEndPoint.Parse(host, port))); }
public static async Task <HProfile> GetProfileAsync(string uniqueId) => HProfile.Create(await ReadContentAsync <string>(HotelEndPoint.GetHotel(uniqueId).ToUri(), $"/api/public/users/{uniqueId}/profile"));
public virtual void OnConnected(HPacket packet) { HotelServer = HotelEndPoint.Parse(packet.ReadUTF8(), packet.ReadInt32()); ClientVersion = packet.ReadUTF8(); ClientIdentifier = packet.ReadUTF8(); ClientType = packet.ReadUTF8(); try { MessagesInfoIncoming = new List <HMessage>(); MessagesInfoOutgoing = new List <HMessage>(); Out = new Outgoing(new List <HMessage>()); In = new Incoming(new List <HMessage>()); int MessagesInfoLenght = packet.ReadInt32(); foreach (var i in Enumerable.Range(0, MessagesInfoLenght)) { int CurrentMessageID = packet.ReadInt32(); string CurrentMessageHash = packet.ReadUTF8(); string CurrentMessageName = packet.ReadUTF8(); string CurrentMessageStructure = packet.ReadUTF8(); bool CurrentMessageIsOutgoing = packet.ReadBoolean(); string CurrentMessageSource = packet.ReadUTF8(); if (string.IsNullOrWhiteSpace(CurrentMessageHash) || CurrentMessageHash == "NULL") { CurrentMessageHash = CurrentMessageName; } CurrentMessageHash = CurrentMessageSource + "_" + CurrentMessageHash; HMessage CurrentHMessage = new HMessage((ushort)CurrentMessageID, CurrentMessageHash, CurrentMessageName, CurrentMessageStructure); if (CurrentMessageIsOutgoing) { MessagesInfoOutgoing.Add(CurrentHMessage); } else { MessagesInfoIncoming.Add(CurrentHMessage); } } List <HMessage> GeodeOut = new List <HMessage>(); List <HMessage> GeodeIn = new List <HMessage>(); foreach (PropertyInfo GeodeOutProperty in Out.GetType().GetProperties()) { try { if (GeodeOutProperty.PropertyType == typeof(HMessage)) { GeodeOut.Add(MessagesInfoOutgoing.First(x => x.Name == GeodeOutProperty.Name)); } } catch { Console.WriteLine("MessageInfo not found for: " + GeodeOutProperty.Name); } } foreach (PropertyInfo GeodeInProperty in In.GetType().GetProperties()) { try { if (GeodeInProperty.PropertyType == typeof(HMessage)) { GeodeIn.Add(MessagesInfoIncoming.First(x => x.Name == GeodeInProperty.Name)); } } catch { Console.WriteLine("MessageInfo not found for: " + GeodeInProperty.Name); } } Out = new Outgoing(GeodeOut); In = new Incoming(GeodeIn); } catch (Exception ex) { Console.WriteLine("Critical MessagesInfo exception: " + ex.Message); MessagesInfo_Failed = true; } IsConnected = true; if (DisableEventHandlers == false) { try { OnConnectedEvent.Invoke(this, packet); } catch { };//Invoke event handler } }
private void InterceptGameClient(object sender, ResponseInterceptedEventArgs e) { if (!e.Response.ResponseUri.Query.StartsWith("?Tanji-")) { return; } if (e.Response.ContentType != "application/x-shockwave-flash") { return; } Eavesdropper.ResponseIntercepted -= InterceptGameClient; Uri remoteUrl = e.Response.ResponseUri; string clientPath = Path.GetFullPath($"Modified Clients/{remoteUrl.Host}/{remoteUrl.LocalPath}"); string clientDirectory = Path.GetDirectoryName(clientPath); Directory.CreateDirectory(clientDirectory); Status = DISASSEMBLING_CLIENT; App.Master.Game = new HGame(e.Payload); App.Master.Game.Location = clientPath; App.Master.Game.Disassemble(); if (App.Master.Game.IsPostShuffle) { Status = GENERATING_MESSAGE_HASHES; App.Master.Game.GenerateMessageHashes(); Status = MODIFYING_CLIENT; App.Master.Game.DisableHostChecks(); App.Master.Game.InjectKeyShouter(4001); } if (App.Master.GameData.Hotel == HHotel.Unknown) { if (IsAutomaticServerExtraction) { Tuple <string, int?> endPoint = App.Master.Game.ExtractEndPoint(); if (!string.IsNullOrWhiteSpace(endPoint.Item1) || endPoint.Item2 != null) { string host = (!string.IsNullOrWhiteSpace(endPoint.Item1) ? endPoint.Item1 : HotelServer.Host); HotelServer = HotelEndPoint.Parse(host, endPoint.Item2 ?? HotelServer.Port); } } Status = MODIFYING_CLIENT; App.Master.Game.InjectEndPoint("127.0.0.1", HotelServer.Port); } Status = SYNCHRONIZING_GAME; App.Master.Synchronize(App.Master.Game); CompressionKind compression = CompressionKind.ZLIB; #if DEBUG compression = CompressionKind.None; #endif Status = ASSEMBLING_CLIENT; e.Payload = App.Master.Game.ToArray(compression); using (var clientStream = File.Open(clientPath, FileMode.Create, FileAccess.Write)) { clientStream.Write(e.Payload, 0, e.Payload.Length); } TerminateProxy(); InterceptConnection(); }
public async Task InterceptAsync(HotelEndPoint endpoint) { _isIntercepting = true; int interceptCount = 0; while (!IsConnected && _isIntercepting) { try { Local = await HNode.AcceptAsync(ListenPort).ConfigureAwait(false); if (!_isIntercepting) { break; } if (++interceptCount == SocketSkip) { interceptCount = 0; continue; } byte[] buffer = await Local.PeekAsync(6).ConfigureAwait(false); if (!_isIntercepting) { break; } if (buffer.Length == 0) { interceptCount--; continue; } Remote = new HNode(); if (BigEndian.ToUInt16(buffer, 4) != 4000) { buffer = await Local.ReceiveAsync(512).ConfigureAwait(false); if (!_isIntercepting) { break; } if (Encoding.UTF8.GetString(buffer) == CROSS_DOMAIN_POLICY_REQUEST) { await Local.SendAsync(Encoding.UTF8.GetBytes(CROSS_DOMAIN_POLICY_RESPONSE)).ConfigureAwait(false); } else { throw new Exception("Expected cross-domain policy request."); } continue; } var args = new ConnectedEventArgs(endpoint); OnConnected(args); endpoint = (args.HotelServer ?? endpoint); if (args.IsFakingPolicyRequest) { using (var tempRemote = await HNode.ConnectNewAsync(endpoint).ConfigureAwait(false)) { await tempRemote.SendAsync(Encoding.UTF8.GetBytes(CROSS_DOMAIN_POLICY_REQUEST)).ConfigureAwait(false); } } if (!await Remote.ConnectAsync(endpoint).ConfigureAwait(false)) { break; } IsConnected = true; _inSteps = 0; _outSteps = 0; Task interceptOutgoingTask = InterceptOutgoingAsync(); Task interceptIncomingTask = InterceptIncomingAsync(); } finally { if (!IsConnected) { Local?.Dispose(); Remote?.Dispose(); } } } HNode.StopListeners(ListenPort); _isIntercepting = false; }
public override HHotel Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) { return(reader.TokenType == JsonTokenType.String ? HotelEndPoint.GetHotel(reader.GetString()) : HHotel.Unknown); }
public ConnectedEventArgs(HotelEndPoint hotelServer) { HotelServer = hotelServer; HotelServerSource = new TaskCompletionSource <HotelEndPoint>(); }
public override void Write(Utf8JsonWriter writer, HHotel value, JsonSerializerOptions options) { writer.WriteStringValue(HotelEndPoint.GetRegion(value)); }
public static Task <HProfile> GetProfileAsync(string uniqueId) => ReadContentAsync <HProfile>(HotelEndPoint.GetHotel(uniqueId).ToUri(), $"/api/public/users/{uniqueId}/profile");
public ConnectedEventArgs(HotelEndPoint hotelServer) { HotelServer = hotelServer; }
public async Task Start() { await Connection.InterceptAsync(HotelEndPoint.Parse(_host, _port)); }