public byte[] ToByteArray()
{
using (var asInstance = new FlashWriter())
{
asInstance.Write7BitEncodedInt(TypeIndex);
asInstance.Write7BitEncodedInt(SuperTypeIndex);
asInstance.Write7BitEncodedInt((byte)ClassInfo);
if ((ClassInfo & ClassFlags.ProtectedNamespace) != 0)
{
asInstance.Write7BitEncodedInt(ProtectedNamespaceIndex);
}
asInstance.Write7BitEncodedInt(InterfaceIndices.Count);
foreach (int index in InterfaceIndices)
{
asInstance.Write7BitEncodedInt(index);
}
asInstance.Write7BitEncodedInt(ConstructorIndex);
asInstance.Write7BitEncodedInt(Traits.Count);
foreach (ASTrait trait in Traits)
{
asInstance.Write(trait.ToByteArray());
}
return(asInstance.ToArray());
}
}
public byte[] ToByteArray()
{
using (var asMethodBody = new FlashWriter())
{
asMethodBody.Write7BitEncodedInt(MethodIndex);
asMethodBody.Write7BitEncodedInt(MaxStack);
asMethodBody.Write7BitEncodedInt(LocalCount);
asMethodBody.Write7BitEncodedInt(InitialScopeDepth);
asMethodBody.Write7BitEncodedInt(MaxScopeDepth);
asMethodBody.Write7BitEncodedInt(Bytecode.Length);
asMethodBody.Write(Bytecode);
asMethodBody.Write7BitEncodedInt(Exceptions.Count);
foreach (ASException exception in Exceptions)
{
asMethodBody.Write(exception.ToByteArray());
}
asMethodBody.Write7BitEncodedInt(Traits.Count);
foreach (ASTrait trait in Traits)
{
asMethodBody.Write(trait.ToByteArray());
}
return(asMethodBody.ToArray());
}
}
public byte[] ToByteArray()
{
using (var rtqName = new FlashWriter())
{
rtqName.Write7BitEncodedInt(ObjNameIndex);
return(rtqName.ToArray());
}
}
public byte[] ToByteArray()
{
using (var multinameL = new FlashWriter())
{
multinameL.Write7BitEncodedInt(NamespaceSetIndex);
return(multinameL.ToArray());
}
}
/// <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 byte[] ToByteArray()
{
using (var trait = new FlashWriter())
{
trait.Write7BitEncodedInt(SlotId);
trait.Write7BitEncodedInt(FunctionIndex);
return(trait.ToArray());
}
}
public byte[] ToByteArray()
{
using (var asNamespace = new FlashWriter())
{
asNamespace.Write((byte)NamespaceType);
asNamespace.Write7BitEncodedInt(ObjNameIndex);
return(asNamespace.ToArray());
}
}
public byte[] ToByteArray()
{
using (var asMultiname = new FlashWriter())
{
asMultiname.Write((byte)MultinameType);
asMultiname.Write(Data.ToByteArray());
return(asMultiname.ToArray());
}
}
public byte[] ToByteArray()
{
using (var trait = new FlashWriter())
{
trait.Write7BitEncodedInt(DispId);
trait.Write7BitEncodedInt(MethodIndex);
return(trait.ToArray());
}
}
protected override byte[] OnConstruct()
{
using (var tag = new FlashWriter(4))
{
tag.Write(MaxRecursionDepth);
tag.Write(ScriptTimeoutSeconds);
return(tag.ToArray());
}
}
protected override byte[] OnConstruct()
{
using (var tag = new FlashWriter())
{
tag.Write(FontId);
tag.WriteNullTerminatedString(FontName);
tag.WriteNullTerminatedString(FontCopyright);
return(tag.ToArray());
}
}
protected override byte[] OnConstruct()
{
using (var tag = new FlashWriter())
{
tag.Write(Flags);
tag.WriteNullTerminatedString(Name);
tag.Write(ABC.ToByteArray());
return(tag.ToArray());
}
}
protected void ReplaceNextOperation(ASMethod method, OPCode oldOP, object[] oldValues, OPCode newOP, object[] newValues)
{
using (var outCode = new FlashWriter())
using (var inCode = new FlashReader(method.Body.Bytecode))
{
ReplaceNextOperation(inCode, outCode, method, oldOP, oldValues, newOP, newValues);
CopyBytecode(inCode, outCode);
method.Body.Bytecode = outCode.ToArray();
}
}
public byte[] ToByteArray()
{
using (var asException = new FlashWriter())
{
asException.Write7BitEncodedInt(From);
asException.Write7BitEncodedInt(To);
asException.Write7BitEncodedInt(Target);
asException.Write7BitEncodedInt(ExceptionTypeIndex);
asException.Write7BitEncodedInt(VariableNameIndex);
return(asException.ToArray());
}
}
protected override byte[] OnConstruct()
{
using (var tag =
new FlashWriter(6 + BinaryData.Length))
{
tag.Write(CharacterId);
tag.Position += 4;
tag.Write(BinaryData);
return(tag.ToArray());
}
}
protected override byte[] OnConstruct()
{
using (var tag = new FlashWriter())
{
tag.Write((ushort)Assets.Count);
foreach (KeyValuePair <ushort, string> pair in Assets)
{
tag.Write(pair.Key);
tag.WriteNullTerminatedString(pair.Value);
}
return(tag.ToArray());
}
}
public byte[] ToByteArray()
{
using (var asMetadata = new FlashWriter())
{
asMetadata.Write7BitEncodedInt(ObjNameIndex);
asMetadata.Write7BitEncodedInt(Elements.Count);
foreach (Tuple <int, int> element in Elements)
{
asMetadata.Write7BitEncodedInt(element.Item1);
asMetadata.Write7BitEncodedInt(element.Item2);
}
return(asMetadata.ToArray());
}
}
public byte[] ToByteArray()
{
using (var asNamespaceSet = new FlashWriter())
{
asNamespaceSet.Write7BitEncodedInt(NamespaceIndices.Count);
foreach (int namespaceIndex in NamespaceIndices)
{
asNamespaceSet.Write7BitEncodedInt(namespaceIndex);
}
return(asNamespaceSet.ToArray());
}
}
public byte[] ToByteArray()
{
using (var asMethod = new FlashWriter())
{
asMethod.Write7BitEncodedInt(Parameters.Count);
asMethod.Write7BitEncodedInt(ReturnTypeIndex);
foreach (ASParameter parameter in Parameters)
{
asMethod.Write7BitEncodedInt(parameter.TypeIndex);
}
asMethod.Write7BitEncodedInt(NameIndex);
asMethod.Write7BitEncodedInt((byte)MethodInfo);
if ((MethodInfo & MethodFlags.HasOptional) != 0)
{
int optionalParamCount = 0;
byte[] optionalParamData = null;
using (var opParam = new FlashWriter())
{
for (int i = 0; i < Parameters.Count; i++)
{
if (!Parameters[i].IsOptional)
{
continue;
}
optionalParamCount++;
opParam.Write7BitEncodedInt(Parameters[i].ValueIndex);
opParam.Write((byte)Parameters[i].ValueType);
}
optionalParamData = opParam.ToArray();
}
asMethod.Write7BitEncodedInt(optionalParamCount);
asMethod.Write(optionalParamData);
}
if ((MethodInfo & MethodFlags.HasParamNames) != 0)
{
foreach (ASParameter parameter in Parameters)
{
asMethod.Write7BitEncodedInt(parameter.ObjNameIndex);
}
}
return(asMethod.ToArray());
}
}
public byte[] ToByteArray()
{
using (var asConstants = new FlashWriter())
{
asConstants.Write7BitEncodedInt(_integers.Count);
for (int i = 1; i < _integers.Count; i++)
{
asConstants.Write7BitEncodedInt(_integers[i]);
}
asConstants.Write7BitEncodedInt(_uintegers.Count);
for (int i = 1; i < _uintegers.Count; i++)
{
asConstants.Write7BitEncodedInt((int)_uintegers[i]);
}
asConstants.Write7BitEncodedInt(_doubles.Count);
for (int i = 1; i < _doubles.Count; i++)
{
asConstants.Write(_doubles[i]);
}
asConstants.Write7BitEncodedInt(_strings.Count);
for (int i = 1; i < _strings.Count; i++)
{
asConstants.Write(_strings[i]);
}
asConstants.Write7BitEncodedInt(_namespaces.Count);
for (int i = 1; i < _namespaces.Count; i++)
{
asConstants.Write(_namespaces[i].ToByteArray());
}
asConstants.Write7BitEncodedInt(_namespaceSets.Count);
for (int i = 1; i < _namespaceSets.Count; i++)
{
asConstants.Write(_namespaceSets[i].ToByteArray());
}
asConstants.Write7BitEncodedInt(_multinames.Count);
for (int i = 1; i < _multinames.Count; i++)
{
asConstants.Write(_multinames[i].ToByteArray());
}
return(asConstants.ToArray());
}
}
public byte[] ToByteArray()
{
using (var typename = new FlashWriter())
{
typename.Write7BitEncodedInt(TypeIndex);
typename.Write7BitEncodedInt(ParameterTypeIndices.Count);
foreach (int multinameParameterIndex in ParameterTypeIndices)
{
typename.Write7BitEncodedInt(multinameParameterIndex);
}
return(typename.ToArray());
}
}
public byte[] ToByteArray()
{
using (var asClass = new FlashWriter())
{
asClass.Write7BitEncodedInt(ConstructorIndex);
asClass.Write7BitEncodedInt(Traits.Count);
foreach (ASTrait trait in Traits)
{
asClass.Write(trait.ToByteArray());
}
return(asClass.ToArray());
}
}
public byte[] ToByteArray()
{
using (var asScript = new FlashWriter())
{
asScript.Write7BitEncodedInt(FunctionIndex);
asScript.Write7BitEncodedInt(Traits.Count);
foreach (ASTrait trait in Traits)
{
asScript.Write(trait.ToByteArray());
}
return(asScript.ToArray());
}
}
public byte[] ToByteArray()
{
using (var trait = new FlashWriter())
{
trait.Write7BitEncodedInt(SlotId);
trait.Write7BitEncodedInt(TypeIndex);
trait.Write7BitEncodedInt(ValueIndex);
if (ValueIndex != 0)
{
trait.Write((byte)ValueType);
}
return(trait.ToArray());
}
}
protected void RemoveHostSuffix(ABCFile abc, ASMethod connectMethod)
{
using (var inCode = new FlashReader(connectMethod.Body.Bytecode))
using (var outCode = new FlashWriter(inCode.Length))
{
int ifNeCount = 0;
while (inCode.Position != inCode.Length)
{
OPCode op = inCode.ReadOP();
outCode.WriteOP(op);
if (op == OPCode.IfNe && ++ifNeCount == 2)
{
var iFNeJumpCount = (int)inCode.ReadS24();
outCode.WriteS24(iFNeJumpCount + 6);
continue;
}
else if (op != OPCode.PushInt)
{
continue;
}
int pushIntIndex = inCode.Read7BitEncodedInt();
int integerValue = abc.Constants.Integers[pushIntIndex];
switch (integerValue)
{
case 65244:
case 65185:
case 65191:
case 65189:
case 65188:
case 65174:
case 65238:
case 65184:
case 65171:
case 65172:
{
pushIntIndex = abc.Constants.AddInteger(65290);
break;
}
}
outCode.Write7BitEncodedInt(pushIntIndex);
}
connectMethod.Body.Bytecode = outCode.ToArray();
}
RemoveDeadFalseConditions(connectMethod.Body);
}
public byte[] ToByteArray()
{
using (var abcFile = new FlashWriter())
{
abcFile.Write(MinorVersion);
abcFile.Write(MajorVersion);
abcFile.Write(Constants.ToByteArray());
abcFile.Write7BitEncodedInt(Methods.Count);
foreach (ASMethod methodInfo in Methods)
{
abcFile.Write(methodInfo.ToByteArray());
}
abcFile.Write7BitEncodedInt(Metadata.Count);
foreach (ASMetadata metadataInfo in Metadata)
{
abcFile.Write(metadataInfo.ToByteArray());
}
abcFile.Write7BitEncodedInt(Instances.Count);
foreach (ASInstance instanceInfo in Instances)
{
abcFile.Write(instanceInfo.ToByteArray());
}
foreach (ASClass classInfo in Classes)
{
abcFile.Write(classInfo.ToByteArray());
}
abcFile.Write7BitEncodedInt(Scripts.Count);
foreach (ASScript scriptInfo in Scripts)
{
abcFile.Write(scriptInfo.ToByteArray());
}
abcFile.Write7BitEncodedInt(MethodBodies.Count);
foreach (ASMethodBody methodBodyInfo in MethodBodies)
{
abcFile.Write(methodBodyInfo.ToByteArray());
}
return(abcFile.ToArray());
}
}
protected override byte[] OnConstruct()
{
using (var tag = new FlashWriter(26))
{
tag.Write((uint)ProductId);
tag.Write((uint)Edition);
tag.Write(MajorVersion);
tag.Write(MinorVersion);
tag.Write(BuildLow);
tag.Write(BuildHigh);
tag.Write((ulong)(
(CompilationDate - _epoch).TotalMilliseconds));
return(tag.ToArray());
}
}
protected override byte[] OnConstruct()
{
if (_compressedBitmapData == null)
{
_compressedBitmapData =
ZlibStream.CompressBuffer(_bitmapData);
}
using (var tag =
new FlashWriter(7 + _compressedBitmapData.Length))
{
tag.Write(CharacterId);
tag.Write(BitmapFormat);
tag.Write(BitmapWidth);
tag.Write(BitmapHeight);
tag.Write(_compressedBitmapData);
return(tag.ToArray());
}
}
public bool DisableExpirationDateCheck()
{
ABCFile abc = ABCFiles[2];
ASInstance windowContext = abc.FindInstanceByName("WindowContext");
if (windowContext == null)
{
return(false);
}
using (var inCode = new FlashReader(windowContext.Constructor.Body.Bytecode))
using (var outCode = new FlashWriter())
{
int setLocal11Itterations = 0;
while (inCode.Position != inCode.Length)
{
OPCode op = inCode.ReadOP();
outCode.WriteOP(op);
if (op != OPCode.SetLocal)
{
continue;
}
int setLocalIndex = inCode.Read7BitEncodedInt();
outCode.Write7BitEncodedInt(setLocalIndex);
if (setLocalIndex != 11 || (++setLocal11Itterations != 2))
{
continue;
}
outCode.WriteOP(OPCode.ReturnVoid);
outCode.Write(inCode.ToArray(), inCode.Position,
inCode.Length - inCode.Position);
windowContext.Constructor.Body.Bytecode = outCode.ToArray();
return(true);
}
}
return(false);
}
protected override byte[] OnConstruct()
{
using (var tag = new FlashWriter())
{
tag.Position = 2;
ushort symbolCount = 0;
foreach (KeyValuePair <ushort, string> symbol in Symbols)
{
string[] symbolNames = symbol.Value.Split(',');
foreach (string symbolName in symbolNames)
{
symbolCount++;
tag.Write(symbol.Key);
tag.WriteNullTerminatedString(symbol.Value);
}
}
tag.Position = 0;
tag.Write(symbolCount);
return(tag.ToArray());
}
}