Example #1
0
            public void DefinePacket(Packet packet, bool isOutGoing)
            {
            //if (packet.DelegateFunction != "_SafeStr_4296")
            //    return;

            if (isOutGoing)
            {
                ParsePreStructure(packet);
                if (!packet.DelegateFunction.StartsWith("_Safe"))
                    return;
            }
            var split1 = GetPositions(packet.DelegateFunction + "):void", _bufferStr);
            var split2 = GetPositions(packet.DelegateFunction + '(', _bufferStr);
            var split3 = GetPositions(packet.DelegateFunction + ';', _bufferStr);

            packet.References = split1.Count + split2.Count + split3.Count - 1;

            foreach (var splitStr in split1)
            {
                var className = GetClassNameByPosition(splitStr);
                if (!string.IsNullOrWhiteSpace(className) &&
                    !className.StartsWith("_SafeStr")) packet.Classes.Add(className);

                var function = GetFunctionByPosition(splitStr);
                ParseVoid(packet, function);
            }

            foreach (var functionPos in split2)
            {
                BasicFunctionParser(packet, functionPos, true);

                packet.FunctionsOrders.Add(string.Join("-",
                    GetFunctionOrderOfClass(functionPos, packet.DelegateFunction)));
            }

            foreach (var splitStr in split3)
            {
                var className = GetClassNameByPosition(splitStr);
                if (!string.IsNullOrWhiteSpace(className) &&
                    !className.StartsWith("_SafeStr")) packet.Classes.Add(className);
            }

            if (isOutGoing)
            {
                List<int> split4 = GetPositions("(k as " + packet.DelegateFunction + ')', _bufferStr);
                List<int> split5 = GetPositions("(event as " + packet.DelegateFunction + ')', _bufferStr);
                List<int> split6 = GetPositions("(k is " + packet.DelegateFunction + ')', _bufferStr);
                List<int> split7 = GetPositions("(event is " + packet.DelegateFunction + ')', _bufferStr);

                packet.References += split4.Count + split5.Count + split6.Count + split7.Count;

                foreach (var functionPos in split4)
                {
                    BasicFunctionParser(packet, functionPos, false);

                    packet.FunctionsOrders.Add(string.Join("-",
                        GetFunctionOrderOfClass(functionPos, "(k as " + packet.DelegateFunction + ')')));
                }

                foreach (var functionPos in split5)
                {
                    BasicFunctionParser(packet, functionPos, false);

                    packet.FunctionsOrders.Add(string.Join("-",
                        GetFunctionOrderOfClass(functionPos, "(event as " + packet.DelegateFunction + ')')));
                }

                foreach (var functionPos in split5)
                {
                    BasicFunctionParser(packet, functionPos, false);

                    packet.FunctionsOrders.Add(string.Join("-",
                        GetFunctionOrderOfClass(functionPos, "(k is " + packet.DelegateFunction + ')')));
                }

                foreach (var functionPos in split6)
                {
                    BasicFunctionParser(packet, functionPos, false);

                    packet.FunctionsOrders.Add(string.Join("-",
                        GetFunctionOrderOfClass(functionPos, "(event is " + packet.DelegateFunction + ')')));
                }
            }

            packet.Sort();

            Console.WriteLine(packet.DelegateFunction + "   " + packet.References + "   " +
                              string.Join(",", packet.Open));
            Console.WriteLine();
            }
Example #2
0
            internal void BasicFunctionParser(Packet packet, int functionPos, bool open)
            {
            var className = GetClassNameByPosition(functionPos);
            if (!string.IsNullOrWhiteSpace(className) &&
                !className.StartsWith("_SafeStr"))
                packet.Classes.Add(className);

            var function = GetNearTopFunctionByPosition(functionPos, _bufferStr);
            if (!string.IsNullOrEmpty(function))
            {
                var nearPacket = new Packet(GetFunctionName(function));
                ParseVoid(nearPacket, function);
                nearPacket.Sort();

                packet.NearTopPacket.Add(nearPacket);
            }
            function = GetNearBottomFunctionByPosition(functionPos, _bufferStr);
            if (!string.IsNullOrEmpty(function))
            {
                var nearPacket = new Packet(GetFunctionName(function));
                ParseVoid(nearPacket, function);
                nearPacket.Sort();

                packet.NearBottomPacket.Add(nearPacket);
            }

            function = GetFunctionByPosition(functionPos);
            ParseVoid(packet, function);

            if (!open) return;

            var inside = RemoveSafeStr(function).Replace(" function ", string.Empty);
            if (!string.IsNullOrWhiteSpace(inside) && !inside.StartsWith("//"))
                packet.Open.Add(inside);
        }
