protected internal override void Execute(DotProtectContext context, ProtectionParameters parameters)
{
RandomGenerator random = context.Registry.GetService <IRandomService>().GetRandomGenerator(ReferenceProxyProtection._FullId);
var store = new RPStore {
random = random
};
foreach (MethodDef method in parameters.Targets.OfType <MethodDef>().WithProgress(context.Logger))
{
if (method.HasBody && method.Body.Instructions.Count > 0)
{
ProcessMethod(ParseParameters(method, context, parameters, store));
context.CheckCancellation();
}
}
RPContext ctx = ParseParameters(context.CurrentModule, context, parameters, store);
if (store.mild != null)
{
store.mild.Finalize(ctx);
}
if (store.strong != null)
{
store.strong.Finalize(ctx);
}
}
protected internal override void Pack(DotProtectContext context, ProtectionParameters parameters)
{
var ctx = context.Annotations.Get <CompressorContext>(context, ContextKey);
if (ctx == null)
{
context.Logger.Error("No executable module!");
throw new DotProtectception(null);
}
ModuleDefMD originModule = context.Modules[ctx.ModuleIndex];
ctx.OriginModuleDef = originModule;
var stubModule = new ModuleDefUser(ctx.ModuleName, originModule.Mvid, originModule.CorLibTypes.AssemblyRef);
if (ctx.CompatMode)
{
var assembly = new AssemblyDefUser(originModule.Assembly);
assembly.Name += ".cr";
assembly.Modules.Add(stubModule);
}
else
{
ctx.Assembly.Modules.Insert(0, stubModule);
ImportAssemblyTypeReferences(originModule, stubModule);
}
stubModule.Characteristics = originModule.Characteristics;
stubModule.Cor20HeaderFlags = originModule.Cor20HeaderFlags;
stubModule.Cor20HeaderRuntimeVersion = originModule.Cor20HeaderRuntimeVersion;
stubModule.DllCharacteristics = originModule.DllCharacteristics;
stubModule.EncBaseId = originModule.EncBaseId;
stubModule.EncId = originModule.EncId;
stubModule.Generation = originModule.Generation;
stubModule.Kind = ctx.Kind;
stubModule.Machine = originModule.Machine;
stubModule.RuntimeVersion = originModule.RuntimeVersion;
stubModule.TablesHeaderVersion = originModule.TablesHeaderVersion;
stubModule.Win32Resources = originModule.Win32Resources;
InjectStub(context, ctx, parameters, stubModule);
var snKey = context.Annotations.Get <StrongNameKey>(originModule, Marker.SNKey);
using (var ms = new MemoryStream()) {
stubModule.Write(ms, new ModuleWriterOptions(stubModule, new KeyInjector(ctx))
{
StrongNameKey = snKey
});
context.CheckCancellation();
ProtectStub(context, context.OutputPaths[ctx.ModuleIndex], ms.ToArray(), snKey, new StubProtection(ctx, originModule));
}
}
protected internal override void Execute(DotProtectContext context, ProtectionParameters parameters)
{
var service = (NameService)context.Registry.GetService <INameService>();
context.Logger.Debug("Building VTables & identifier list...");
foreach (IDnlibDef def in parameters.Targets.WithProgress(context.Logger))
{
ParseParameters(def, context, service, parameters);
if (def is ModuleDef)
{
var module = (ModuleDef)def;
foreach (Resource res in module.Resources)
{
service.SetOriginalName(res, res.Name);
}
}
else
{
service.SetOriginalName(def, def.Name);
}
if (def is TypeDef)
{
service.GetVTables().GetVTable((TypeDef)def);
service.SetOriginalNamespace(def, ((TypeDef)def).Namespace);
}
context.CheckCancellation();
}
context.Logger.Debug("Analyzing...");
RegisterRenamers(context, service);
IList <IRenamer> renamers = service.Renamers;
foreach (IDnlibDef def in parameters.Targets.WithProgress(context.Logger))
{
Analyze(service, context, parameters, def, true);
context.CheckCancellation();
}
}
protected internal override void Execute(DotProtectContext context, ProtectionParameters parameters)
{
var service = (NameService)context.Registry.GetService <INameService>();
foreach (IRenamer renamer in service.Renamers)
{
foreach (IDnlibDef def in parameters.Targets)
{
renamer.PostRename(context, service, parameters, def);
}
context.CheckCancellation();
}
}
protected internal override void Execute(DotProtectContext context, ProtectionParameters parameters)
{
bool disabledOpti = DisabledOptimization(context.CurrentModule);
RandomGenerator random = context.Registry.GetService <IRandomService>().GetRandomGenerator(ControlFlowProtection._FullId);
foreach (MethodDef method in parameters.Targets.OfType <MethodDef>().WithProgress(context.Logger))
{
if (method.HasBody && method.Body.Instructions.Count > 0)
{
ProcessMethod(method.Body, ParseParameters(method, context, parameters, random, disabledOpti));
context.CheckCancellation();
}
}
}
void CreateSection(ModuleWriterBase writer)
{
// move some PE parts to separate section to prevent it from being hashed
var peSection = new PESection("", 0x60000020);
bool moved = false;
uint alignment;
if (writer.StrongNameSignature != null)
{
alignment = writer.TextSection.Remove(writer.StrongNameSignature).Value;
peSection.Add(writer.StrongNameSignature, alignment);
moved = true;
}
var managedWriter = writer as ModuleWriter;
if (managedWriter != null)
{
if (managedWriter.ImportAddressTable != null)
{
alignment = writer.TextSection.Remove(managedWriter.ImportAddressTable).Value;
peSection.Add(managedWriter.ImportAddressTable, alignment);
moved = true;
}
if (managedWriter.StartupStub != null)
{
alignment = writer.TextSection.Remove(managedWriter.StartupStub).Value;
peSection.Add(managedWriter.StartupStub, alignment);
moved = true;
}
}
if (moved)
{
writer.Sections.Add(peSection);
}
// create section
var nameBuffer = new byte[8];
nameBuffer[0] = (byte)(name1 >> 0);
nameBuffer[1] = (byte)(name1 >> 8);
nameBuffer[2] = (byte)(name1 >> 16);
nameBuffer[3] = (byte)(name1 >> 24);
nameBuffer[4] = (byte)(name2 >> 0);
nameBuffer[5] = (byte)(name2 >> 8);
nameBuffer[6] = (byte)(name2 >> 16);
nameBuffer[7] = (byte)(name2 >> 24);
var newSection = new PESection(Encoding.ASCII.GetString(nameBuffer), 0xE0000040);
writer.Sections.Insert(random.NextInt32(writer.Sections.Count), newSection);
// random padding at beginning to prevent revealing hash key
newSection.Add(new ByteArrayChunk(random.NextBytes(0x10)), 0x10);
// create index
var bodyIndex = new JITBodyIndex(methods.Select(method => writer.MetaData.GetToken(method).Raw));
newSection.Add(bodyIndex, 0x10);
// save methods
foreach (MethodDef method in methods.WithProgress(context.Logger))
{
if (!method.HasBody)
{
continue;
}
MDToken token = writer.MetaData.GetToken(method);
var jitBody = new JITMethodBody();
var bodyWriter = new JITMethodBodyWriter(writer.MetaData, method.Body, jitBody, random.NextUInt32(), writer.MetaData.KeepOldMaxStack || method.Body.KeepOldMaxStack);
bodyWriter.Write();
jitBody.Serialize(token.Raw, key, fieldLayout);
bodyIndex.Add(token.Raw, jitBody);
method.Body = NopBody;
writer.MetaData.TablesHeap.MethodTable[token.Rid].ImplFlags |= (ushort)MethodImplAttributes.NoInlining;
context.CheckCancellation();
}
bodyIndex.PopulateSection(newSection);
// padding to prevent bad size due to shift division
newSection.Add(new ByteArrayChunk(new byte[4]), 4);
}
protected internal override void Execute(DotProtectContext context, ProtectionParameters parameters)
{
var service = (NameService)context.Registry.GetService <INameService>();
context.Logger.Debug("Renaming...");
foreach (IRenamer renamer in service.Renamers)
{
foreach (IDnlibDef def in parameters.Targets)
{
renamer.PreRename(context, service, parameters, def);
}
context.CheckCancellation();
}
var targets = parameters.Targets.ToList();
service.GetRandom().Shuffle(targets);
var pdbDocs = new HashSet <string>();
foreach (IDnlibDef def in targets.WithProgress(context.Logger))
{
if (def is ModuleDef && parameters.GetParameter(context, def, "rickroll", false))
{
RickRoller.CommenceRickroll(context, (ModuleDef)def);
}
bool canRename = service.CanRename(def);
RenameMode mode = service.GetRenameMode(def);
if (def is MethodDef)
{
var method = (MethodDef)def;
if ((canRename || method.IsConstructor) && parameters.GetParameter(context, def, "renameArgs", true))
{
foreach (ParamDef param in ((MethodDef)def).ParamDefs)
{
param.Name = null;
}
}
if (parameters.GetParameter(context, def, "renPdb", false) && method.HasBody)
{
foreach (var instr in method.Body.Instructions)
{
if (instr.SequencePoint != null && !pdbDocs.Contains(instr.SequencePoint.Document.Url))
{
instr.SequencePoint.Document.Url = service.ObfuscateName(instr.SequencePoint.Document.Url, mode);
pdbDocs.Add(instr.SequencePoint.Document.Url);
}
}
foreach (var local in method.Body.Variables)
{
if (!string.IsNullOrEmpty(local.Name))
{
local.Name = service.ObfuscateName(local.Name, mode);
}
}
method.Body.Scope = null;
}
}
if (!canRename)
{
continue;
}
IList <INameReference> references = service.GetReferences(def);
bool cancel = false;
foreach (INameReference refer in references)
{
cancel |= refer.ShouldCancelRename();
if (cancel)
{
break;
}
}
if (cancel)
{
continue;
}
if (def is TypeDef)
{
var typeDef = (TypeDef)def;
if (parameters.GetParameter(context, def, "flatten", true))
{
typeDef.Name = service.ObfuscateName(typeDef.FullName, mode);
typeDef.Namespace = "";
}
else
{
typeDef.Namespace = service.ObfuscateName(typeDef.Namespace, mode);
typeDef.Name = service.ObfuscateName(typeDef.Name, mode);
}
foreach (var param in typeDef.GenericParameters)
{
param.Name = ((char)(param.Number + 1)).ToString();
}
}
else if (def is MethodDef)
{
foreach (var param in ((MethodDef)def).GenericParameters)
{
param.Name = ((char)(param.Number + 1)).ToString();
}
def.Name = service.ObfuscateName(def.Name, mode);
}
else
{
def.Name = service.ObfuscateName(def.Name, mode);
}
foreach (INameReference refer in references.ToList())
{
if (!refer.UpdateNameReference(context, service))
{
context.Logger.ErrorFormat("Failed to update name reference on '{0}'.", def);
throw new DotProtectception(null);
}
}
context.CheckCancellation();
}
}
void ExtractConstants(
DotProtectContext context, ProtectionParameters parameters, CEContext moduleCtx,
Dictionary <object, List <Tuple <MethodDef, Instruction> > > ldc,
Dictionary <byte[], List <Tuple <MethodDef, Instruction> > > ldInit)
{
var dataFields = new HashSet <FieldDef>();
var fieldRefs = new HashSet <Instruction>();
foreach (MethodDef method in parameters.Targets.OfType <MethodDef>().WithProgress(context.Logger))
{
if (!method.HasBody)
{
continue;
}
moduleCtx.Elements = 0;
string elements = parameters.GetParameter(context, method, "elements", "SI");
foreach (char elem in elements)
{
switch (elem)
{
case 'S':
case 's':
moduleCtx.Elements |= EncodeElements.Strings;
break;
case 'N':
case 'n':
moduleCtx.Elements |= EncodeElements.Numbers;
break;
case 'P':
case 'p':
moduleCtx.Elements |= EncodeElements.Primitive;
break;
case 'I':
case 'i':
moduleCtx.Elements |= EncodeElements.Initializers;
break;
}
}
if (moduleCtx.Elements == 0)
{
continue;
}
foreach (Instruction instr in method.Body.Instructions)
{
bool eligible = false;
if (instr.OpCode == OpCodes.Ldstr && (moduleCtx.Elements & EncodeElements.Strings) != 0)
{
var operand = (string)instr.Operand;
if (string.IsNullOrEmpty(operand) && (moduleCtx.Elements & EncodeElements.Primitive) == 0)
{
continue;
}
eligible = true;
}
else if (instr.OpCode == OpCodes.Call && (moduleCtx.Elements & EncodeElements.Initializers) != 0)
{
var operand = (IMethod)instr.Operand;
if (operand.DeclaringType.DefinitionAssembly.IsCorLib() &&
operand.DeclaringType.Namespace == "System.Runtime.CompilerServices" &&
operand.DeclaringType.Name == "RuntimeHelpers" &&
operand.Name == "InitializeArray")
{
IList <Instruction> instrs = method.Body.Instructions;
int i = instrs.IndexOf(instr);
if (instrs[i - 1].OpCode != OpCodes.Ldtoken)
{
continue;
}
if (instrs[i - 2].OpCode != OpCodes.Dup)
{
continue;
}
if (instrs[i - 3].OpCode != OpCodes.Newarr)
{
continue;
}
if (instrs[i - 4].OpCode != OpCodes.Ldc_I4)
{
continue;
}
var dataField = instrs[i - 1].Operand as FieldDef;
if (dataField == null)
{
continue;
}
if (!dataField.HasFieldRVA || dataField.InitialValue == null)
{
continue;
}
// Prevent array length from being encoded
var arrLen = (int)instrs[i - 4].Operand;
if (ldc.ContainsKey(arrLen))
{
List <Tuple <MethodDef, Instruction> > list = ldc[arrLen];
list.RemoveWhere(entry => entry.Item2 == instrs[i - 4]);
if (list.Count == 0)
{
ldc.Remove(arrLen);
}
}
dataFields.Add(dataField);
fieldRefs.Add(instrs[i - 1]);
var value = new byte[dataField.InitialValue.Length + 4];
value[0] = (byte)(arrLen >> 0);
value[1] = (byte)(arrLen >> 8);
value[2] = (byte)(arrLen >> 16);
value[3] = (byte)(arrLen >> 24);
Buffer.BlockCopy(dataField.InitialValue, 0, value, 4, dataField.InitialValue.Length);
ldInit.AddListEntry(value, Tuple.Create(method, instr));
}
}
else if ((moduleCtx.Elements & EncodeElements.Numbers) != 0)
{
if (instr.OpCode == OpCodes.Ldc_I4)
{
var operand = (int)instr.Operand;
if ((operand >= -1 && operand <= 8) && (moduleCtx.Elements & EncodeElements.Primitive) == 0)
{
continue;
}
eligible = true;
}
else if (instr.OpCode == OpCodes.Ldc_I8)
{
var operand = (long)instr.Operand;
if ((operand >= -1 && operand <= 1) && (moduleCtx.Elements & EncodeElements.Primitive) == 0)
{
continue;
}
eligible = true;
}
else if (instr.OpCode == OpCodes.Ldc_R4)
{
var operand = (float)instr.Operand;
if ((operand == -1 || operand == 0 || operand == 1) && (moduleCtx.Elements & EncodeElements.Primitive) == 0)
{
continue;
}
eligible = true;
}
else if (instr.OpCode == OpCodes.Ldc_R8)
{
var operand = (double)instr.Operand;
if ((operand == -1 || operand == 0 || operand == 1) && (moduleCtx.Elements & EncodeElements.Primitive) == 0)
{
continue;
}
eligible = true;
}
}
if (eligible)
{
ldc.AddListEntry(instr.Operand, Tuple.Create(method, instr));
}
}
context.CheckCancellation();
}
RemoveDataFieldRefs(context, dataFields, fieldRefs);
}
protected internal override void Execute(DotProtectContext 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());
});
}
void InjectStub(DotProtectContext 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 ? "DotProtect.Runtime.CompressorCompat" : "DotProtect.Runtime.Compressor");
IEnumerable <IDnlibDef> defs = InjectHelper.Inject(rtType, stubModule.GlobalType, stubModule);
switch (parameters.GetParameter(context, context.CurrentModule, "key", Mode.Normal))
{
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 PackModules(DotProtectContext context, CompressorContext compCtx, ModuleDef stubModule, ICompressionService comp, RandomGenerator random)
{
int maxLen = 0;
var modules = new Dictionary <string, byte[]>();
for (int i = 0; i < context.OutputModules.Count; i++)
{
if (i == compCtx.ModuleIndex)
{
continue;
}
string id = GetId(context.Modules[i].Assembly);
modules.Add(id, context.OutputModules[i]);
int strLen = Encoding.UTF8.GetByteCount(id);
if (strLen > maxLen)
{
maxLen = strLen;
}
}
foreach (var extModule in context.ExternalModules)
{
var name = GetId(extModule).ToUpperInvariant();
modules.Add(name, extModule);
int strLen = Encoding.UTF8.GetByteCount(name);
if (strLen > maxLen)
{
maxLen = strLen;
}
}
byte[] key = random.NextBytes(4 + maxLen);
key[0] = (byte)(compCtx.EntryPointToken >> 0);
key[1] = (byte)(compCtx.EntryPointToken >> 8);
key[2] = (byte)(compCtx.EntryPointToken >> 16);
key[3] = (byte)(compCtx.EntryPointToken >> 24);
for (int i = 4; i < key.Length; i++) // no zero bytes
{
key[i] |= 1;
}
compCtx.KeySig = key;
int moduleIndex = 0;
foreach (var entry in modules)
{
byte[] name = Encoding.UTF8.GetBytes(entry.Key);
for (int i = 0; i < name.Length; i++)
{
name[i] *= key[i + 4];
}
uint state = 0x6fff61;
foreach (byte chr in name)
{
state = state * 0x5e3f1f + chr;
}
byte[] encrypted = compCtx.Encrypt(comp, entry.Value, state, progress => {
progress = (progress + moduleIndex) / modules.Count;
context.Logger.Progress((int)(progress * 10000), 10000);
});
context.CheckCancellation();
var resource = new EmbeddedResource(Convert.ToBase64String(name), encrypted, ManifestResourceAttributes.Private);
stubModule.Resources.Add(resource);
moduleIndex++;
}
context.Logger.EndProgress();
}
