public void OnWriterEvent(ModuleWriterBase writer, ModuleWriterEvent evt)
{
if (evt == ModuleWriterEvent.MDBeginCreateTables)
{
// Add key signature
uint sigBlob = writer.MetaData.BlobHeap.Add(ctx.KeySig);
uint sigRid = writer.MetaData.TablesHeap.StandAloneSigTable.Add(new RawStandAloneSigRow(sigBlob));
Debug.Assert(sigRid == 1);
uint sigToken = 0x11000000 | sigRid;
ctx.KeyToken = sigToken;
MutationHelper.InjectKey(writer.Module.EntryPoint, 2, (int)sigToken);
}
else if (evt == ModuleWriterEvent.MDBeginAddResources)
{
// Compute hash
byte[] hash = SHA1.Create().ComputeHash(ctx.OriginModule);
uint hashBlob = writer.MetaData.BlobHeap.Add(hash);
MDTable <RawFileRow> fileTbl = writer.MetaData.TablesHeap.FileTable;
uint fileRid = fileTbl.Add(new RawFileRow(
(uint)FileAttributes.ContainsMetaData,
writer.MetaData.StringsHeap.Add("koi"),
hashBlob));
uint impl = CodedToken.Implementation.Encode(new MDToken(Table.File, fileRid));
// Add resources
MDTable <RawManifestResourceRow> resTbl = writer.MetaData.TablesHeap.ManifestResourceTable;
foreach (var resource in ctx.ManifestResources)
{
resTbl.Add(new RawManifestResourceRow(resource.Item1, resource.Item2, writer.MetaData.StringsHeap.Add(resource.Item3), impl));
}
}
}
public void Epoch()
{
DestroyGameObjects();
nGeneration++;
int totalFitness = GetFitness();
individuals = individuals.OrderByDescending(o => o.fitness).ToList();
List <Individual> newIndividuals = new List <Individual>();
newIndividuals.AddRange(CloneElite(ConfigManager.config.geneticAlgorithm.nElite));
newIndividuals.AddRange(ReproductionHelper.Reproduce(individuals, ConfigManager.config.geneticAlgorithm.nIndividuals - ConfigManager.config.geneticAlgorithm.nElite, totalFitness));
MutationHelper.Mutate(newIndividuals);
for (int i = 0; i < newIndividuals.Count; i++)
{
newIndividuals[i].SetTile(tileMap.GetRandomTile());
}
PrintStats();
individuals = new List <Individual>(newIndividuals);
CreateGameObjects();
}
private static void AdvanceGeneration()
{
Individual[] nextPopulation = new Individual[Config.nIndividualsPerPopulation];
Individual[] orderedIndividuals = FitnessHelper.GetOrderedIndividuals(population);
for (int i = 0; i < Config.nElite; i++)
{
nextPopulation[i] = orderedIndividuals[i];
nextPopulation[i].wasElite = true;
}
Debug.Log("ordered generation " + generationsFinished);
Print(orderedIndividuals);
//sacar el promedio de fitness, y hacer que la mutación pase empezando por el promedio ese dividido 2 (por ejemplo, si el fitness promedio es 4, empezás a mutar desde el frame 2)
//y aumentás el mutationRate un toque
Individual[] childrenIndividuals = ReproductionHelper.GetChildrenIndividuals(population, Config.nIndividualsPerPopulation - Config.nElite);
MutationHelper.MutatePopulation(childrenIndividuals);
for (int i = Config.nElite; i < childrenIndividuals.Length + Config.nElite; i++)
{
nextPopulation[i] = childrenIndividuals[i - Config.nElite];
}
Debug.Log("next generation " + generationsFinished + 1);
Print(nextPopulation);
generationsFinished++;
individualsFinished = 0;
population = (Individual[])nextPopulation.Clone();
StartIndividual(0);
}
void InjectData(ModuleDef stubModule, MethodDef method, byte[] data)
{
var dataType = new TypeDefUser("", "DataType", stubModule.CorLibTypes.GetTypeRef("System", "ValueType"));
dataType.Layout = TypeAttributes.ExplicitLayout;
dataType.Visibility = TypeAttributes.NestedPrivate;
dataType.IsSealed = true;
dataType.ClassLayout = new ClassLayoutUser(1, (uint)data.Length);
stubModule.GlobalType.NestedTypes.Add(dataType);
var dataField = new FieldDefUser("DataField", new FieldSig(dataType.ToTypeSig()))
{
IsStatic = true,
HasFieldRVA = true,
InitialValue = data,
Access = FieldAttributes.CompilerControlled
};
stubModule.GlobalType.Fields.Add(dataField);
MutationHelper.ReplacePlaceholder(method, arg => {
var repl = new List <Instruction>();
repl.AddRange(arg);
repl.Add(Instruction.Create(OpCodes.Dup));
repl.Add(Instruction.Create(OpCodes.Ldtoken, dataField));
repl.Add(Instruction.Create(OpCodes.Call, stubModule.Import(
typeof(RuntimeHelpers).GetMethod("InitializeArray"))));
return(repl.ToArray());
});
}
public void Epoch()
{
PrintStats();
DestroyGameObjects();
nGeneration++;
individuals = individuals.OrderByDescending(o => o.Fitness).ToList();
List <Individual> newIndividuals = new List <Individual>();
newIndividuals.AddRange(CloneElite(ConfigManager.config.geneticAlgorithm.nElite));
newIndividuals.AddRange(ReproductionHelper.Reproduce(individuals, ConfigManager.config.geneticAlgorithm.nIndividuals - ConfigManager.config.geneticAlgorithm.nElite, GetFitness()));
MutationHelper.Mutate(newIndividuals);
enemies = new List <List <Enemy> >();
for (int i = 0; i < newIndividuals.Count; i++)
{
newIndividuals[i].Index = i;
newIndividuals[i].CreateGameObject();
enemies.Add(new List <Enemy>());
float distanceOffset = 0;
for (int j = 0; j < ConfigManager.config.nEnemies; j++)
{
enemies[i].Add(new Enemy(i, distanceOffset));
distanceOffset = enemies[i][j].Distance;
}
newIndividuals[i].SetEnemies(enemies[i]);
}
individuals = new List <Individual>(newIndividuals);
CreateGameObjects();
}
TypeDef GetKeyAttr(RPContext ctx)
{
if (keyAttrs == null)
{
keyAttrs = new Tuple <TypeDef, Func <int, int> > [0x10];
}
int index = ctx.Random.NextInt32(keyAttrs.Length);
if (keyAttrs[index] == null)
{
TypeDef rtType = ctx.Context.Registry.GetService <IRuntimeService>().GetRuntimeType("Confuser.Runtime.RefProxyKey");
TypeDef injectedAttr = InjectHelper.Inject(rtType, ctx.Module);
injectedAttr.Name = ctx.Name.RandomName();
injectedAttr.Namespace = string.Empty;
Expression expression, inverse;
var var = new Variable("{VAR}");
var result = new Variable("{RESULT}");
ctx.DynCipher.GenerateExpressionPair(
ctx.Random,
new VariableExpression {
Variable = var
}, new VariableExpression {
Variable = result
},
ctx.Depth, out expression, out inverse);
var expCompiled = new DMCodeGen(typeof(int), new[] { Tuple.Create("{VAR}", typeof(int)) })
.GenerateCIL(expression)
.Compile <Func <int, int> >();
MethodDef ctor = injectedAttr.FindMethod(".ctor");
MutationHelper.ReplacePlaceholder(ctor, arg =>
{
var invCompiled = new List <Instruction>();
new CodeGen(arg, ctor, invCompiled).GenerateCIL(inverse);
return(invCompiled.ToArray());
});
keyAttrs[index] = Tuple.Create(injectedAttr, expCompiled);
ctx.Module.AddAsNonNestedType(injectedAttr);
foreach (IDnlibDef def in injectedAttr.FindDefinitions())
{
if (def.Name == "GetHashCode")
{
ctx.Name.MarkHelper(def, ctx.Marker, ctx.Protection);
((MethodDef)def).Access = MethodAttributes.Public;
}
else
{
ctx.Name.MarkHelper(def, ctx.Marker, ctx.Protection);
}
}
}
return(keyAttrs[index].Item1);
}
void Awake()
{
PhraseHelper.Init();
ReproductionHelper.Init();
MutationHelper.Init();
UIManager.Init();
PopulationManager.Init();
}
private static void AddChildren(Individual[] nextPopulation, Individual[] population)
{
Individual[] childrenIndividuals = ReproductionHelper.GetChildrenIndividuals(population, Config.nIndividualsPerPopulation - Config.nElite);
MutationHelper.MutatePopulation(childrenIndividuals);
for (int i = Config.nElite; i < childrenIndividuals.Length + Config.nElite; i++)
{
nextPopulation[i] = childrenIndividuals[i - Config.nElite];
}
}
protected override void OnNextStepClicked()
{
NumberOfSteps++;
var reproduceItems = ReproductionHelper.ReproduceReal(Function, RealItems);
var newItems =
CrossingoverHelper.MakeRealCrossingover(reproduceItems, SolutionAccuracy, CrossingoverPossibility);
MutationHelper.MutateReal(newItems, NumberOfSteps, MaxSteps, MutationPossibility);
RealItems = newItems;
var minItem = RealItems.Aggregate((i, j) =>
Function(i.X1, i.X2) < Function(j.X1, j.X2)
? i
: j);
ItemValue = $"x1: {minItem.X1}\nx2: {minItem.X2}";
var functionValue = Function(minItem.X1, minItem.X2);
MaxItemValueFunction = functionValue.ToString();
// ------------------------------------------------------
for (var i = ChartModel.Series.Count - 1; i > 0; i--)
{
ChartModel.Series.RemoveAt(i);
}
var solutions = new ScatterSeries
{
MarkerType = MarkerType.Circle,
MarkerFill = OxyColor.FromRgb(0, 0, 0xFF)
};
foreach (var p in RealItems)
{
var plotPoint = new ScatterPoint(p.X1, p.X2, 5);
solutions.Points.Add(plotPoint);
}
ChartModel.Series.Add(solutions);
var minValueSeries = new ScatterSeries
{
MarkerType = MarkerType.Circle,
MarkerFill = OxyColor.FromRgb(0xFF, 0, 0)
};
minValueSeries.Points.Add(new ScatterPoint(minItem.X1, minItem.X2, 7, functionValue));
ChartModel.Series.Add(minValueSeries);
ChartModel.InvalidatePlot(true);
}
public object CreateDecoder(MethodDef decoder, CEContext ctx)
{
var encoding = new x86Encoding();
encoding.Compile(ctx);
MutationHelper.ReplacePlaceholder(decoder, arg => {
var repl = new List <Instruction>();
repl.AddRange(arg);
repl.Add(Instruction.Create(OpCodes.Call, encoding.native));
return(repl.ToArray());
});
return(encoding);
}
// Token: 0x06000197 RID: 407 RVA: 0x000618C0 File Offset: 0x0005FAC0
private void MutateInitializer(REContext moduleCtx, MethodDef decomp)
{
moduleCtx.InitMethod.Body.SimplifyMacros(moduleCtx.InitMethod.Parameters);
List <Instruction> list = moduleCtx.InitMethod.Body.Instructions.ToList <Instruction>();
for (int i = 0; i < list.Count; i++)
{
Instruction instruction = list[i];
IMethod method = instruction.Operand as IMethod;
bool flag = instruction.OpCode == OpCodes.Call;
if (flag)
{
bool flag2 = method.DeclaringType.Name == "Mutation" && method.Name == "Crypt";
if (flag2)
{
Instruction instruction2 = list[i - 2];
Instruction instruction3 = list[i - 1];
Debug.Assert(instruction2.OpCode == OpCodes.Ldloc && instruction3.OpCode == OpCodes.Ldloc);
list.RemoveAt(i);
list.RemoveAt(i - 1);
list.RemoveAt(i - 2);
list.InsertRange(i - 2, moduleCtx.ModeHandler.EmitDecrypt(moduleCtx.InitMethod, moduleCtx, (Local)instruction2.Operand, (Local)instruction3.Operand));
}
else
{
bool flag3 = method.DeclaringType.Name == "Lzma" && method.Name == "Decompress";
if (flag3)
{
instruction.Operand = decomp;
}
}
}
}
moduleCtx.InitMethod.Body.Instructions.Clear();
foreach (Instruction item in list)
{
moduleCtx.InitMethod.Body.Instructions.Add(item);
}
MutationHelper.ReplacePlaceholder(moduleCtx.InitMethod, delegate(Instruction[] arg)
{
List <Instruction> list2 = new List <Instruction>();
list2.AddRange(arg);
list2.Add(Instruction.Create(OpCodes.Dup));
list2.Add(Instruction.Create(OpCodes.Ldtoken, moduleCtx.DataField));
list2.Add(Instruction.Create(OpCodes.Call, moduleCtx.Module.Import(typeof(RuntimeHelpers).GetMethod("InitializeArray"))));
return(list2.ToArray());
});
moduleCtx.Context.Registry.GetService <IConstantService>().ExcludeMethod(moduleCtx.Context, moduleCtx.InitMethod);
}
InitMethodDesc GetInitMethod(RPContext ctx, IRPEncoding encoding)
{
InitMethodDesc[] initDescs;
if (!inits.TryGetValue(encoding, out initDescs))
{
inits[encoding] = initDescs = new InitMethodDesc[ctx.InitCount];
}
int index = ctx.Random.NextInt32(initDescs.Length);
if (initDescs[index] == null)
{
TypeDef rtType = ctx.Context.Registry.GetService <IRuntimeService>().GetRuntimeType("Confuser.Runtime.RefProxyStrong");
MethodDef injectedMethod = InjectHelper.Inject(rtType.FindMethod("Initialize"), ctx.Module);
ctx.Module.GlobalType.Methods.Add(injectedMethod);
injectedMethod.Access = MethodAttributes.PrivateScope;
injectedMethod.Name = ctx.Name.RandomName();
ctx.Name.SetCanRename(injectedMethod, false);
ctx.Marker.Mark(injectedMethod, ctx.Protection);
var desc = new InitMethodDesc {
Method = injectedMethod
};
// Field name has five bytes, each bytes has different order & meaning
int[] order = Enumerable.Range(0, 5).ToArray();
ctx.Random.Shuffle(order);
desc.OpCodeIndex = order[4];
desc.TokenNameOrder = new int[4];
Array.Copy(order, 0, desc.TokenNameOrder, 0, 4);
desc.TokenByteOrder = Enumerable.Range(0, 4).Select(x => x * 8).ToArray();
ctx.Random.Shuffle(desc.TokenByteOrder);
var keyInjection = new int[9];
Array.Copy(desc.TokenNameOrder, 0, keyInjection, 0, 4);
Array.Copy(desc.TokenByteOrder, 0, keyInjection, 4, 4);
keyInjection[8] = desc.OpCodeIndex;
MutationHelper.InjectKeys(injectedMethod, Enumerable.Range(0, 9).ToArray(), keyInjection);
// Encoding
MutationHelper.ReplacePlaceholder(injectedMethod, arg => { return(encoding.EmitDecode(injectedMethod, ctx, arg)); });
desc.Encoding = encoding;
initDescs[index] = desc;
}
return(initDescs[index]);
}
public object CreateDecoder(MethodDef decoder, CEContext ctx)
{
uint k1 = ctx.Random.NextUInt32() | 1;
uint k2 = ctx.Random.NextUInt32();
MutationHelper.ReplacePlaceholder(decoder, arg => {
var repl = new List <Instruction>();
repl.AddRange(arg);
repl.Add(Instruction.Create(OpCodes.Ldc_I4, (int)MathsUtils.modInv(k1)));
repl.Add(Instruction.Create(OpCodes.Mul));
repl.Add(Instruction.Create(OpCodes.Ldc_I4, (int)k2));
repl.Add(Instruction.Create(OpCodes.Xor));
return(repl.ToArray());
});
return(Tuple.Create(k1, k2));
}
public void OnWriterEvent(ModuleWriterBase writer, ModuleWriterEvent evt)
{
if (evt == ModuleWriterEvent.MDBeginCreateTables)
{
// Add key signature
var sigBlob = writer.MetaData.BlobHeap.Add(ctx.KeySig);
var sigRid = writer.MetaData.TablesHeap.StandAloneSigTable.Add(new RawStandAloneSigRow(sigBlob));
Debug.Assert(sigRid == 1);
var sigToken = 0x11000000 | sigRid;
ctx.KeyToken = sigToken;
MutationHelper.InjectKey(writer.Module.EntryPoint, 2, (int)sigToken);
}
else if (evt == ModuleWriterEvent.MDBeginAddResources && !ctx.CompatMode)
{
// Compute hash
var hash = SHA1.Create().ComputeHash(ctx.OriginModule);
var hashBlob = writer.MetaData.BlobHeap.Add(hash);
var fileTbl = writer.MetaData.TablesHeap.FileTable;
var fileRid = fileTbl.Add(new RawFileRow(
(uint)FileAttributes.ContainsMetaData,
writer.MetaData.StringsHeap.Add("koi"),
hashBlob));
var impl = CodedToken.Implementation.Encode(new MDToken(Table.File, fileRid));
// Add resources
var resTbl = writer.MetaData.TablesHeap.ManifestResourceTable;
foreach (var resource in ctx.ManifestResources)
{
resTbl.Add(new RawManifestResourceRow(resource.Item1, resource.Item2, writer.MetaData.StringsHeap.Add(resource.Item3), impl));
}
// Add exported types
var exTbl = writer.MetaData.TablesHeap.ExportedTypeTable;
foreach (var type in ctx.OriginModuleDef.GetTypes())
{
if (!type.IsVisibleOutside())
{
continue;
}
exTbl.Add(new RawExportedTypeRow((uint)type.Attributes, 0,
writer.MetaData.StringsHeap.Add(type.Name),
writer.MetaData.StringsHeap.Add(type.Namespace), impl));
}
}
}
private void MutateInitializer(REContext moduleCtx, MethodDef decomp)
{
moduleCtx.InitMethod.Body.SimplifyMacros(moduleCtx.InitMethod.Parameters);
var instrs = moduleCtx.InitMethod.Body.Instructions.ToList();
for (var i = 0; i < instrs.Count; i++)
{
var instr = instrs[i];
var method = instr.Operand as IMethod;
if (instr.OpCode == OpCodes.Call)
{
if (method.DeclaringType.Name == "Mutation" &&
method.Name == "Crypt")
{
var ldBlock = instrs[i - 2];
var ldKey = instrs[i - 1];
Debug.Assert(ldBlock.OpCode == OpCodes.Ldloc && ldKey.OpCode == OpCodes.Ldloc);
instrs.RemoveAt(i);
instrs.RemoveAt(i - 1);
instrs.RemoveAt(i - 2);
instrs.InsertRange(i - 2, moduleCtx.ModeHandler.EmitDecrypt(moduleCtx.InitMethod, moduleCtx, (Local)ldBlock.Operand, (Local)ldKey.Operand));
}
else if (method.DeclaringType.Name == "Lzma" &&
method.Name == "Decompress")
{
instr.Operand = decomp;
}
}
}
moduleCtx.InitMethod.Body.Instructions.Clear();
foreach (var instr in instrs)
{
moduleCtx.InitMethod.Body.Instructions.Add(instr);
}
MutationHelper.ReplacePlaceholder(moduleCtx.InitMethod, arg =>
{
var repl = new List <Instruction>();
repl.AddRange(arg);
repl.Add(Instruction.Create(OpCodes.Dup));
repl.Add(Instruction.Create(OpCodes.Ldtoken, moduleCtx.DataField));
repl.Add(Instruction.Create(OpCodes.Call, moduleCtx.Module.Import(
typeof(RuntimeHelpers).GetMethod("InitializeArray"))));
return(repl.ToArray());
});
moduleCtx.Context.Registry.GetService <IConstantService>().ExcludeMethod(moduleCtx.Context, moduleCtx.InitMethod);
}
public static void AdvanceGeneration()
{
List <Individual> newPopulation = new List <Individual>();
FitnessHelper.CalculateFitness(population);
newPopulation.AddRange(FitnessHelper.GetIndividualsWithHighestFitness(population, Config.nIndividualsToAdvanceAutomatically));
UIManager.UpdateBestPhrase(newPopulation[0].dna.phrase);
newPopulation.AddRange(ReproductionHelper.GetNewIndividuals(population, Config.nIndividuals - Config.nIndividualsToAdvanceAutomatically));
MutationHelper.MutatePopulation(population);
generationNumber++;
UIManager.UpdateGenerationNumber(generationNumber);
UIManager.UpdateFitnesses(FitnessHelper.GetFitnessInformation(population));
ReassignPopulation(newPopulation);
}
private InitMethodDesc GetInitMethod(RPContext ctx, IRPEncoding encoding)
{
InitMethodDesc[] descArray;
if (!this.inits.TryGetValue(encoding, out descArray))
{
this.inits[encoding] = descArray = new InitMethodDesc[ctx.InitCount];
}
int index = ctx.Random.NextInt32(descArray.Length);
if (descArray[index] == null)
{
TypeDef runtimeType = ctx.Context.Registry.GetService <IRuntimeService>().GetRuntimeType("Confuser.Runtime.RefProxyStrong");
MethodDef injectedMethod = InjectHelper.Inject(runtimeType.FindMethod("Initialize"), ctx.Module);
ctx.Module.GlobalType.Methods.Add(injectedMethod);
injectedMethod.Access = MethodAttributes.CompilerControlled;
injectedMethod.Name = ctx.Name.RandomName();
ctx.Name.SetCanRename(injectedMethod, false);
ctx.Marker.Mark(injectedMethod, ctx.Protection);
InitMethodDesc desc = new InitMethodDesc {
Method = injectedMethod
};
int[] list = Enumerable.Range(0, 5).ToArray <int>();
ctx.Random.Shuffle <int>(list);
desc.OpCodeIndex = list[4];
desc.TokenNameOrder = new int[4];
Array.Copy(list, 0, desc.TokenNameOrder, 0, 4);
desc.TokenByteOrder = (from x in Enumerable.Range(0, 4) select x * 8).ToArray <int>();
ctx.Random.Shuffle <int>(desc.TokenByteOrder);
int[] destinationArray = new int[9];
Array.Copy(desc.TokenNameOrder, 0, destinationArray, 0, 4);
Array.Copy(desc.TokenByteOrder, 0, destinationArray, 4, 4);
destinationArray[8] = desc.OpCodeIndex;
MutationHelper.InjectKeys(injectedMethod, Enumerable.Range(0, 9).ToArray <int>(), destinationArray);
MutationHelper.ReplacePlaceholder(injectedMethod, arg => encoding.EmitDecode(injectedMethod, ctx, arg));
desc.Encoding = encoding;
descArray[index] = desc;
}
return(descArray[index]);
}
public void Epoch()
{
Debug.Log("Finished generation " + nGeneration + " with a total fitness of " + GetFitness());
PopulationHistory.AddIndividuals(Individuals);
nGeneration++;
DestroyGameObjects();
Individuals = Individuals.OrderByDescending(o => o.Fitness).ToList();
List <Individual> newIndividuals = new List <Individual>();
newIndividuals.AddRange(CloneElite(ConfigManager.config.geneticAlgorithm.nElite));
newIndividuals.AddRange(ReproductionHelper.Reproduce(Individuals, ConfigManager.config.geneticAlgorithm.nIndividuals - ConfigManager.config.geneticAlgorithm.nElite, GetFitness()));
MutationHelper.Mutate(newIndividuals.GetRange(ConfigManager.config.geneticAlgorithm.nElite, newIndividuals.Count - ConfigManager.config.geneticAlgorithm.nElite));
for (int i = 0; i < newIndividuals.Count; i++)
{
newIndividuals[i].Index = i;
}
Individuals = new List <Individual>(newIndividuals);
CreateGameObjects();
}
void InjectStub(ConfuserContext context, CompressorContext compCtx, ProtectionParameters parameters, ModuleDef stubModule)
{
var rt = context.Registry.GetService <IRuntimeService>();
RandomGenerator random = context.Registry.GetService <IRandomService>().GetRandomGenerator(Id);
var comp = context.Registry.GetService <ICompressionService>();
var rtType = rt.GetRuntimeType(compCtx.CompatMode ? "Confuser.Runtime.CompressorCompat" : "Confuser.Runtime.Compressor");
IEnumerable <IDnlibDef> defs = InjectHelper.Inject(rtType, stubModule.GlobalType, stubModule);
switch (parameters.GetParameter(context, context.CurrentModule, "key", Mode.Dynamic))
{
case Mode.Normal:
compCtx.Deriver = new NormalDeriver();
break;
case Mode.Dynamic:
compCtx.Deriver = new DynamicDeriver();
break;
default:
throw new UnreachableException();
}
compCtx.Deriver.Init(context, random);
context.Logger.Debug("Encrypting modules...");
// Main
MethodDef entryPoint = defs.OfType <MethodDef>().Single(method => method.Name == "Main");
stubModule.EntryPoint = entryPoint;
if (compCtx.EntryPoint.HasAttribute("System.STAThreadAttribute"))
{
var attrType = stubModule.CorLibTypes.GetTypeRef("System", "STAThreadAttribute");
var ctorSig = MethodSig.CreateInstance(stubModule.CorLibTypes.Void);
entryPoint.CustomAttributes.Add(new CustomAttribute(
new MemberRefUser(stubModule, ".ctor", ctorSig, attrType)));
}
else if (compCtx.EntryPoint.HasAttribute("System.MTAThreadAttribute"))
{
var attrType = stubModule.CorLibTypes.GetTypeRef("System", "MTAThreadAttribute");
var ctorSig = MethodSig.CreateInstance(stubModule.CorLibTypes.Void);
entryPoint.CustomAttributes.Add(new CustomAttribute(
new MemberRefUser(stubModule, ".ctor", ctorSig, attrType)));
}
uint seed = random.NextUInt32();
compCtx.OriginModule = context.OutputModules[compCtx.ModuleIndex];
byte[] encryptedModule = compCtx.Encrypt(comp, compCtx.OriginModule, seed,
progress => context.Logger.Progress((int)(progress * 10000), 10000));
context.Logger.EndProgress();
context.CheckCancellation();
compCtx.EncryptedModule = encryptedModule;
MutationHelper.InjectKeys(entryPoint,
new[] { 0, 1 },
new[] { encryptedModule.Length >> 2, (int)seed });
InjectData(stubModule, entryPoint, encryptedModule);
// Decrypt
MethodDef decrypter = defs.OfType <MethodDef>().Single(method => method.Name == "Decrypt");
decrypter.Body.SimplifyMacros(decrypter.Parameters);
List <Instruction> instrs = decrypter.Body.Instructions.ToList();
for (int i = 0; i < instrs.Count; i++)
{
Instruction instr = instrs[i];
if (instr.OpCode == OpCodes.Call)
{
var method = (IMethod)instr.Operand;
if (method.DeclaringType.Name == "Mutation" &&
method.Name == "Crypt")
{
Instruction ldDst = instrs[i - 2];
Instruction ldSrc = instrs[i - 1];
Debug.Assert(ldDst.OpCode == OpCodes.Ldloc && ldSrc.OpCode == OpCodes.Ldloc);
instrs.RemoveAt(i);
instrs.RemoveAt(i - 1);
instrs.RemoveAt(i - 2);
instrs.InsertRange(i - 2, compCtx.Deriver.EmitDerivation(decrypter, context, (Local)ldDst.Operand, (Local)ldSrc.Operand));
}
else if (method.DeclaringType.Name == "Lzma" &&
method.Name == "Decompress")
{
MethodDef decomp = comp.GetRuntimeDecompressor(stubModule, member => { });
instr.Operand = decomp;
}
}
}
decrypter.Body.Instructions.Clear();
foreach (Instruction instr in instrs)
{
decrypter.Body.Instructions.Add(instr);
}
// Pack modules
PackModules(context, compCtx, stubModule, comp, random);
}
void InjectHelpers(ConfuserContext context, ICompressionService compression, IRuntimeService rt, CEContext moduleCtx)
{
var members = InjectHelper.Inject(rt.GetRuntimeType("Confuser.Runtime.Constant"), context.CurrentModule.GlobalType, context.CurrentModule);
foreach (var member in members)
{
if (member.Name == "Get")
{
context.CurrentModule.GlobalType.Remove((MethodDef)member);
continue;
}
if (member.Name == "b")
{
moduleCtx.BufferField = (FieldDef)member;
}
else if (member.Name == "Initialize")
{
moduleCtx.InitMethod = (MethodDef)member;
}
moduleCtx.Name.MarkHelper(member, moduleCtx.Marker, (Protection)Parent);
}
ProtectionParameters.GetParameters(context, moduleCtx.InitMethod).Remove(Parent);
var dataType = new TypeDefUser("", moduleCtx.Name.RandomName(), context.CurrentModule.CorLibTypes.GetTypeRef("System", "ValueType"))
{
Layout = TypeAttributes.ExplicitLayout,
Visibility = TypeAttributes.NestedPrivate,
IsSealed = true
};
moduleCtx.DataType = dataType;
context.CurrentModule.GlobalType.NestedTypes.Add(dataType);
moduleCtx.Name.MarkHelper(dataType, moduleCtx.Marker, (Protection)Parent);
moduleCtx.DataField = new FieldDefUser(moduleCtx.Name.RandomName(), new FieldSig(dataType.ToTypeSig()))
{
IsStatic = true,
Access = FieldAttributes.CompilerControlled
};
context.CurrentModule.GlobalType.Fields.Add(moduleCtx.DataField);
moduleCtx.Name.MarkHelper(moduleCtx.DataField, moduleCtx.Marker, (Protection)Parent);
var decoder = rt.GetRuntimeType("Confuser.Runtime.Constant").FindMethod("Get");
moduleCtx.Decoders = new List <Tuple <MethodDef, DecoderDesc> >();
for (var i = 0; i < moduleCtx.DecoderCount; i++)
{
var decoderInst = InjectHelper.Inject(decoder, context.CurrentModule);
for (var j = 0; j < decoderInst.Body.Instructions.Count; j++)
{
var instr = decoderInst.Body.Instructions[j];
var method = instr.Operand as IMethod;
var field = instr.Operand as IField;
if (instr.OpCode == OpCodes.Call &&
method.DeclaringType.Name == "Mutation" &&
method.Name == "Value")
{
decoderInst.Body.Instructions[j] = Instruction.Create(OpCodes.Sizeof, new GenericMVar(0).ToTypeDefOrRef());
}
else if (instr.OpCode == OpCodes.Ldsfld &&
method.DeclaringType.Name == "Constant")
{
if (field.Name == "b")
{
instr.Operand = moduleCtx.BufferField;
}
else
{
throw new UnreachableException();
}
}
}
context.CurrentModule.GlobalType.Methods.Add(decoderInst);
moduleCtx.Name.MarkHelper(decoderInst, moduleCtx.Marker, (Protection)Parent);
ProtectionParameters.GetParameters(context, decoderInst).Remove(Parent);
var decoderDesc = new DecoderDesc
{
StringID = (byte)(moduleCtx.Random.NextByte() & 3)
};
do
{
decoderDesc.NumberID = (byte)(moduleCtx.Random.NextByte() & 3);
}while (decoderDesc.NumberID == decoderDesc.StringID);
do
{
decoderDesc.InitializerID = (byte)(moduleCtx.Random.NextByte() & 3);
}while (decoderDesc.InitializerID == decoderDesc.StringID || decoderDesc.InitializerID == decoderDesc.NumberID);
MutationHelper.InjectKeys(decoderInst,
new[] { 0, 1, 2 },
new int[] { decoderDesc.StringID, decoderDesc.NumberID, decoderDesc.InitializerID });
decoderDesc.Data = moduleCtx.ModeHandler.CreateDecoder(decoderInst, moduleCtx);
moduleCtx.Decoders.Add(Tuple.Create(decoderInst, decoderDesc));
}
}
public void HandleInject(AntiTamperProtection parent, ConfuserContext context, ProtectionParameters parameters)
{
random = context.Registry.GetService <IRandomService>().GetRandomGenerator(parent.FullId);
z = random.NextUInt32();
x = random.NextUInt32();
c = random.NextUInt32();
v = random.NextUInt32();
name1 = random.NextUInt32() & 0x7f7f7f7f;
name2 = random.NextUInt32() & 0x7f7f7f7f;
switch (parameters.GetParameter(context, context.CurrentModule, "key", Mode.Normal))
{
case Mode.Normal:
deriver = new NormalDeriver();
break;
case Mode.Dynamic:
deriver = new DynamicDeriver();
break;
default:
throw new UnreachableException();
}
deriver.Init(context, random);
var rt = context.Registry.GetService <IRuntimeService>();
TypeDef initType = rt.GetRuntimeType("Confuser.Runtime.AntiTamperAnti");
IEnumerable <IDnlibDef> members = InjectHelper.Inject(initType, context.CurrentModule.GlobalType, context.CurrentModule);
var initMethod = (MethodDef)members.Single(m => m.Name == "Initialize");
initMethod.Body.SimplifyMacros(initMethod.Parameters);
List <Instruction> instrs = initMethod.Body.Instructions.ToList();
for (int i = 0; i < instrs.Count; i++)
{
Instruction instr = instrs[i];
if (instr.OpCode == OpCodes.Ldtoken)
{
instr.Operand = context.CurrentModule.GlobalType;
}
else if (instr.OpCode == OpCodes.Call)
{
var method = (IMethod)instr.Operand;
if (method.DeclaringType.Name == "Mutation" &&
method.Name == "Crypt")
{
Instruction ldDst = instrs[i - 2];
Instruction ldSrc = instrs[i - 1];
Debug.Assert(ldDst.OpCode == OpCodes.Ldloc && ldSrc.OpCode == OpCodes.Ldloc);
instrs.RemoveAt(i);
instrs.RemoveAt(i - 1);
instrs.RemoveAt(i - 2);
instrs.InsertRange(i - 2, deriver.EmitDerivation(initMethod, context, (Local)ldDst.Operand, (Local)ldSrc.Operand));
}
}
}
initMethod.Body.Instructions.Clear();
foreach (Instruction instr in instrs)
{
initMethod.Body.Instructions.Add(instr);
}
MutationHelper.InjectKeys(initMethod,
new[] { 0, 1, 2, 3, 4 },
new[] { (int)(name1 * name2), (int)z, (int)x, (int)c, (int)v });
var name = context.Registry.GetService <INameService>();
var marker = context.Registry.GetService <IMarkerService>();
foreach (IDnlibDef def in members)
{
name.MarkHelper(def, marker, parent);
if (def is MethodDef)
{
parent.ExcludeMethod(context, (MethodDef)def);
}
}
MethodDef cctor = context.CurrentModule.GlobalType.FindStaticConstructor();
cctor.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Call, initMethod));
parent.ExcludeMethod(context, cctor);
}
protected override void Execute(ConfuserContext context, ProtectionParameters parameters)
{
var moduleCtx = context.Annotations.Get <CEContext>(context.CurrentModule, ConstantProtection.ContextKey);
if (!parameters.Targets.Any() || moduleCtx == null)
{
return;
}
var ldc = new Dictionary <object, List <Tuple <MethodDef, Instruction> > >();
var ldInit = new Dictionary <byte[], List <Tuple <MethodDef, Instruction> > >(new ByteArrayComparer());
// Extract constants
ExtractConstants(context, parameters, moduleCtx, ldc, ldInit);
// Encode constants
moduleCtx.ReferenceRepl = new Dictionary <MethodDef, List <Tuple <Instruction, uint, IMethod> > >();
moduleCtx.EncodedBuffer = new List <uint>();
foreach (var entry in ldInit.WithProgress(context.Logger)) // Ensure the array length haven't been encoded yet
{
EncodeInitializer(moduleCtx, entry.Key, entry.Value);
context.CheckCancellation();
}
foreach (var entry in ldc.WithProgress(context.Logger))
{
if (entry.Key is string)
{
EncodeString(moduleCtx, (string)entry.Key, entry.Value);
}
else if (entry.Key is int)
{
EncodeConstant32(moduleCtx, (uint)(int)entry.Key, context.CurrentModule.CorLibTypes.Int32, entry.Value);
}
else if (entry.Key is long)
{
EncodeConstant64(moduleCtx, (uint)((long)entry.Key >> 32), (uint)(long)entry.Key, context.CurrentModule.CorLibTypes.Int64, entry.Value);
}
else if (entry.Key is float)
{
var t = new RTransform();
t.R4 = (float)entry.Key;
EncodeConstant32(moduleCtx, t.Lo, context.CurrentModule.CorLibTypes.Single, entry.Value);
}
else if (entry.Key is double)
{
var t = new RTransform();
t.R8 = (double)entry.Key;
EncodeConstant64(moduleCtx, t.Hi, t.Lo, context.CurrentModule.CorLibTypes.Double, entry.Value);
}
else
{
throw new UnreachableException();
}
context.CheckCancellation();
}
ReferenceReplacer.ReplaceReference(moduleCtx, parameters);
// compress
var encodedBuff = new byte[moduleCtx.EncodedBuffer.Count * 4];
int buffIndex = 0;
foreach (uint dat in moduleCtx.EncodedBuffer)
{
encodedBuff[buffIndex++] = (byte)((dat >> 0) & 0xff);
encodedBuff[buffIndex++] = (byte)((dat >> 8) & 0xff);
encodedBuff[buffIndex++] = (byte)((dat >> 16) & 0xff);
encodedBuff[buffIndex++] = (byte)((dat >> 24) & 0xff);
}
Debug.Assert(buffIndex == encodedBuff.Length);
encodedBuff = context.Registry.GetService <ICompressionService>().Compress(encodedBuff);
context.CheckCancellation();
uint compressedLen = (uint)(encodedBuff.Length + 3) / 4;
compressedLen = (compressedLen + 0xfu) & ~0xfu;
var compressedBuff = new uint[compressedLen];
Buffer.BlockCopy(encodedBuff, 0, compressedBuff, 0, encodedBuff.Length);
Debug.Assert(compressedLen % 0x10 == 0);
// encrypt
uint keySeed = moduleCtx.Random.NextUInt32();
var key = new uint[0x10];
uint state = keySeed;
for (int i = 0; i < 0x10; i++)
{
state ^= state >> 12;
state ^= state << 25;
state ^= state >> 27;
key[i] = state;
}
var encryptedBuffer = new byte[compressedBuff.Length * 4];
buffIndex = 0;
while (buffIndex < compressedBuff.Length)
{
uint[] enc = moduleCtx.ModeHandler.Encrypt(compressedBuff, buffIndex, key);
for (int j = 0; j < 0x10; j++)
{
key[j] ^= compressedBuff[buffIndex + j];
}
Buffer.BlockCopy(enc, 0, encryptedBuffer, buffIndex * 4, 0x40);
buffIndex += 0x10;
}
Debug.Assert(buffIndex == compressedBuff.Length);
moduleCtx.DataField.InitialValue = encryptedBuffer;
moduleCtx.DataField.HasFieldRVA = true;
moduleCtx.DataType.ClassLayout = new ClassLayoutUser(0, (uint)encryptedBuffer.Length);
MutationHelper.InjectKeys(moduleCtx.InitMethod,
new[] { 0, 1 },
new[] { encryptedBuffer.Length / 4, (int)keySeed });
MutationHelper.ReplacePlaceholder(moduleCtx.InitMethod, arg => {
var repl = new List <Instruction>();
repl.AddRange(arg);
repl.Add(Instruction.Create(OpCodes.Dup));
repl.Add(Instruction.Create(OpCodes.Ldtoken, moduleCtx.DataField));
repl.Add(Instruction.Create(OpCodes.Call, moduleCtx.Module.Import(
typeof(RuntimeHelpers).GetMethod("InitializeArray"))));
return(repl.ToArray());
});
}
public void HandleInject(AntiTamperProtection parent, ConfuserContext context, ProtectionParameters parameters)
{
this.context = context;
random = context.Registry.GetService <IRandomService>().GetRandomGenerator(parent.FullId);
z = random.NextUInt32();
x = random.NextUInt32();
c = random.NextUInt32();
v = random.NextUInt32();
name1 = random.NextUInt32() & 0x7f7f7f7f;
name2 = random.NextUInt32() & 0x7f7f7f7f;
key = random.NextUInt32();
fieldLayout = new byte[6];
for (int i = 0; i < 6; i++)
{
int index = random.NextInt32(0, 6);
while (fieldLayout[index] != 0)
{
index = random.NextInt32(0, 6);
}
fieldLayout[index] = (byte)i;
}
switch (parameters.GetParameter(context, context.CurrentModule, "key", Mode.Normal))
{
case Mode.Normal:
deriver = new NormalDeriver();
break;
case Mode.Dynamic:
deriver = new DynamicDeriver();
break;
default:
throw new UnreachableException();
}
deriver.Init(context, random);
var rt = context.Registry.GetService <IRuntimeService>();
TypeDef initType = rt.GetRuntimeType("Confuser.Runtime.AntiTamperJIT");
IEnumerable <IDnlibDef> defs = InjectHelper.Inject(initType, context.CurrentModule.GlobalType, context.CurrentModule);
initMethod = defs.OfType <MethodDef>().Single(method => method.Name == "Initialize");
initMethod.Body.SimplifyMacros(initMethod.Parameters);
List <Instruction> instrs = initMethod.Body.Instructions.ToList();
for (int i = 0; i < instrs.Count; i++)
{
Instruction instr = instrs[i];
if (instr.OpCode == OpCodes.Ldtoken)
{
instr.Operand = context.CurrentModule.GlobalType;
}
else if (instr.OpCode == OpCodes.Call)
{
var method = (IMethod)instr.Operand;
if (method.DeclaringType.Name == "Mutation" &&
method.Name == "Crypt")
{
Instruction ldDst = instrs[i - 2];
Instruction ldSrc = instrs[i - 1];
Debug.Assert(ldDst.OpCode == OpCodes.Ldloc && ldSrc.OpCode == OpCodes.Ldloc);
instrs.RemoveAt(i);
instrs.RemoveAt(i - 1);
instrs.RemoveAt(i - 2);
instrs.InsertRange(i - 2, deriver.EmitDerivation(initMethod, context, (Local)ldDst.Operand, (Local)ldSrc.Operand));
}
}
}
initMethod.Body.Instructions.Clear();
foreach (Instruction instr in instrs)
{
initMethod.Body.Instructions.Add(instr);
}
MutationHelper.InjectKeys(initMethod,
new[] { 0, 1, 2, 3, 4 },
new[] { (int)(name1 * name2), (int)z, (int)x, (int)c, (int)v });
var name = context.Registry.GetService <INameService>();
var marker = context.Registry.GetService <IMarkerService>();
cctor = context.CurrentModule.GlobalType.FindStaticConstructor();
cctorRepl = new MethodDefUser(name.RandomName(), MethodSig.CreateStatic(context.CurrentModule.CorLibTypes.Void));
cctorRepl.IsStatic = true;
cctorRepl.Access = MethodAttributes.CompilerControlled;
cctorRepl.Body = new CilBody();
cctorRepl.Body.Instructions.Add(Instruction.Create(OpCodes.Ret));
context.CurrentModule.GlobalType.Methods.Add(cctorRepl);
name.MarkHelper(cctorRepl, marker, parent);
MutationHelper.InjectKeys(defs.OfType <MethodDef>().Single(method => method.Name == "HookHandler"),
new[] { 0 }, new[] { (int)key });
foreach (IDnlibDef def in defs)
{
if (def.Name == "MethodData")
{
var dataType = (TypeDef)def;
FieldDef[] fields = dataType.Fields.ToArray();
var layout = fieldLayout.Clone() as byte[];
Array.Sort(layout, fields);
for (byte j = 0; j < 6; j++)
{
layout[j] = j;
}
Array.Sort(fieldLayout, layout);
fieldLayout = layout;
dataType.Fields.Clear();
foreach (FieldDef f in fields)
{
dataType.Fields.Add(f);
}
}
name.MarkHelper(def, marker, parent);
if (def is MethodDef)
{
parent.ExcludeMethod(context, (MethodDef)def);
}
}
parent.ExcludeMethod(context, cctor);
}
// Token: 0x0600019A RID: 410 RVA: 0x00061B74 File Offset: 0x0005FD74
private void OnWriterEvent(object sender, ModuleWriterListenerEventArgs e)
{
ModuleWriterBase moduleWriterBase = (ModuleWriterBase)sender;
bool flag = e.WriterEvent == ModuleWriterEvent.MDBeginAddResources;
if (flag)
{
this.ctx.Context.CheckCancellation();
this.ctx.Context.Logger.Debug("Encrypting resources...");
bool flag2 = this.ctx.Context.Packer != null;
List <EmbeddedResource> list = this.ctx.Module.Resources.OfType <EmbeddedResource>().ToList <EmbeddedResource>();
bool flag3 = !flag2;
if (flag3)
{
this.ctx.Module.Resources.RemoveWhere((Resource res) => res is EmbeddedResource);
}
string text = this.ctx.Name.RandomName(RenameMode.Letters);
PublicKey publicKey = null;
bool flag4 = moduleWriterBase.TheOptions.StrongNameKey != null;
if (flag4)
{
publicKey = PublicKeyBase.CreatePublicKey(moduleWriterBase.TheOptions.StrongNameKey.PublicKey);
}
AssemblyDefUser assemblyDefUser = new AssemblyDefUser(text, new Version(0, 0), publicKey);
assemblyDefUser.Modules.Add(new ModuleDefUser(text + ".dll"));
ModuleDef manifestModule = assemblyDefUser.ManifestModule;
assemblyDefUser.ManifestModule.Kind = ModuleKind.Dll;
AssemblyRefUser asmRef = new AssemblyRefUser(manifestModule.Assembly);
bool flag5 = !flag2;
if (flag5)
{
foreach (EmbeddedResource embeddedResource in list)
{
embeddedResource.Attributes = ManifestResourceAttributes.Public;
manifestModule.Resources.Add(embeddedResource);
this.ctx.Module.Resources.Add(new AssemblyLinkedResource(embeddedResource.Name, asmRef, embeddedResource.Attributes));
}
}
byte[] array;
using (MemoryStream memoryStream = new MemoryStream())
{
manifestModule.Write(memoryStream, new ModuleWriterOptions
{
StrongNameKey = moduleWriterBase.TheOptions.StrongNameKey
});
array = memoryStream.ToArray();
}
array = this.ctx.Context.Registry.GetService <ICompressionService>().Compress(array, delegate(double progress)
{
this.ctx.Context.Logger.Progress((int)(progress * 10000.0), 10000);
});
this.ctx.Context.Logger.EndProgress();
this.ctx.Context.CheckCancellation();
uint num = (uint)((array.Length + 3) / 4);
num = (num + 15u & 4294967280u);
uint[] array2 = new uint[num];
Buffer.BlockCopy(array, 0, array2, 0, array.Length);
Debug.Assert(num % 16u == 0u);
uint num2 = this.ctx.Random.NextUInt32() | 16u;
uint[] array3 = new uint[16];
uint num3 = num2;
for (int i = 0; i < 16; i++)
{
num3 ^= num3 >> 13;
num3 ^= num3 << 25;
num3 ^= num3 >> 27;
array3[i] = num3;
}
byte[] array4 = new byte[array2.Length * 4];
int j;
for (j = 0; j < array2.Length; j += 16)
{
uint[] src = this.ctx.ModeHandler.Encrypt(array2, j, array3);
for (int k = 0; k < 16; k++)
{
array3[k] ^= array2[j + k];
}
Buffer.BlockCopy(src, 0, array4, j * 4, 64);
}
Debug.Assert(j == array2.Length);
uint num4 = (uint)array4.Length;
TablesHeap tablesHeap = moduleWriterBase.MetaData.TablesHeap;
tablesHeap.ClassLayoutTable[moduleWriterBase.MetaData.GetClassLayoutRid(this.ctx.DataType)].ClassSize = num4;
RawFieldRow rawFieldRow = tablesHeap.FieldTable[moduleWriterBase.MetaData.GetRid(this.ctx.DataField)];
rawFieldRow.Flags |= 256;
this.encryptedResource = moduleWriterBase.Constants.Add(new ByteArrayChunk(array4), 8u);
MutationHelper.InjectKeys(this.ctx.InitMethod, new int[]
{
0,
1
}, new int[]
{
(int)(num4 / 4u),
(int)num2
});
}
else
{
bool flag6 = e.WriterEvent == ModuleWriterEvent.EndCalculateRvasAndFileOffsets;
if (flag6)
{
TablesHeap tablesHeap2 = moduleWriterBase.MetaData.TablesHeap;
tablesHeap2.FieldRVATable[moduleWriterBase.MetaData.GetFieldRVARid(this.ctx.DataField)].RVA = (uint)this.encryptedResource.RVA;
}
}
}
void OnWriterEvent(object sender, ModuleWriterListenerEventArgs e)
{
var writer = (ModuleWriterBase)sender;
if (e.WriterEvent == ModuleWriterEvent.MDBeginAddResources)
{
ctx.Context.CheckCancellation();
ctx.Context.Logger.Debug("Encrypting resources...");
bool hasPacker = ctx.Context.Packer != null;
List <EmbeddedResource> resources = ctx.Module.Resources.OfType <EmbeddedResource>().ToList();
if (!hasPacker)
{
ctx.Module.Resources.RemoveWhere(res => res is EmbeddedResource);
}
// move resources
string asmName = ctx.Name.RandomName(RenameMode.Letters);
PublicKey pubKey = null;
if (writer.TheOptions.StrongNameKey != null)
{
pubKey = PublicKeyBase.CreatePublicKey(writer.TheOptions.StrongNameKey.PublicKey);
}
var assembly = new AssemblyDefUser(asmName, new Version(0, 0), pubKey);
assembly.Modules.Add(new ModuleDefUser(asmName + ".dll"));
ModuleDef module = assembly.ManifestModule;
assembly.ManifestModule.Kind = ModuleKind.Dll;
var asmRef = new AssemblyRefUser(module.Assembly);
if (!hasPacker)
{
foreach (EmbeddedResource res in resources)
{
res.Attributes = ManifestResourceAttributes.Public;
module.Resources.Add(res);
ctx.Module.Resources.Add(new AssemblyLinkedResource(res.Name, asmRef, res.Attributes));
}
}
byte[] moduleBuff;
using (var ms = new MemoryStream()) {
module.Write(ms, new ModuleWriterOptions {
StrongNameKey = writer.TheOptions.StrongNameKey
});
moduleBuff = ms.ToArray();
}
// compress
moduleBuff = ctx.Context.Registry.GetService <ICompressionService>().Compress(
moduleBuff,
progress => ctx.Context.Logger.Progress((int)(progress * 10000), 10000));
ctx.Context.Logger.EndProgress();
ctx.Context.CheckCancellation();
uint compressedLen = (uint)(moduleBuff.Length + 3) / 4;
compressedLen = (compressedLen + 0xfu) & ~0xfu;
var compressedBuff = new uint[compressedLen];
Buffer.BlockCopy(moduleBuff, 0, compressedBuff, 0, moduleBuff.Length);
Debug.Assert(compressedLen % 0x10 == 0);
// encrypt
uint keySeed = ctx.Random.NextUInt32() | 0x10;
var key = new uint[0x10];
uint state = keySeed;
for (int i = 0; i < 0x10; i++)
{
state ^= state >> 13;
state ^= state << 25;
state ^= state >> 27;
key[i] = state;
}
var encryptedBuffer = new byte[compressedBuff.Length * 4];
int buffIndex = 0;
while (buffIndex < compressedBuff.Length)
{
uint[] enc = ctx.ModeHandler.Encrypt(compressedBuff, buffIndex, key);
for (int j = 0; j < 0x10; j++)
{
key[j] ^= compressedBuff[buffIndex + j];
}
Buffer.BlockCopy(enc, 0, encryptedBuffer, buffIndex * 4, 0x40);
buffIndex += 0x10;
}
Debug.Assert(buffIndex == compressedBuff.Length);
var size = (uint)encryptedBuffer.Length;
TablesHeap tblHeap = writer.MetaData.TablesHeap;
tblHeap.ClassLayoutTable[writer.MetaData.GetClassLayoutRid(ctx.DataType)].ClassSize = size;
tblHeap.FieldTable[writer.MetaData.GetRid(ctx.DataField)].Flags |= (ushort)FieldAttributes.HasFieldRVA;
encryptedResource = writer.Constants.Add(new ByteArrayChunk(encryptedBuffer), 8);
// inject key values
MutationHelper.InjectKeys(ctx.InitMethod,
new[] { 0, 1 },
new[] { (int)(size / 4), (int)(keySeed) });
}
else if (e.WriterEvent == ModuleWriterEvent.EndCalculateRvasAndFileOffsets)
{
TablesHeap tblHeap = writer.MetaData.TablesHeap;
tblHeap.FieldRVATable[writer.MetaData.GetFieldRVARid(ctx.DataField)].RVA = (uint)encryptedResource.RVA;
}
}
