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 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 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 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();
}
}
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);
}
protected void ScanForMessageReferences(ABCFile abc)
{
if (!FindMessageInstances()) return;
if (_messageReferencesCache.Count > 0) return;
var messageClasses = new Dictionary<string, ASClass>(
OutgoingTypes.Count + IncomingTypes.Count);
foreach (ASClass outClass in OutgoingTypes.Values)
{
messageClasses.Add(
outClass.Instance.Type.ObjName, outClass);
}
foreach (ASClass inClass in IncomingTypes.Values)
{
messageClasses.Add(
inClass.Instance.Type.ObjName, inClass);
}
foreach (ASClass asClass in abc.Classes)
{
ASInstance asInstance = asClass.Instance;
if (asInstance.ClassInfo.HasFlag(ClassFlags.Interface)) continue;
ScanForMessageReference(messageClasses, asClass, asClass.Constructor, 0);
ScanForMessageReference(messageClasses, asClass, asClass.Instance.Constructor, 0);
if (asInstance.Traits.Count < 1) continue;
for (int i = 0; i < asInstance.Traits.Count; i++)
{
ASTrait trait = asInstance.Traits[i];
if (trait.TraitType != TraitType.Method) continue;
var mgsTrait = (MethodGetterSetterTrait)trait.Data;
ScanForMessageReference(messageClasses, asClass, mgsTrait.Method, i);
}
}
}
public ASParameter(ABCFile abc, int typeIndex, bool isOptional)
{
ABC = abc;
TypeIndex = typeIndex;
IsOptional = isOptional;
}
public ASInstance(ABCFile abc)
{
ABC = abc;
Traits = new List <ASTrait>();
InterfaceIndices = new List <int>();
}
public ASParameter(ABCFile abc)
: this(abc, 0, false)
{
}
public ASParameter(ABCFile abc, int typeIndex)
: this(abc, typeIndex, false)
{
}
public ASInstance(ABCFile abc)
{
ABC = abc;
Traits = new List<ASTrait>();
InterfaceIndices = new List<int>();
}
public ASScript(ABCFile abc)
{
ABC = abc;
Traits = new List <ASTrait>();
}
public ASException(ABCFile abc)
{
ABC = abc;
}
public ASScript(ABCFile abc)
{
ABC = abc;
Traits = new List<ASTrait>();
}
public ASTrait(ABCFile abc)
{
ABC = abc;
MetadataIndices = new List<int>();
}
public ASParameter(ABCFile abc)
: this(abc, 0, false)
{ }
public ASClass(ABCFile abc)
{
ABC = abc;
Traits = new List<ASTrait>();
}
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 ASParameter(ABCFile abc, int typeIndex, bool isOptional)
{
ABC = abc;
TypeIndex = typeIndex;
IsOptional = isOptional;
}
public ASException(ABCFile abc)
{
ABC = abc;
}
public ASMethod(ABCFile abc)
{
ABC = abc;
Parameters = new List <ASParameter>();
}
public ASClass(ABCFile abc)
{
ABC = abc;
Traits = new List <ASTrait>();
}
public ASParameter(ABCFile abc, int typeIndex)
: this(abc, typeIndex, false)
{ }
public ASMethod(ABCFile abc)
{
ABC = abc;
Parameters = new List<ASParameter>();
}
public ASMetadata(ABCFile abc)
{
ABC = abc;
Elements = new List<Tuple<int, int>>();
}