Example #3
0
            private void ParseClassMesage(Packet packet, string className)
            {
            var classPosition = GetPositions("class " + className + " implements", _bufferStr);

            if (classPosition.Count == 0) return;
            var classStr = GetClassByPosition(classPosition[0] + 10);

            #region Readers

            var parsePosition = GetPositions(" parse(", classStr);
            if (!parsePosition.Any()) return;
            var voidStr = GetFunctionByPosition(parsePosition[0], classStr);

            using (var reader = new StringReader(voidStr))
            {
                string line2;
                while ((line2 = reader.ReadLine()) != null)
                {
                    if (line2.Contains(_stringName))
                        packet.Readers.Add("readString()");
                    else if (line2.Contains(_integerName))
                        packet.Readers.Add("readInteger()");
                    else if (line2.Contains(_booleanName))
                        packet.Readers.Add("readBoolean()");
                    else if (line2.Contains(_shortName))
                        packet.Readers.Add("readShort()");
                    else if (line2.Contains(_byteName))
                        packet.Readers.Add("readByte()");
                    else if (line2.Contains(_floatName))
                        packet.Readers.Add("readFloat()");
                    else if (line2.Contains(_doubleName))
                        packet.Readers.Add("readDouble()");
                    else if (line2.Contains(_bytesAvaibleName))
                        packet.Readers.Add("bytesAvailable");
                    else if (line2.Contains(" else"))
                        packet.Readers.Add("else");
                    else if (line2.Contains("if ("))
                        packet.Readers.Add("if");
                    else if (line2.Contains("for ("))
                        packet.Readers.Add("for");
                    else if (line2.Contains("for each ("))
                        packet.Readers.Add("foreach");
                    else if (line2.Contains("while ("))
                        packet.Readers.Add("while");
                    else if (line2.Contains("switch ("))
                        packet.Readers.Add("switch");
                    else if (line2.Contains("case ("))
                        packet.Readers.Add("case");
                    else if (line2.Contains("new "))
                        packet.Readers.Add(
                            RemoveSafeStr(line2.Substring(line2.IndexOf("new ", StringComparison.Ordinal))));
                    else if (line2.Contains(" return"))
                        packet.Readers.Add(
                            RemoveSafeStr(line2.Substring(line2.IndexOf(" return", StringComparison.Ordinal) + 1)));
                }
            }

            #endregion
            }
