public DefineFontNameTag(FlashReader reader, TagRecord header) :
base(reader, header)
{
FontId = reader.ReadUInt16();
FontName = reader.ReadNullTerminatedString();
FontCopyright = reader.ReadNullTerminatedString();
}
protected HGame(FlashReader input)
: base(input)
{
_abcFileTags = new Dictionary <DoABCTag, ABCFile>();
ABCFiles = new List <ABCFile>();
}
public DefineBinaryDataTag(HeaderRecord header, FlashReader input)
: base(header)
{
Id = input.ReadUInt16();
input.ReadUInt32(); // Reserved | Must equal '0'.
Data = input.ReadBytes(header.Length - 6);
}
public SetBackgroundColorTag(HeaderRecord header, FlashReader input)
: base(header)
{
R = input.ReadByte();
G = input.ReadByte();
B = input.ReadByte();
}
private void FlashReader_Click(object sender, EventArgs e)
{
var flashReader = new FlashReader();
flashReader.MdiParent = this;
flashReader.Show();
}
protected void ReplaceNextOperation(FlashReader inCode, FlashWriter outCode, ASMethod method, OPCode oldOP, object[] oldValues, OPCode newOP, object[] newValues)
{
while (inCode.IsDataAvailable)
{
OPCode op = inCode.ReadOP();
object[] values = inCode.ReadValues(op);
if (op != oldOP)
{
outCode.WriteOP(op, values);
continue;
}
if (oldValues != null && (oldValues.Length == values.Length))
{
bool valuesMatch = true;
for (int i = 0; i < oldValues.Length; i++)
{
if (oldValues[i] != null &&
!oldValues[i].Equals(values[i]))
{
valuesMatch = false;
break;
}
}
if (!valuesMatch)
{
outCode.WriteOP(op, values);
continue;
}
}
outCode.WriteOP(newOP, newValues);
WriteLog($"Replaced operation '{oldOP}[{string.Join(", ", oldValues)}]' with '{newOP}[{string.Join(", ", newValues)}]' in method '{method}'.");
break;
}
}
protected ShockwaveFlash(FlashReader input)
: this(false)
{
Compression = (CompressionKind)input.ReadString(3)[0];
Version = input.ReadByte();
FileLength = input.ReadUInt32();
switch (Compression)
{
case CompressionKind.LZMA:
{
byte[] decompressed = LZMA.Decompress(input.BaseStream, ((int)FileLength - 8));
_input = new FlashReader(decompressed);
break;
}
case CompressionKind.ZLIB:
{
_input = ZLIB.WrapDecompressor(input.BaseStream);
break;
}
case CompressionKind.None:
{
_input = input;
break;
}
}
Frame = new FrameRecord(_input);
}
public DefineFontNameTag(HeaderRecord header, FlashReader input)
: base(header)
{
Id = input.ReadUInt16();
Name = input.ReadNullString();
Copyright = input.ReadNullString();
}
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));
}
}
/// <summary>
/// Returns the hardcoded client revision string from the Outgoing[4000] message class.
/// </summary>
/// <returns></returns>
public string GetClientRevision()
{
if (!string.IsNullOrWhiteSpace(_clientRevision))
{
return(_clientRevision);
}
if (!(OutgoingMessages?.ContainsKey(4000) ?? false))
{
return(string.Empty);
}
ASInstance outgoingInstance = OutgoingMessages[4000].Instance;
ASMethod method = outgoingInstance.FindFirstMethod(null, "Array");
if (method == null)
{
return(string.Empty);
}
using (var inCode = new FlashReader(method.Body.Bytecode))
{
object[] values = inCode.ReadValuesUntil(OPCode.PushString);
var pushStringIndex = (int)values[0];
_clientRevision = method.ABC.Constants.Strings[pushStringIndex];
}
return(_clientRevision);
}
public ASInstance(ABCFile abc, FlashReader input)
: this(abc)
{
QNameIndex = input.ReadInt30();
SuperIndex = input.ReadInt30();
Flags = (ClassFlags)input.ReadByte();
if (Flags.HasFlag(ClassFlags.ProtectedNamespace))
{
ProtectedNamespaceIndex = input.ReadInt30();
}
InterfaceIndices.Capacity = input.ReadInt30();
for (int i = 0; i < InterfaceIndices.Capacity; i++)
{
int interfaceIndex = input.ReadInt30();
InterfaceIndices.Add(interfaceIndex);
}
ConstructorIndex = input.ReadInt30();
Constructor.IsConstructor = true;
Constructor.Container = this;
PopulateTraits(input);
}
protected virtual FlashTag ReadTag(FlashReader reader, TagRecord header)
{
FlashTag tag = null;
switch (header.TagType)
{
default:
tag = new UnknownTag(Reader, header);
break;
case FlashTagType.DoABC:
tag = new DoABCTag(Reader, header);
_abcFiles.Add(((DoABCTag)tag).ABC);
break;
case FlashTagType.DefineBitsLossless2:
tag = new DefineBitsLossless2Tag(Reader, header);
break;
case FlashTagType.DefineBinaryData:
tag = new DefineBinaryDataTag(Reader, header);
break;
}
var character = (tag as ICharacter);
if (character != null)
{
// Add ICharacter tag to the global dictionary.
Dictionary.Characters[
character.CharacterId] = character;
}
return(tag);
}
/// <summary>
/// Initializes a new instance of the <see cref="ShockwaveFlash"/> class based on the specified array of bytes.
/// </summary>
/// <param name="data">The data containing the raw Shockwave Flash(SWF) file.</param>
public ShockwaveFlash(byte[] data)
{
_flashData = data;
_abcFiles = new List <ABCFile>();
Reader = new FlashReader(data);
Tags = new List <FlashTag>();
Dictionary = new FlashDictionary();
Signature = Reader.ReadString(3);
CompressWith = (CompressionStandard)Signature[0];
Version = Reader.ReadByte();
FileLength = Reader.ReadUInt32();
if (CompressWith ==
CompressionStandard.None)
{
ReadFrameInformation();
}
else
{
IsCompressed = true;
}
}
public ASMethodBody(ABCFile abc, FlashReader reader)
: this(abc)
{
MethodIndex = reader.Read7BitEncodedInt();
MaxStack = reader.Read7BitEncodedInt();
LocalCount = reader.Read7BitEncodedInt();
InitialScopeDepth = reader.Read7BitEncodedInt();
MaxScopeDepth = reader.Read7BitEncodedInt();
int bytecodeLength = reader.Read7BitEncodedInt();
Bytecode = reader.ReadBytes(bytecodeLength);
Exceptions.Capacity = reader.Read7BitEncodedInt();
for (int i = 0; i < Exceptions.Capacity; i++)
{
Exceptions.Add(new ASException(abc, reader));
}
Traits.Capacity = reader.Read7BitEncodedInt();
for (int i = 0; i < Traits.Capacity; i++)
{
Traits.Add(new ASTrait(abc, reader));
}
Method.Body = this;
}
public DefineBinaryDataTag(FlashReader reader, TagRecord header)
: base(reader, header)
{
CharacterId = reader.ReadUInt16();
reader.ReadUInt32();
BinaryData = reader.ReadBytes(header.Body.Length - 6);
}
public ASClass(ABCFile abc, FlashReader input) : base(abc)
{
ConstructorIndex = input.ReadInt30();
Constructor.IsConstructor = true;
Constructor.Container = this;
PopulateTraits(input);
}
public DebugIns(ABCFile abc, FlashReader input)
: this(abc)
{
DebugType = input.ReadByte();
NameIndex = input.ReadInt30();
RegisterIndex = input.ReadByte();
Extra = input.ReadInt30();
}
public ASException(ABCFile abc, FlashReader input)
: base(abc)
{
From = input.ReadInt30();
To = input.ReadInt30();
Target = input.ReadInt30();
ExceptionTypeIndex = input.ReadInt30();
VariableNameIndex = input.ReadInt30();
}
public SetBackgroundColorTag(HeaderRecord header, FlashReader input)
: base(header)
{
byte r = input.ReadByte();
byte g = input.ReadByte();
byte b = input.ReadByte();
BackgroundColor = Color.FromArgb(r, g, b);
}
public ASException(ABCFile abc, FlashReader reader)
: this(abc)
{
From = reader.Read7BitEncodedInt();
To = reader.Read7BitEncodedInt();
Target = reader.Read7BitEncodedInt();
ExceptionTypeIndex = reader.Read7BitEncodedInt();
VariableNameIndex = reader.Read7BitEncodedInt();
}
public ASNamespaceSet(ABCFile abc, FlashReader reader)
: this(abc)
{
NamespaceIndices.Capacity = reader.Read7BitEncodedInt();
for (int i = 0; i < NamespaceIndices.Capacity; i++)
{
NamespaceIndices.Add(reader.Read7BitEncodedInt());
}
}
/// <summary>
/// Injects the specified public RSA keys into the bytecode that handles the verification of the received primes.
/// </summary>
/// <param name="exponent">The public exponent.</param>
/// <param name="modulus">The public modulus.</param>
public void ReplaceRSAKeys(int exponent, string modulus)
{
ABCFile abc = ABCFiles[2];
ASInstance habboCommDemoInstance = abc.FindFirstInstanceByName("HabboCommunicationDemo");
IEnumerable <MethodGetterSetterTrait> mgsTraits =
habboCommDemoInstance.FindMethodGetterSetterTraits();
ASMethod method = null;
int rsaKeyTypeIndex = abc.Constants.IndexOfMultiname("RSAKey");
foreach (MethodGetterSetterTrait mgsTrait in mgsTraits)
{
if (mgsTrait.Method.ReturnType.Name != "void")
{
continue;
}
if (mgsTrait.Method.Parameters.Count != 1)
{
continue;
}
if (ContainsOperation(mgsTrait.Method, OPCode.GetLex, rsaKeyTypeIndex))
{
method = mgsTrait.Method;
WriteLog($"Found reference to 'RSAKey' in method '{method}'.");
break;
}
}
using (var outCode = new FlashWriter())
using (var inCode = new FlashReader(method.Body.Bytecode))
{
int modulusStringIndex = abc.Constants.AddString(modulus);
int exponentStringIndex = abc.Constants.AddString(exponent.ToString("x")); // Turn the number to hex, remeber guys, (65537= 10001(hex))
int keyObfuscatorTypeIndex = abc.Constants.IndexOfMultiname("KeyObfuscator");
// Replace the first 'GetLex[KeyObfuscator]' operation with 'PushString[modulus]'.
ReplaceNextOperation(inCode, outCode, method,
OPCode.GetLex, new object[] { keyObfuscatorTypeIndex },
OPCode.PushString, new object[] { modulusStringIndex });
// Ignore these operations, do not write.
inCode.ReadValuesUntil(OPCode.CallProperty);
// Replace the second 'GetLex[KeyObfuscator]' operation with 'PushString[exponent]'.
ReplaceNextOperation(inCode, outCode, method,
OPCode.GetLex, new object[] { keyObfuscatorTypeIndex },
OPCode.PushString, new object[] { exponentStringIndex });
// Ignore these operations, do not write.
inCode.ReadValuesUntil(OPCode.CallProperty);
CopyBytecode(inCode, outCode);
method.Body.Bytecode = outCode.ToArray();
}
}
public ASMultiname(ASConstantPool pool, FlashReader input)
: this(pool)
{
Kind = (MultinameKind)input.ReadByte();
switch (Kind)
{
case MultinameKind.QName:
case MultinameKind.QNameA:
{
NamespaceIndex = input.ReadInt30();
NameIndex = input.ReadInt30();
break;
}
case MultinameKind.RTQName:
case MultinameKind.RTQNameA:
{
NameIndex = input.ReadInt30();
break;
}
case MultinameKind.RTQNameL:
case MultinameKind.RTQNameLA:
{
/* No data. */
break;
}
case MultinameKind.Multiname:
case MultinameKind.MultinameA:
{
NameIndex = input.ReadInt30();
NamespaceSetIndex = input.ReadInt30();
break;
}
case MultinameKind.MultinameL:
case MultinameKind.MultinameLA:
{
NamespaceSetIndex = input.ReadInt30();
break;
}
case MultinameKind.TypeName:
{
QNameIndex = input.ReadInt30();
TypeIndices.Capacity = input.ReadInt30();
for (int i = 0; i < TypeIndices.Capacity; i++)
{
int typeIndex = input.ReadInt30();
TypeIndices.Add(typeIndex);
}
break;
}
}
}
public ASTrait(ABCFile abc, FlashReader input)
: this(abc)
{
QNameIndex = input.ReadInt30();
byte bitContainer = input.ReadByte();
Kind = (TraitKind)(bitContainer & 0x0F);
Attributes = (TraitAttributes)(bitContainer >> 4);
Id = input.ReadInt30();
switch (Kind)
{
case TraitKind.Slot:
case TraitKind.Constant:
{
TypeIndex = input.ReadInt30();
ValueIndex = input.ReadInt30();
if (ValueIndex != 0)
{
ValueKind = (ConstantKind)input.ReadByte();
}
break;
}
case TraitKind.Method:
case TraitKind.Getter:
case TraitKind.Setter:
{
MethodIndex = input.ReadInt30();
Method.Trait = this;
break;
}
case TraitKind.Class:
{
ClassIndex = input.ReadInt30();
break;
}
case TraitKind.Function:
{
FunctionIndex = input.ReadInt30();
break;
}
}
if (Attributes.HasFlag(TraitAttributes.Metadata))
{
MetadataIndices.Capacity = input.ReadInt30();
for (int i = 0; i < MetadataIndices.Capacity; i++)
{
int metadatumIndex = input.ReadInt30();
MetadataIndices.Add(metadatumIndex);
}
}
}
public LookUpSwitchIns(FlashReader input)
: this()
{
DefaultOffset = input.ReadUInt24();
CaseOffsets.Capacity = (input.ReadInt30() + 1);
for (int i = 0; i < CaseOffsets.Capacity; i++)
{
CaseOffsets.Add(input.ReadUInt24());
}
}
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 ASNamespace(ASConstantPool pool, FlashReader input)
: base(pool)
{
Kind = (NamespaceKind)input.ReadByte();
if (!Enum.IsDefined(typeof(NamespaceKind), Kind))
{
throw new InvalidCastException($"Invalid namespace kind for value {Kind:0x00}.");
}
NameIndex = input.ReadInt30();
}
public RectangeRecord(FlashReader input)
{
int maxBitCount = input.ReadUB(5);
X = input.ReadSB(maxBitCount);
Width = (input.ReadSB(maxBitCount) / 20);
Y = input.ReadSB(maxBitCount);
Height = (input.ReadSB(maxBitCount) / 20);
}
public ASNamespaceSet(ASConstantPool pool, FlashReader input)
: this(pool)
{
NamespaceIndices.Capacity = input.ReadInt30();
for (int i = 0; i < NamespaceIndices.Capacity; i++)
{
int namespaceIndex = input.ReadInt30();
NamespaceIndices.Add(namespaceIndex);
}
}
public DoABCTag(HeaderRecord header, FlashReader input)
: base(header)
{
Flags = input.ReadUInt32();
Name = input.ReadNullString();
int partialLength = (Encoding.UTF8.GetByteCount(Name) + 5);
ABCData = input.ReadBytes(header.Length - partialLength);
}
