public DefineFontNameTag(FlashReader reader, TagRecord header) : base(reader, header) { FontId = reader.ReadUInt16(); FontName = reader.ReadNullTerminatedString(); FontCopyright = reader.ReadNullTerminatedString(); }
public ASNamespaceSet(ABCFile abc, FlashReader reader) : this(abc) { NamespaceIndices.Capacity = reader.Read7BitEncodedInt(); for (int i = 0; i < NamespaceIndices.Capacity; i++) NamespaceIndices.Add(reader.Read7BitEncodedInt()); }
public DefineBinaryDataTag(FlashReader reader, TagRecord header) : base(reader, header) { CharacterId = reader.ReadUInt16(); reader.ReadUInt32(); BinaryData = reader.ReadBytes(header.Body.Length - 6); }
public ASScript(ABCFile abc, FlashReader reader) : this(abc) { FunctionIndex = reader.Read7BitEncodedInt(); Traits.Capacity = reader.Read7BitEncodedInt(); for (int i = 0; i < Traits.Capacity; i++) Traits.Add(new ASTrait(abc, reader)); }
public ASException(ABCFile abc, FlashReader reader) : this(abc) { From = reader.Read7BitEncodedInt(); To = reader.Read7BitEncodedInt(); Target = reader.Read7BitEncodedInt(); ExceptionTypeIndex = reader.Read7BitEncodedInt(); VariableNameIndex = reader.Read7BitEncodedInt(); }
public Typename(ABCFile abc, FlashReader reader) : this(abc) { TypeIndex = reader.Read7BitEncodedInt(); ParameterTypeIndices.Capacity = reader.Read7BitEncodedInt(); for (int i = 0; i < ParameterTypeIndices.Capacity; i++) ParameterTypeIndices.Add(reader.Read7BitEncodedInt()); }
public SetBackgroundColorTag(FlashReader reader, TagRecord header) : base(reader, header) { byte red = reader.ReadByte(); byte green = reader.ReadByte(); byte blue = reader.ReadByte(); BackgroundColor = Color.FromArgb(red, green, blue); }
public SlotConstantTrait(ABCFile abc, FlashReader reader, TraitType traitType) : this(abc, traitType) { SlotId = reader.Read7BitEncodedInt(); TypeIndex = reader.Read7BitEncodedInt(); ValueIndex = reader.Read7BitEncodedInt(); if (ValueIndex != 0) ValueType = (ConstantType)reader.ReadByte(); }
public ASClass(ABCFile abc, FlashReader reader) : this(abc) { ConstructorIndex = reader.Read7BitEncodedInt(); if (Constructor != null) Constructor.IsConstructor = true; Traits.Capacity = reader.Read7BitEncodedInt(); for (int i = 0; i < Traits.Capacity; i++) Traits.Add(new ASTrait(abc, reader)); }
public DoABCTag(FlashReader reader, TagRecord header) : base(reader, header) { Flags = reader.ReadUInt32(); Name = reader.ReadNullTerminatedString(); int nameLength = (Encoding.UTF8.GetByteCount(Name) + 1); byte[] abcData = reader.ReadBytes(header.Body.Length - (nameLength + 4)); ABC = new ABCFile(abcData); }
public RectangleRecord(FlashReader reader) { int bits = reader.ReadUB(5); X = reader.ReadSB(bits); TwipsWidth = reader.ReadSB(bits); Width = (TwipsWidth / 20); Y = reader.ReadSB(bits); TwipsHeight = reader.ReadSB(bits); Height = (TwipsHeight / 20); }
public ASMetadata(ABCFile abc, FlashReader reader) : this(abc) { ObjNameIndex = reader.Read7BitEncodedInt(); Elements.Capacity = reader.Read7BitEncodedInt(); for (int i = 0; i < Elements.Capacity; i++) { int elementKey = reader.Read7BitEncodedInt(); int elementValue = reader.Read7BitEncodedInt(); Elements.Add(new Tuple<int, int>(elementKey, elementValue)); } }
public ASTrait(ABCFile abc, FlashReader reader) : this(abc) { TypeIndex = reader.Read7BitEncodedInt(); byte trueKind = reader.ReadByte(); var traitType = (TraitType)(trueKind & 0xF); Attributes = (TraitAttributes)(trueKind >> 4); #region Trait Reading switch (traitType) { case TraitType.Slot: case TraitType.Constant: { Data = new SlotConstantTrait(abc, reader, traitType) { ObjName = Type.ObjName }; break; } case TraitType.Method: case TraitType.Getter: case TraitType.Setter: { Data = new MethodGetterSetterTrait(abc, reader, traitType) { ObjName = Type.ObjName }; ((MethodGetterSetterTrait)Data).Method.ObjName = ObjName; break; } case TraitType.Class: { Data = new ClassTrait(abc, reader) { ObjName = Type.ObjName }; break; } case TraitType.Function: { Data = new FunctionTrait(abc, reader) { ObjName = Type.ObjName }; break; } default: throw new Exception($"Invalid {nameof(ASTrait)} type: " + traitType); } #endregion if ((Attributes & TraitAttributes.Metadata) != 0) MetadataIndices.Capacity = reader.Read7BitEncodedInt(); for (int i = 0; i < MetadataIndices.Capacity; i++) MetadataIndices.Add(reader.Read7BitEncodedInt()); }
public ASMultiname(ABCFile abc, FlashReader reader) : this(abc) { var multinameType = (ConstantType)reader.ReadByte(); switch (multinameType) { case ConstantType.QName: case ConstantType.QNameA: { var qName = new QName(abc, reader, multinameType); ObjNameIndex = qName.ObjNameIndex; Data = qName; break; } case ConstantType.RTQName: case ConstantType.RTQNameA: { var rtqName = new RTQName(abc, reader, multinameType); ObjNameIndex = rtqName.ObjNameIndex; Data = rtqName; break; } case ConstantType.RTQNameL: case ConstantType.RTQNameLA: Data = new RTQNameL(abc, multinameType); break; case ConstantType.Multiname: case ConstantType.MultinameA: { var multiname = new Multiname(abc, reader, multinameType); ObjNameIndex = multiname.ObjNameIndex; Data = multiname; break; } case ConstantType.MultinameL: case ConstantType.MultinameLA: Data = new MultinameL(abc, reader, multinameType); break; case ConstantType.Typename: Data = new Typename(abc, reader); break; default: throw new Exception("Invalid multiname: " + multinameType); } }
public bool FindMessageInstances() { if (OutgoingTypes.Count > 0 && IncomingTypes.Count > 0) return true; ABCFile abc = ABCFiles[2]; ASClass habboMessages = abc.FindClassByName("HabboMessages"); if (habboMessages == null || habboMessages.Traits.Count < 2) return false; ASTrait incomingMap = habboMessages.Traits[0]; ASTrait outgoingMap = habboMessages.Traits[1]; using (var mapReader = new FlashReader( habboMessages.Constructor.Body.Bytecode.ToArray())) { while (mapReader.Position != mapReader.Length) { OPCode op = mapReader.ReadOP(); if (op != OPCode.GetLex) continue; int mapTypeIndex = mapReader.Read7BitEncodedInt(); bool isOutgoing = (mapTypeIndex == outgoingMap.TypeIndex); bool isIncoming = (mapTypeIndex == incomingMap.TypeIndex); if (!isOutgoing && !isIncoming) continue; op = mapReader.ReadOP(); if (op != OPCode.PushShort && op != OPCode.PushByte) continue; ushort header = 0; if (op == OPCode.PushByte) { header = mapReader.ReadByte(); } else header = (ushort)mapReader.Read7BitEncodedInt(); op = mapReader.ReadOP(); if (op != OPCode.GetLex) continue; int messageTypeIndex = mapReader.Read7BitEncodedInt(); ASMultiname messageType = abc.Constants.Multinames[messageTypeIndex]; ASClass messageInstance = abc.FindClassByName(messageType.ObjName); if (isOutgoing) OutgoingTypes[header] = messageInstance; else if (isIncoming) IncomingTypes[header] = messageInstance; } } return (OutgoingTypes.Count > 0 && IncomingTypes.Count > 0); }
public ProductInfoTag(FlashReader reader, TagRecord header) : base(reader, header) { ProductId = (FlashProductId)reader.ReadUInt32(); Edition = (FlashEdition)reader.ReadUInt32(); MajorVersion = reader.ReadByte(); MinorVersion = reader.ReadByte(); BuildLow = reader.ReadUInt32(); BuildHigh = reader.ReadUInt32(); CompilationDate = _epoch.AddMilliseconds(reader.ReadUInt64()); }
public TagRecord(FlashReader reader) { Start = reader.Position; ushort header = reader.ReadUInt16(); TagType = (FlashTagType)(header >> 6); int length = (header & 63); if (length >= 63) { length = reader.ReadInt32(); IsSpecialLong = (length < 63); } BodyStart = reader.Position; Body = reader.ReadBytes(length); reader.Position = BodyStart; }
public SymbolClassTag(FlashReader reader, TagRecord header) : base(reader, header) { int symbolCount = reader.ReadUInt16(); Symbols = new Dictionary<ushort, string>(symbolCount); for (int i = 0; i < symbolCount; i++) { ushort characterId = reader.ReadUInt16(); string symbolName = reader.ReadNullTerminatedString(); if (Symbols.ContainsKey(characterId)) { symbolName = $"{Symbols[characterId]},{symbolName}"; } Symbols[characterId] = symbolName; } }
public ExportAssetsTag(FlashReader reader, TagRecord header) : base(reader, header) { int count = reader.ReadUInt16(); Assets = new Dictionary<ushort, string>(count); for (int i = 0; i < count; i++) { ushort tag = reader.ReadUInt16(); string name = reader.ReadNullTerminatedString(); if (Assets.ContainsKey(tag)) { throw new Exception( "Duplicate tag id: " + tag); } Assets[tag] = name; } }
public ASInstance(ABCFile abc, FlashReader reader) : this(abc) { TypeIndex = reader.Read7BitEncodedInt(); SuperTypeIndex = reader.Read7BitEncodedInt(); ClassInfo = (ClassFlags)reader.ReadByte(); if ((ClassInfo & ClassFlags.ProtectedNamespace) != 0) ProtectedNamespaceIndex = reader.Read7BitEncodedInt(); InterfaceIndices.Capacity = reader.Read7BitEncodedInt(); for (int i = 0; i < InterfaceIndices.Capacity; i++) InterfaceIndices.Add(reader.Read7BitEncodedInt()); ConstructorIndex = reader.Read7BitEncodedInt(); if (Constructor != null) Constructor.IsConstructor = true; Traits.Capacity = reader.Read7BitEncodedInt(); for (int i = 0; i < Traits.Capacity; i++) Traits.Add(new ASTrait(abc, reader)); }
public ASMethod(ABCFile abc, FlashReader reader) : this(abc) { Parameters.Capacity = reader.Read7BitEncodedInt(); ReturnTypeIndex = reader.Read7BitEncodedInt(); for (int i = 0; i < Parameters.Capacity; i++) { int parameterTypeIndex = reader.Read7BitEncodedInt(); var parameter = new ASParameter(abc, parameterTypeIndex); Parameters.Add(parameter); parameter.Rank = Parameters.Count; } NameIndex = reader.Read7BitEncodedInt(); MethodInfo = (MethodFlags)reader.ReadByte(); if (MethodInfo.HasFlag(MethodFlags.HasOptional)) { int optionalParamCount = reader.Read7BitEncodedInt(); while (optionalParamCount > 0) { int paramIndex = ((Parameters.Count - 1) - (--optionalParamCount)); ASParameter optionalParameter = Parameters[paramIndex]; optionalParameter.IsOptional = true; optionalParameter.ValueIndex = reader.Read7BitEncodedInt(); optionalParameter.ValueType = (ConstantType)reader.ReadByte(); } } if (MethodInfo.HasFlag(MethodFlags.HasParamNames)) { foreach (ASParameter parameter in Parameters) parameter.ObjNameIndex = reader.Read7BitEncodedInt(); } }
public DefineBitsLossless2Tag(FlashReader reader, TagRecord header) : base(reader, header) { CharacterId = reader.ReadUInt16(); BitmapFormat = reader.ReadByte(); BitmapWidth = reader.ReadUInt16(); BitmapHeight = reader.ReadUInt16(); _isCompressed = true; switch (BitmapFormat - 3) { case 0: break; case 1: case 2: { _compressedBitmapData = reader.ReadBytes(header.Body.Length - 7); break; } } }
public ABCFile(FlashReader reader) { _reader = reader; MinorVersion = _reader.ReadUInt16(); MajorVersion = _reader.ReadUInt16(); Constants = new ASConstants(this, _reader); Constants.ReadConstants(); Methods = new List<ASMethod>(_reader.Read7BitEncodedInt()); for (int i = 0; i < Methods.Capacity; i++) Methods.Add(new ASMethod(this, _reader)); Metadata = new List<ASMetadata>(_reader.Read7BitEncodedInt()); for (int i = 0; i < Metadata.Capacity; i++) Metadata.Add(new ASMetadata(this, _reader)); Instances = new List<ASInstance>(_reader.Read7BitEncodedInt()); for (int i = 0; i < Instances.Capacity; i++) Instances.Add(new ASInstance(this, _reader)); Classes = new List<ASClass>(Instances.Capacity); for (int i = 0; i < Classes.Capacity; i++) { Classes.Add(new ASClass(this, _reader)); Classes[i].Instance = Instances[i]; } Scripts = new List<ASScript>(_reader.Read7BitEncodedInt()); for (int i = 0; i < Scripts.Capacity; i++) Scripts.Add(new ASScript(this, _reader)); MethodBodies = new List<ASMethodBody>(_reader.Read7BitEncodedInt()); for (int i = 0; i < MethodBodies.Capacity; i++) MethodBodies.Add(new ASMethodBody(this, _reader)); }
public ASClass GetIncomingParser(ASInstance incomingInstance) { if (_incomingParsersCache.ContainsKey(incomingInstance)) return _incomingParsersCache[incomingInstance]; ASClass parserClass = null; ABCFile abc = incomingInstance.ABC; try { using (var codeOut = new FlashReader( incomingInstance.Constructor.Body.Bytecode)) { while (codeOut.IsDataAvailable) { OPCode op = codeOut.ReadOP(); object[] values = codeOut.ReadValues(op); if (op != OPCode.GetLex) continue; var getLexIndex = (int)values[0]; ASMultiname getLexName = abc.Constants.Multinames[getLexIndex]; parserClass = abc.FindClassByName(getLexName.ObjName); if (parserClass != null) return parserClass; break; } } ASInstance incomingSuperInstance = abc.FindInstanceByName( incomingInstance.SuperType.ObjName); ASMultiname parserReturnType = incomingSuperInstance .FindGetter("parser").Method.ReturnType; SlotConstantTrait parserSlot = incomingSuperInstance .FindSlot("*", parserReturnType.ObjName); foreach (ASTrait trait in incomingInstance.Traits) { if (trait.TraitType != TraitType.Method) continue; var mgsTrait = (MethodGetterSetterTrait)trait.Data; if (mgsTrait.Method.Parameters.Count != 0) continue; using (var codeOut = new FlashReader( mgsTrait.Method.Body.Bytecode)) { while (codeOut.IsDataAvailable) { OPCode op = codeOut.ReadOP(); object[] values = codeOut.ReadValues(op); if (op != OPCode.GetLex) continue; var getLexIndex = (int)values[0]; ASMultiname getLexType = abc.Constants.Multinames[getLexIndex]; if (getLexType.ObjName != parserSlot.ObjName) continue; parserClass = abc.FindClassByName(mgsTrait.Method.ReturnType.ObjName); if (parserClass != null) return parserClass; break; } } } return parserClass; } finally { if (parserClass != null) _incomingParsersCache[incomingInstance] = parserClass; } }
protected void RemoveDeadFalseConditions(ASMethodBody body) { using (var inCode = new FlashReader(body.Bytecode)) using (var outCode = new FlashWriter(inCode.Length)) { while (inCode.Position != inCode.Length) { OPCode op = inCode.ReadOP(); if (op != OPCode.PushFalse) { outCode.WriteOP(op); continue; } op = inCode.ReadOP(); if (op != OPCode.PushFalse) { outCode.WriteOP(OPCode.PushFalse); outCode.WriteOP(op); continue; } op = inCode.ReadOP(); if (op != OPCode.IfNe) { outCode.WriteOP(OPCode.PushFalse); outCode.WriteOP(OPCode.PushFalse); outCode.WriteOP(op); continue; } else inCode.ReadS24(); } body.Bytecode = outCode.ToArray(); } }
public RTQName(ABCFile abc, FlashReader reader, ConstantType multinameType) : this(abc, multinameType) { ObjNameIndex = reader.Read7BitEncodedInt(); }
public RTQName(ABCFile abc, FlashReader reader) : this(abc, reader, ConstantType.RTQName) { }
protected ASMethod FindVerifyMethod(ASInstance instance, ABCFile abc, out int rsaStart) { List<MethodGetterSetterTrait> methodTraits = instance.FindTraits<MethodGetterSetterTrait>(TraitType.Method); rsaStart = -1; foreach (MethodGetterSetterTrait mgsTrait in methodTraits) { ASMethod method = mgsTrait.Method; if (method.ReturnType.ObjName != "void") continue; if (method.Parameters.Count != 1) continue; using (var code = new FlashReader(method.Body.Bytecode)) { while (code.Position != code.Length) { OPCode op = code.ReadOP(); if (op != OPCode.GetLex) continue; int typeIndex = code.Read7BitEncodedInt(); ASMultiname type = abc.Constants.Multinames[typeIndex]; if (type?.ObjName == "RSAKey") { rsaStart = code.Position; return method; } } } } return null; }
public bool BypassRemoteHostCheck() { ABCFile abc = ABCFiles[2]; ASInstance commManager = abc.FindInstanceByName("HabboCommunicationManager"); if (commManager == null) return false; // The "host" value is always the first slot, for now. string hostValueSlotName = commManager.FindTraits<SlotConstantTrait>(TraitType.Slot) .Where(t => t.Type.ObjName == "String").ToArray()[0].ObjName; ASMethod initComponent = commManager.FindMethod("initComponent", "void").Method; if (initComponent == null) return false; using (var inCode = new FlashReader(initComponent.Body.Bytecode)) using (var outCode = new FlashWriter(inCode.Length)) { int hostSlotIndex = abc.Constants.IndexOfMultiname(hostValueSlotName); while (inCode.Position != inCode.Length) { OPCode op = inCode.ReadOP(); outCode.WriteOP(op); if (op != OPCode.GetLocal_0) continue; op = inCode.ReadOP(); outCode.WriteOP(op); if (op != OPCode.CallPropVoid) continue; int callPropVoidIndex = inCode.Read7BitEncodedInt(); outCode.Write7BitEncodedInt(callPropVoidIndex); int callPropVoidArgCount = inCode.Read7BitEncodedInt(); outCode.Write7BitEncodedInt(callPropVoidArgCount); if (callPropVoidArgCount != 0) continue; int getPropertyNameIndex = abc.Constants .IndexOfMultiname("getProperty"); outCode.WriteOP(OPCode.GetLocal_0); outCode.WriteOP(OPCode.FindPropStrict); outCode.Write7BitEncodedInt(getPropertyNameIndex); outCode.WriteOP(OPCode.PushString); outCode.Write7BitEncodedInt(abc.Constants.AddString("connection.info.host")); outCode.WriteOP(OPCode.CallProperty); outCode.Write7BitEncodedInt(getPropertyNameIndex); outCode.Write7BitEncodedInt(1); outCode.WriteOP(OPCode.InitProperty); outCode.Write7BitEncodedInt(hostSlotIndex); outCode.Write(inCode.ToArray(), inCode.Position, inCode.Length - inCode.Position); do op = inCode.ReadOP(); while (op != OPCode.CallPropVoid); callPropVoidIndex = inCode.Read7BitEncodedInt(); ASMultiname callPropVoidName = abc.Constants.Multinames[callPropVoidIndex]; ASMethod connectMethod = commManager.FindMethod(callPropVoidName.ObjName, "void").Method; RemoveHostSuffix(abc, connectMethod); initComponent.Body.Bytecode = outCode.ToArray(); return true; } } return false; }
public ScriptLimitsTag(FlashReader reader, TagRecord header) : base(reader, header) { MaxRecursionDepth = reader.ReadUInt16(); ScriptTimeoutSeconds = reader.ReadUInt16(); }