Example #4
0
        private void ParseVoid(Packet packet, string function)
        {
            packet.ConditionalCount += GetPositions("if", function).Count;
            packet.ConditionalNegativeCount += GetPositions("if (!", function).Count;
            packet.ConditionalElseCount += GetPositions("else", function).Count;
            packet.LocalCount += GetPositions("_local_", function).Count;
            packet.ArgCount += GetPositions("_arg_", function).Count;
            packet.ThisCount += GetPositions("this.", function).Count;
            packet.EventsCount += GetPositions("events.dispatchEvent", function).Count;
            packet.KCount += GetPositions("(k ", function).Count + GetPositions("(k)", function).Count +
                             GetPositions("(k.", function).Count + GetPositions("(k,", function).Count +
                             GetPositions(" k.", function).Count + GetPositions(" k,", function).Count;
            packet.ForCount += GetPositions("for (", function).Count;
            packet.ForeachCount += GetPositions("for each (", function).Count;
            packet.WhileCount += GetPositions("while (", function).Count;
            packet.SwitchCount += GetPositions("switch (", function).Count;
            packet.CaseCount += GetPositions("case ", function).Count;
            packet.DefaultCount += GetPositions("default:", function).Count;
            packet.PointCount += GetPositions("new Point(", function).Count + GetPositions(":Point", function).Count;
            packet.IndexOfCount += GetPositions(".indexOf(", function).Count;
            packet.GetValueCount += GetPositions(".getValue(", function).Count;
            packet.IntegersCount += GetPositions(":int ", function).Count;
            packet.StringsCount += GetPositions(":String ", function).Count;
            packet.BoolsCount += GetPositions(":Boolean ", function).Count;
            packet.ArrayCount += GetPositions("new Array( ", function).Count + GetPositions(":Array ", function).Count;
            packet.NewCount += GetPositions("new ", function).Count;
            packet.SendCount += GetPositions(".send(", function).Count;
            packet.ReturnNull += GetPositions("return;", function).Count;
            packet.ReturnFalse += GetPositions("return (false);", function).Count;
            packet.ReturnTrue += GetPositions("return (true);", function).Count;
            packet.ReturnTotal += GetPositions("return ", function).Count;
            packet.DotsCount += GetPositions(".", function).Count;
            packet.OrCount += GetPositions(" || ", function).Count;
            packet.AndCount += GetPositions(" && ", function).Count;
            packet.NotCount += GetPositions("!", function).Count;
            packet.BitAndCount += GetPositions(" & ", function).Count;
            packet.NullCount += GetPositions(" null", function).Count;
            packet.Equal += GetPositions(" = ", function).Count;
            packet.ComparatorEqual += GetPositions(" == ", function).Count;
            packet.ComparatorNotEqual += GetPositions(" != ", function).Count;
            packet.ComparatorLower += GetPositions(" < ", function).Count;
            packet.ComparatorHigher += GetPositions(" > ", function).Count;
            packet.ComparatorEqualOrLower += GetPositions(" <= ", function).Count;
            packet.ComparatorEqualOrHigher += GetPositions(" >= ", function).Count;
            packet.FalseCount += GetPositions(" = false", function).Count;
            packet.TrueCount += GetPositions(" = true", function).Count;
            packet.RestCount += GetPositions(" - ", function).Count;
            packet.SumCount += GetPositions(" + ", function).Count;
            packet.LengthCount += GetPositions(".length", function).Count;
            packet.AsCount += GetPositions(" as ", function).Count;
            packet.IsCount += GetPositions(" is ", function).Count;
            packet.InCount += GetPositions(" in ", function).Count;

            using (var reader = new StringReader(function))
            {
                string line;
                int lineId = 0;
                while ((line = reader.ReadLine()) != null)
                {
                    if (line.Contains("function " + packet.DelegateFunction + "("))
                    {
                        var voidStr = line.Substring(line.IndexOf("(", StringComparison.Ordinal));
                        voidStr = voidStr.Substring(1, voidStr.IndexOf(")", StringComparison.Ordinal) - 1);

                        if (!string.IsNullOrWhiteSpace(voidStr) && voidStr != "k:Function")
                            packet.Builders.AddRange(voidStr.Split(',').ToList());
                    }
                    if (line.Contains("function "))
                    {
                        var voidName = GetFunctionName(line);

                        if (!voidName.StartsWith("_Safe"))
                            packet.FunctionsNames.Add(voidName);
                    }
                    if (line.Contains(packet.DelegateFunction))
                    {
                        if (line.Contains(".addHabboConnectionMessageEvent")) //line changes
                            packet.Lines.Add(RemoveSafeStr(line));
                        else
                            packet.Lines.Add(lineId + (char) 7 + RemoveSafeStr(line));
                    }

                    if (line.Contains("super("))
                    {
                        if (line.Contains(","))
                            ParseClassMesage(packet,
                                line.Split(',')[1].Replace(");", string.Empty).Replace(" ", string.Empty));

                        var superStr = RemoveSafeStr(line.Replace(" ", string.Empty));
                        if (superStr != "super(k,);" && !packet.Supers.Contains(superStr))
                            packet.Supers.Add(superStr);
                    }

                    lineId++;
                }
            }

            var array = Regex.Matches(function, @"\""(.*?)\""");
            if (array.Count > 0)
            {
                foreach (var txt in array.Cast<Match>().Where(txt => !packet.Strings.Contains(txt.Groups[1].Value)))
                {
                    packet.Strings.Add(txt.Groups[1].Value);
                    function = function.Replace("\"" + txt.Groups[1].Value + "\"", string.Empty);
                }
            }

            var split = function.Split('.', ':');
            foreach (var str in split.Skip(1))
            {
                var call = str.Split(';', ' ', ')', '(')[0];
                if (call.Contains("_SafeStr_") || call.Contains(Environment.NewLine))
                    continue;

                packet.Calls.Add(call);
            }
            }
Example #5
0
        //This is where the fun begins
        void ParseStructure(Packet packet, string structureStr, string classStr, int count = -1)
        {
            count++;
            if (count > 5) // Anti stack overflow.
                return;

            if (string.IsNullOrEmpty(classStr))
            {
                classStr = GetClassByPosition(GetPositions(structureStr, _bufferStr)[0]);
            }

            using (var reader = new StringReader(structureStr))
            {
                string line;
                int lineId = -1;
                while ((line = reader.ReadLine()) != null)
                {
                    lineId++;
                    if (lineId == 0)
                        continue;

                    if (line.IndexOf("k.") != -1)
                    {
                        foreach (var subLine in line.Split(new[] {"k."}, StringSplitOptions.None).Skip(1))
                        {
                            if (subLine.IndexOf(_stringName) != -1)
                                packet.Structure.Add("string");
                            else if (subLine.IndexOf(_integerName) != -1)
                                packet.Structure.Add("int");
                            else if (subLine.IndexOf(_booleanName) != -1)
                                packet.Structure.Add("bool");
                            else if (subLine.IndexOf(_shortName) != -1)
                                packet.Structure.Add("short");
                            else if (subLine.IndexOf(_byteName) != -1)
                                packet.Structure.Add("byte");
                            else if (subLine.IndexOf(_floatName) != -1)
                                packet.Structure.Add("float");
                            else if (subLine.IndexOf(_doubleName) != -1)
                                packet.Structure.Add("double");
                            else if (subLine.IndexOf(_bytesAvaibleName) != -1)
                                packet.Structure.Add("bytesAvaible");
                        }
                    }
                    else if (line.IndexOf("(k)") != -1 || line.IndexOf("(k,") != -1 || line.IndexOf(" k,") != -1 ||
                             line.IndexOf("k)") != -1)
                    {
                        if (line.IndexOf("new ") != -1)
                        {
                            packet.Structure.Add("class");
                            var className = line.Split(new[] {"new "}, StringSplitOptions.None)[1].Split('(')[0];
                            var classStr2 =
                                GetClassByPosition(GetPositions("class " + className + " ", _bufferStr)[0] +
                                                   ("class " + className + " ").Length);

                            ParseStructure(packet, GetFunctionByName(className, classStr2), classStr2, count);
                        }
                        else
                        {
                            packet.Structure.Add("function");
                            var functionName = line.Split('(')[0].Split(' ').Last();

                            if (functionName.IndexOf('.') != -1)
                            {
                                functionName =
                                    functionName.Split(new[] {"(k)", "(k,", " k,", "k)"},
                                        StringSplitOptions.None)[0].Split(' ').Last();
                                if (functionName.IndexOf("(") != -1)
                                    functionName = functionName.Split('(').Last();

                                var isThis = functionName.IndexOf("this.") != -1;
                                functionName = functionName.Replace("this.", string.Empty);

                                if (functionName.IndexOf('.') != -1)
                                {
                                    var functionNames = functionName.Split('.');
                                    if (functionNames.Length > 2)
                                        continue;
                                    functionName = functionNames[1];
                                    var className = functionNames[0];

                                    if (isThis)
                                        className =
                                            classStr.Split(new[] {" " + functionNames[0] + ":"},
                                                StringSplitOptions.None)[1].Split(' ', ';')[0];

                                    var pos = GetPositions("class " + className + " ", _bufferStr);
                                    if (pos.Count == 0)
                                    {
                                        pos = GetPositions("class " + className + '\n', _bufferStr);
                                        if (pos.Count == 0)
                                            continue;
                                    }

                                    var classStr2 =
                                        GetClassByPosition(pos[0] +
                                                           ("class " + className + " ").Length);
                                    ParseStructure(packet, GetFunctionByName(functionName, classStr2), classStr2, count);
                                }
                                else
                                    ParseStructure(packet, GetFunctionByName(functionName, _bufferStr),
                                        string.Empty, count);
                            }
                            else
                            {
                                functionName = functionName.Replace("this.", string.Empty);

                                if (functionName == "super")
                                {
                                    packet.Structure.Add("super");
                                    continue;
                                }

                                ParseStructure(packet, GetFunctionByName(functionName, _bufferStr), classStr, count);
                            }
                        }

                        packet.Structure.Add("end");
                    }
                    else if (line.IndexOf("foreach (") != -1)
                        packet.Structure.Add("foreach");
                    else if (line.IndexOf("if (") != -1)
                        packet.Structure.Add("if");
                }
            }
        }
Example #6
0
        //I have bigger plans for this in AHPU 2.0
        void ParsePreStructure(Packet packet)
        {
            var classStr =
                GetClassByPosition(GetPositions("class " + packet.DelegateFunction + " ", _bufferStr)[0] +
                                   ("class " + packet.DelegateFunction + " ").Length);
            if (classStr.IndexOf(" as ") == -1)
                return;

            var subClassName = classStr.Split(new[] {" as "}, StringSplitOptions.None)[1].Split(')')[0];
            if (!subClassName.StartsWith("_Safe"))
            {
                packet.DelegateFunction = subClassName;
                return;
            }

            classStr =
                GetClassByPosition(GetPositions("class " + subClassName + " ", _bufferStr)[0] +
                                   ("class " + subClassName + " ").Length);
            string structureStr = GetFunctionByName("parse", classStr);

            ParseStructure(packet, structureStr, classStr);
        }
Example #7
0
        private static int GetPoints(Packet oldPacket, Packet newPacket)
        {
            var points = 0;

            if (oldPacket.Classes.Count == 0 && newPacket.Classes.Count == 0) points += 3;
            else if (string.Join(",", oldPacket.Classes) == string.Join(",", newPacket.Classes)) points += 3;

            if (oldPacket.Open.Count == 0 && newPacket.Open.Count == 0) points += 3;
            else if (string.Join(",", oldPacket.Open) == string.Join(",", newPacket.Open)) points += 3;

            if (oldPacket.Strings.Count == 0 && newPacket.Strings.Count == 0) points += 5;
            else if (string.Join(",", oldPacket.Strings) == string.Join(",", newPacket.Strings)) points += 5;

            if (oldPacket.Calls.Count == 0 && newPacket.Calls.Count == 0) points += 3;
            else if (string.Join(",", oldPacket.Calls) == string.Join(",", newPacket.Calls)) points += 3;

            if (oldPacket.Lines.Count == 0 && newPacket.Lines.Count == 0) points += 4;
            else if (string.Join(",", oldPacket.Lines) == string.Join(",", newPacket.Lines)) points += 4;

            if (oldPacket.Supers.Count == 0 && newPacket.Supers.Count == 0) points += 3;
            else if (string.Join(",", oldPacket.Supers) == string.Join(",", newPacket.Supers)) points += 3;

            if (oldPacket.Builders.Count == 0 && newPacket.Builders.Count == 0) points += 5;
            else points += string.Join(",", oldPacket.Builders) == string.Join(",", newPacket.Builders) ? 5 : 0;

            if (oldPacket.Readers.Count == 0 && newPacket.Readers.Count == 0) points += 5;
            else points += string.Join(",", oldPacket.Readers) == string.Join(",", newPacket.Readers) ? 5 : 0;

            if (oldPacket.FunctionsNames.Count == 0 && newPacket.FunctionsNames.Count == 0) points += 7;
            else if (string.Join(",", oldPacket.FunctionsNames) == string.Join(",", newPacket.FunctionsNames)) points += 7;

            if (string.Join(",", oldPacket.FunctionsOrders) == string.Join(",", newPacket.FunctionsOrders)) points += 6;

            if (string.Join(",", oldPacket.Structure) == string.Join(",", newPacket.Structure)) points += 8;
            else if (newPacket.Structure.Count - oldPacket.Structure.Count == 1) points += 6;
            else if (newPacket.Structure.Count - oldPacket.Structure.Count == 2) points += 5;
            else if (newPacket.Structure.Count - oldPacket.Structure.Count == 3) points += 4;
            else if (newPacket.Structure.Count - oldPacket.Structure.Count == 4) points += 3;

            if (oldPacket.ConditionalCount == newPacket.ConditionalCount) points += 4;

            if (oldPacket.ConditionalNegativeCount == newPacket.ConditionalNegativeCount) points += 4;

            if (oldPacket.ConditionalElseCount == newPacket.ConditionalElseCount) points += 4;

            if (oldPacket.KCount == newPacket.KCount) points += 4;

            if (oldPacket.EventsCount == newPacket.EventsCount) points += 4;

            if (oldPacket.ForCount == newPacket.ForCount) points += 4;

            if (oldPacket.ForeachCount == newPacket.ForeachCount) points += 4;

            if (oldPacket.WhileCount == newPacket.WhileCount) points += 4;

            if (oldPacket.SwitchCount == newPacket.SwitchCount) points += 4;

            if (oldPacket.CaseCount == newPacket.CaseCount) points += 4;

            if (oldPacket.DefaultCount == newPacket.DefaultCount) points += 3;

            if (oldPacket.LocalCount == newPacket.LocalCount) points += 4;

            if (oldPacket.ArgCount == newPacket.ArgCount) points += 4;

            if (oldPacket.ThisCount == newPacket.ThisCount) points += 4;

            if (oldPacket.PointCount == newPacket.PointCount) points += 5;

            if (oldPacket.IndexOfCount == newPacket.IndexOfCount) points += 4;

            if (oldPacket.GetValueCount == newPacket.GetValueCount) points += 4;

            if (oldPacket.References == newPacket.References) points += 4;

            if (oldPacket.IntegersCount == newPacket.IntegersCount) points += 4;

            if (oldPacket.StringsCount == newPacket.StringsCount) points += 4;

            if (oldPacket.BoolsCount == newPacket.BoolsCount) points += 4;

            if (oldPacket.ArrayCount == newPacket.ArrayCount) points += 4;

            if (oldPacket.NewCount == newPacket.NewCount) points += 4;

            if (oldPacket.ReturnNull == newPacket.ReturnNull) points += 4;

            if (oldPacket.ReturnFalse == newPacket.ReturnFalse) points += 4;

            if (oldPacket.ReturnTrue == newPacket.ReturnTrue) points += 4;

            if (oldPacket.ReturnTotal == newPacket.ReturnTotal) points += 4;

            if (oldPacket.SendCount == newPacket.SendCount) points += 4;

            if (oldPacket.DotsCount == newPacket.DotsCount) points += 4;

            if (oldPacket.OrCount == newPacket.OrCount) points += 4;

            if (oldPacket.AndCount == newPacket.AndCount) points += 4;

            if (oldPacket.NotCount == newPacket.NotCount) points += 4;

            if (oldPacket.BitAndCount == newPacket.BitAndCount) points += 4;

            if (oldPacket.NullCount == newPacket.NullCount) points += 4;

            if (oldPacket.Equal == newPacket.Equal) points += 4;

            if (oldPacket.ComparatorEqual == newPacket.ComparatorEqual) points += 4;

            if (oldPacket.ComparatorNotEqual == newPacket.ComparatorNotEqual) points += 4;

            if (oldPacket.ComparatorLower == newPacket.ComparatorLower) points += 4;

            if (oldPacket.ComparatorHigher == newPacket.ComparatorHigher) points += 4;

            if (oldPacket.ComparatorEqualOrLower == newPacket.ComparatorEqualOrLower) points += 4;

            if (oldPacket.ComparatorEqualOrHigher == newPacket.ComparatorEqualOrHigher) points += 4;

            if (oldPacket.FalseCount == newPacket.FalseCount) points += 4;

            if (oldPacket.TrueCount == newPacket.TrueCount) points += 4;

            if (oldPacket.RestCount == newPacket.RestCount) points += 4;

            if (oldPacket.SumCount == newPacket.SumCount) points += 4;

            if (oldPacket.LengthCount == newPacket.LengthCount) points += 4;

            if (oldPacket.AsCount == newPacket.RestCount) points += 4;

            if (oldPacket.IsCount == newPacket.SumCount) points += 4;

            if (oldPacket.InCount == newPacket.LengthCount) points += 4;

            return points;
        }