// Token: 0x06000195 RID: 405 RVA: 0x0006142C File Offset: 0x0005F62C
protected override void Execute(ConfuserContext context, ProtectionParameters parameters)
{
bool flag = parameters.Targets.Any <IDnlibDef>();
if (flag)
{
bool flag2 = !UTF8String.IsNullOrEmpty(context.CurrentModule.Assembly.Culture);
if (flag2)
{
context.Logger.DebugFormat("Skipping resource encryption for satellite assembly '{0}'.", new object[]
{
context.CurrentModule.Assembly.FullName
});
}
else
{
ICompressionService service = context.Registry.GetService <ICompressionService>();
INameService name = context.Registry.GetService <INameService>();
IMarkerService marker = context.Registry.GetService <IMarkerService>();
IRuntimeService service2 = context.Registry.GetService <IRuntimeService>();
REContext recontext = new REContext
{
Random = context.Registry.GetService <IRandomService>().GetRandomGenerator(base.Parent.Id),
Context = context,
Module = context.CurrentModule,
Marker = marker,
DynCipher = context.Registry.GetService <IDynCipherService>(),
Name = name
};
recontext.Mode = parameters.GetParameter <Mode>(context, context.CurrentModule, "mode", Mode.Normal);
Mode mode = recontext.Mode;
if (mode != Mode.Normal)
{
if (mode != Mode.Dynamic)
{
throw new UnreachableException();
}
recontext.ModeHandler = new DynamicMode();
}
else
{
recontext.ModeHandler = new NormalMode();
}
MethodDef runtimeDecompressor = service.GetRuntimeDecompressor(context.CurrentModule, delegate(IDnlibDef member)
{
name.MarkHelper(member, marker, (Protection)this.Parent);
bool flag3 = member is MethodDef;
if (flag3)
{
ProtectionParameters.GetParameters(context, member).Remove(this.Parent);
}
});
this.InjectHelpers(context, service, service2, recontext);
this.MutateInitializer(recontext, runtimeDecompressor);
MethodDef methodDef = context.CurrentModule.GlobalType.FindStaticConstructor();
methodDef.Body.Instructions.Insert(0, Instruction.Create(OpCodes.Call, recontext.InitMethod));
new MDPhase(recontext).Hook();
}
}
}
protected DataProcessingPipelineBase(IItemSerializerService serializerService, IEncryptionService encryptionService,
ICompressionService compressionService)
{
_serializerService = serializerService;
_encryptionService = encryptionService;
_compressionService = compressionService;
}
void InjectHelpers(ConfuserContext context, ICompressionService compression, IRuntimeService rt, REContext moduleCtx) {
var rtName = context.Packer != null ? "Confuser.Runtime.Resource_Packer" : "Confuser.Runtime.Resource";
IEnumerable<IDnlibDef> members = InjectHelper.Inject(rt.GetRuntimeType(rtName), context.CurrentModule.GlobalType, context.CurrentModule);
foreach (IDnlibDef member in members) {
if (member.Name == "Initialize")
moduleCtx.InitMethod = (MethodDef)member;
moduleCtx.Name.MarkHelper(member, moduleCtx.Marker, (Protection)Parent);
}
var dataType = new TypeDefUser("", moduleCtx.Name.RandomName(), context.CurrentModule.CorLibTypes.GetTypeRef("System", "ValueType"));
dataType.Layout = TypeAttributes.ExplicitLayout;
dataType.Visibility = TypeAttributes.NestedPrivate;
dataType.IsSealed = true;
dataType.ClassLayout = new ClassLayoutUser(1, 0);
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,
HasFieldRVA = true,
InitialValue = new byte[0],
Access = FieldAttributes.CompilerControlled
};
context.CurrentModule.GlobalType.Fields.Add(moduleCtx.DataField);
moduleCtx.Name.MarkHelper(moduleCtx.DataField, moduleCtx.Marker, (Protection)Parent);
}
private static void Run(ICompressionService compressionService)
{
var run = true;
while (run)
{
Console.WriteLine("Выберите действие: 1 - сжатие, 2 - распаковка, 3 - выход");
switch (Console.ReadLine())
{
case "1":
Compress(compressionService);
break;
case "2":
Decompress(compressionService);
break;
case "3":
run = false;
break;
default:
Console.WriteLine("Введено некорректное значение");
break;
}
}
}
void InjectHelpers(ConfuserContext context, ICompressionService compression, IRuntimeService rt, REContext moduleCtx)
{
var rtName = context.Packer != null ? "Confuser.Runtime.Resource_Packer" : "Confuser.Runtime.Resource";
IEnumerable <IDnlibDef> members = Core.Helpers.InjectHelper.Inject(rt.GetRuntimeType(rtName), context.CurrentModule.GlobalType, context.CurrentModule);
foreach (IDnlibDef member in members)
{
if (member.Name == "Initialize")
{
moduleCtx.InitMethod = (MethodDef)member;
}
moduleCtx.Name.MarkHelper(member, moduleCtx.Marker, (Protection)Parent);
}
var dataType = new TypeDefUser("", moduleCtx.Name.RandomName(), context.CurrentModule.CorLibTypes.GetTypeRef("System", "ValueType"));
dataType.Layout = TypeAttributes.ExplicitLayout;
dataType.Visibility = TypeAttributes.NestedPrivate;
dataType.IsSealed = true;
dataType.ClassLayout = new ClassLayoutUser(1, 0);
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,
HasFieldRVA = true,
InitialValue = new byte[0],
Access = FieldAttributes.CompilerControlled
};
context.CurrentModule.GlobalType.Fields.Add(moduleCtx.DataField);
moduleCtx.Name.MarkHelper(moduleCtx.DataField, moduleCtx.Marker, (Protection)Parent);
}
public DataProcessingInformations(IItemSerializerService serializerService, IEncryptionService encryptionService,
ICompressionService compressionService)
{
this.SerializerServiceId = serializerService.Identifier;
this.EncryptionServiceId = encryptionService.Identifier;
this.CompressionServiceId = encryptionService.Identifier;
}
// Token: 0x06000196 RID: 406 RVA: 0x000616C4 File Offset: 0x0005F8C4
private void InjectHelpers(ConfuserContext context, ICompressionService compression, IRuntimeService rt, REContext moduleCtx)
{
string fullName = (context.Packer != null) ? "Confuser.Runtime.Resource_Packer" : "Confuser.Runtime.Resource";
IEnumerable <IDnlibDef> enumerable = InjectHelper.Inject(rt.GetRuntimeType(fullName), context.CurrentModule.GlobalType, context.CurrentModule);
foreach (IDnlibDef dnlibDef in enumerable)
{
bool flag = dnlibDef.Name == "Initialize";
if (flag)
{
moduleCtx.InitMethod = (MethodDef)dnlibDef;
}
moduleCtx.Name.MarkHelper(dnlibDef, moduleCtx.Marker, (Protection)base.Parent);
}
TypeDefUser typeDefUser = new TypeDefUser("", moduleCtx.Name.RandomName(), context.CurrentModule.CorLibTypes.GetTypeRef("System", "ValueType"));
typeDefUser.Layout = TypeAttributes.ExplicitLayout;
typeDefUser.Visibility = TypeAttributes.NestedPrivate;
typeDefUser.IsSealed = true;
typeDefUser.ClassLayout = new ClassLayoutUser(1, 0u);
moduleCtx.DataType = typeDefUser;
context.CurrentModule.GlobalType.NestedTypes.Add(typeDefUser);
moduleCtx.Name.MarkHelper(typeDefUser, moduleCtx.Marker, (Protection)base.Parent);
moduleCtx.DataField = new FieldDefUser(moduleCtx.Name.RandomName(), new FieldSig(typeDefUser.ToTypeSig()))
{
IsStatic = true,
HasFieldRVA = true,
InitialValue = new byte[0],
Access = FieldAttributes.PrivateScope
};
context.CurrentModule.GlobalType.Fields.Add(moduleCtx.DataField);
moduleCtx.Name.MarkHelper(moduleCtx.DataField, moduleCtx.Marker, (Protection)base.Parent);
}
public DocumentContentService(ICompressionService compressionService, IEncryptionService encryptionService, IDocumentContentRepository repo)
{
_compressionService = compressionService;
_encryptionService = encryptionService;
_repo = repo;
_contentTypeProvider = new FileExtensionContentTypeProvider();
}
static Program()
{
var cancellationToken = new CancellationTokenSource();
logger = new ConsoleLogger();
parsingService = new ParsingService(logger);
compressionService = new CompressionService(cancellationToken, logger);
}
public ParallelCompressionService(
ICompressionService compressionService,
IStatusUpdateService statusUpdateService,
IInputOverflowControlSettings inputOverflowControlSettings)
{
_compressionService = compressionService;
_statusUpdateService = statusUpdateService;
_inputOverflowControlSettings = inputOverflowControlSettings;
}
public void Setup()
{
var cancellationTokenSource = new CancellationTokenSource();
var mockLogger = new Mock <ILogger>();
mockLogger.Setup(foo => foo.Warning(It.IsAny <string>()));
mockLogger.Setup(foo => foo.Error(It.IsAny <string>()));
compressionService = new CompressionService(cancellationTokenSource, mockLogger.Object);
}
private static void Decompress(ICompressionService compressionService)
{
try
{
Console.WriteLine("Укажите путь к файлу gz.info архива");
var pathOfDestenationFileDecompression = Console.ReadLine();
Console.WriteLine("Распаковка...");
compressionService.Decompression(pathOfDestenationFileDecompression);
Console.WriteLine("Файл успешно распакован");
Console.WriteLine("Для продолжения нажмите Enter");
Console.Read();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
public byte[] Encrypt(ICompressionService compress, byte[] data, uint seed, Action <double> progressFunc)
{
data = (byte[])data.Clone();
var dst = new uint[0x10];
var src = new uint[0x10];
ulong state = seed;
for (var i = 0; i < 0x10; i++)
{
state = (state * state) % 0x143fc089;
src[i] = (uint)state;
dst[i] = (uint)((state * state) % 0x444d56fb);
}
var key = Deriver.DeriveKey(dst, src);
var z = (uint)(state % 0x8a5cb7);
for (var i = 0; i < data.Length; i++)
{
data[i] ^= (byte)state;
if ((i & 0xff) == 0)
{
state = (state * state) % 0x8a5cb7;
}
}
data = compress.Compress(data, progressFunc);
Array.Resize(ref data, (data.Length + 3) & ~3);
var encryptedData = new byte[data.Length];
var keyIndex = 0;
for (var i = 0; i < data.Length; i += 4)
{
var datum = (uint)(data[i + 0] | (data[i + 1] << 8) | (data[i + 2] << 16) | (data[i + 3] << 24));
var encrypted = datum ^ key[keyIndex & 0xf];
key[keyIndex & 0xf] = (key[keyIndex & 0xf] ^ datum) + 0x3ddb2819;
encryptedData[i + 0] = (byte)(encrypted >> 0);
encryptedData[i + 1] = (byte)(encrypted >> 8);
encryptedData[i + 2] = (byte)(encrypted >> 16);
encryptedData[i + 3] = (byte)(encrypted >> 24);
keyIndex++;
}
return(encryptedData);
}
private static void Compress(ICompressionService compressionService)
{
try
{
Console.WriteLine("Укажите путь к исходному файлу, включая полное имя файла и расширение");
var pathOfSourceFile = Console.ReadLine();
Console.WriteLine("Укажите путь назначения");
var pathOfDestenationFile = Console.ReadLine();
Console.WriteLine("Сжатие...");
var startTime = System.Diagnostics.Stopwatch.StartNew();
compressionService.Compression(pathOfSourceFile, pathOfDestenationFile);
var resultTime = startTime.Elapsed;
Console.WriteLine($"Файл успешно сжат. Время сжатия: \"{resultTime.Hours:00}:{resultTime.Minutes:00}:{resultTime.Seconds:00}.{resultTime.Milliseconds:000}\"");
Console.WriteLine("Для продолжения нажмите Enter");
Console.ReadLine();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
public byte[] Encrypt(ICompressionService compress, byte[] data, uint seed, Action<double> progressFunc)
{
data = (byte[])data.Clone();
var dst = new uint[0x10];
var src = new uint[0x10];
ulong state = seed;
for (int i = 0; i < 0x10; i++) {
state = (state * state) % 0x143fc089;
src[i] = (uint)state;
dst[i] = (uint)((state * state) % 0x444d56fb);
}
uint[] key = Deriver.DeriveKey(dst, src);
var z = (uint)(state % 0x8a5cb7);
for (int i = 0; i < data.Length; i++) {
data[i] ^= (byte)state;
if ((i & 0xff) == 0)
state = (state * state) % 0x8a5cb7;
}
data = compress.Compress(data, progressFunc);
Array.Resize(ref data, (data.Length + 3) & ~3);
var encryptedData = new byte[data.Length];
int keyIndex = 0;
for (int i = 0; i < data.Length; i += 4) {
var datum = (uint)(data[i + 0] | (data[i + 1] << 8) | (data[i + 2] << 16) | (data[i + 3] << 24));
uint encrypted = datum ^ key[keyIndex & 0xf];
key[keyIndex & 0xf] = (key[keyIndex & 0xf] ^ datum) + 0x3ddb2819;
encryptedData[i + 0] = (byte)(encrypted >> 0);
encryptedData[i + 1] = (byte)(encrypted >> 8);
encryptedData[i + 2] = (byte)(encrypted >> 16);
encryptedData[i + 3] = (byte)(encrypted >> 24);
keyIndex++;
}
return encryptedData;
}
public SettingsHelper(ISettingsAdapter adapter)
{
_adapter = adapter;
_compressionService = Central.Container.Resolve <ICompressionService>();
_serializationService = adapter.SerializationService;
}
public DataProcessingPipeline(IItemSerializerService serializerService, IEncryptionService encryptionService, ICompressionService compressionService) : base(serializerService, encryptionService, compressionService)
{
}
public DataService(ICompressionService compressionService, PageService pageService)
{
_compressionService = compressionService;
_pageService = pageService;
}
void PackModules(ConfuserContext 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();
}
public DownloadDocumentCommandHandler(IBus bus, ICompressionService compressionService)
{
this.bus = bus;
this.compressionService = compressionService;
}
public DataProcessingPipeline(ICompressionService compressionService, IEncryptionService encryptionService)
{
_compressionService = compressionService;
_encryptionService = encryptionService;
}
protected override void Execute(ConfuserContext context, ProtectionParameters parameters)
{
Virtualizer vr = context.Annotations.Get <Virtualizer>(context, Fish.VirtualizerKey);
IMarkerService marker = context.Registry.GetService <IMarkerService>();
IReferenceProxyService refProxy = context.Registry.GetService <IReferenceProxyService>();
IAntiTamperService antiTamper = context.Registry.GetService <IAntiTamperService>();
ICompressionService compression = context.Registry.GetService <ICompressionService>();
var methods = new HashSet <MethodDef>(parameters.Targets.OfType <MethodDef>());
var refRepl = new Dictionary <IMemberRef, IMemberRef>();
TypeDef oldType = context.CurrentModule.GlobalType;
var newType = new TypeDefUser(oldType.Name);
oldType.Namespace = "What_a_great_VM";
oldType.Name = "VM";
oldType.BaseType = context.CurrentModule.CorLibTypes.GetTypeRef("System", "Object");
context.CurrentModule.Types.Insert(0, newType);
MethodDef old_cctor = oldType.FindOrCreateStaticConstructor();
MethodDef cctor = newType.FindOrCreateStaticConstructor();
old_cctor.Name = "Load";
old_cctor.IsRuntimeSpecialName = false;
old_cctor.IsSpecialName = false;
old_cctor.Access = MethodAttributes.PrivateScope;
cctor.Body = new CilBody(true, new List <Instruction>
{
Instruction.Create(OpCodes.Call, old_cctor),
Instruction.Create(OpCodes.Ret)
}, new List <ExceptionHandler>(), new List <Local>());
marker.Mark(cctor, this.Parent);
antiTamper.ExcludeMethod(context, cctor);
for (int i = 0; i < oldType.Methods.Count; i++)
{
MethodDef nativeMethod = oldType.Methods[i];
if (nativeMethod.IsNative)
{
var methodStub = new MethodDefUser(nativeMethod.Name, nativeMethod.MethodSig.Clone());
methodStub.Attributes = MethodAttributes.Assembly | MethodAttributes.Static;
methodStub.Body = new CilBody();
methodStub.Body.Instructions.Add(new Instruction(OpCodes.Jmp, nativeMethod));
methodStub.Body.Instructions.Add(new Instruction(OpCodes.Ret));
oldType.Methods[i] = methodStub;
newType.Methods.Add(nativeMethod);
refRepl[nativeMethod] = methodStub;
marker.Mark(methodStub, this.Parent);
antiTamper.ExcludeMethod(context, methodStub);
}
}
compression.TryGetRuntimeDecompressor(context.CurrentModule, def =>
{
if (def is MethodDef)
{
methods.Remove((MethodDef)def);
}
});
var toProcess = new Dictionary <ModuleDef, List <MethodDef> >();
foreach (System.Tuple <MethodDef, bool> entry in new Scanner(context.CurrentModule, methods).Scan().WithProgress(context.Logger))
{
bool isExport = entry.Item2;
isExport |= context.Annotations.Get <object>(entry.Item1, Fish.ExportKey) != null;
isExport |= refProxy.IsTargeted(context, entry.Item1);
if (!isExport)
{
antiTamper.ExcludeMethod(context, entry.Item1);
}
vr.AddMethod(entry.Item1, isExport);
toProcess.AddListEntry(entry.Item1.Module, entry.Item1);
context.CheckCancellation();
}
context.CurrentModuleWriterListener.OnWriterEvent += new Listener
{
ctx = context,
vr = vr,
methods = toProcess,
refRepl = refRepl
}.OnWriterEvent;
}
public RelativeApiService(string host, string name, string apiKey, ISerializerService serializer, ICompressionService compressionService, IGeneralDataService generalDataService, IHttpClientFactory httpClientFactory) : base(host, name, apiKey, serializer, compressionService, generalDataService, httpClientFactory)
{
}
public MembershipServiceApi(IAppSettings setting, ISerializerService serializer, ICompressionService compressionService, IGeneralDataService generalDataService, IHttpClientFactory httpClientFactory)
{
this.SystemLinkedUserApiService = new System.LinkedUserApiService(setting.MembershipService.Host, "ERPMembershipService", setting.MembershipService.ApiKey, serializer, compressionService, generalDataService, httpClientFactory);
this.SystemUserApiService = new System.UserApiService(setting.MembershipService.Host, "ERPMembershipService", setting.MembershipService.ApiKey, serializer, compressionService, generalDataService, httpClientFactory);
this.MembershipFeatureApiService = new Membership.FeatureApiService(setting.MembershipService.Host, "ERPMembershipService", setting.MembershipService.ApiKey, serializer, compressionService, generalDataService, httpClientFactory);
this.MembershipLinkedUserApiService = new Membership.LinkedUserApiService(setting.MembershipService.Host, "ERPMembershipService", setting.MembershipService.ApiKey, serializer, compressionService, generalDataService, httpClientFactory);
this.MembershipPermissionApiService = new Membership.PermissionApiService(setting.MembershipService.Host, "ERPMembershipService", setting.MembershipService.ApiKey, serializer, compressionService, generalDataService, httpClientFactory);
this.MembershipRelativeApiService = new Membership.RelativeApiService(setting.MembershipService.Host, "ERPMembershipService", setting.MembershipService.ApiKey, serializer, compressionService, generalDataService, httpClientFactory);
this.MembershipRoleApiService = new Membership.RoleApiService(setting.MembershipService.Host, "ERPMembershipService", setting.MembershipService.ApiKey, serializer, compressionService, generalDataService, httpClientFactory);
this.MembershipUserApiService = new Membership.UserApiService(setting.MembershipService.Host, "ERPMembershipService", setting.MembershipService.ApiKey, serializer, compressionService, generalDataService, httpClientFactory);
this.AuthAuthApiService = new Auth.AuthApiService(setting.MembershipService.Host, "ERPMembershipService", setting.MembershipService.ApiKey, serializer, compressionService, generalDataService, httpClientFactory);
}
public RoamingFileSettingsAdapter(ISerializationService serializationService, ICompressionService compressionService)
{
_helper = new FileService(serializationService);
SerializationService = serializationService;
CompressionService = compressionService;
}
public SettingsHelper(ISettingsAdapter adapter)
{
_adapter = adapter;
_compressionService = adapter.CompressionService;
_serializationService = adapter.SerializationService;
}
public SettingsHelper(ISettingsAdapter adapter)
{
_adapter = adapter;
_compressionService = PrismApplicationBase.Container.Resolve <ICompressionService>();
_serializationService = adapter.SerializationService;
}
private void InjectHelpers(ConfuserContext context, ICompressionService compression, IRuntimeService rt, CEContext moduleCtx)
{
IEnumerable<IDnlibDef> members = InjectHelper.Inject(rt.GetRuntimeType("Confuser.Runtime.Constant"), context.CurrentModule.GlobalType, context.CurrentModule);
foreach (IDnlibDef 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);
}
ProtectionParameters.GetParameters(context, moduleCtx.InitMethod).Remove(Parent);
var dataType = new TypeDefUser("", moduleCtx.Name.RandomName(), context.CurrentModule.CorLibTypes.GetTypeRef("System", "ValueType"));
dataType.Layout = TypeAttributes.ExplicitLayout;
dataType.Visibility = TypeAttributes.NestedPrivate;
dataType.IsSealed = true;
moduleCtx.DataType = dataType;
context.CurrentModule.GlobalType.NestedTypes.Add(dataType);
moduleCtx.Name.MarkHelper(dataType, moduleCtx.Marker);
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);
MethodDef decoder = rt.GetRuntimeType("Confuser.Runtime.Constant").FindMethod("Get");
moduleCtx.Decoders = new List<Tuple<MethodDef, DecoderDesc>>();
for (int i = 0; i < moduleCtx.DecoderCount; i++) {
MethodDef decoderInst = InjectHelper.Inject(decoder, context.CurrentModule);
for (int j = 0; j < decoderInst.Body.Instructions.Count; j++) {
Instruction 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);
ProtectionParameters.GetParameters(context, decoderInst).Remove(Parent);
var decoderDesc = new DecoderDesc();
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 EasyCache(IDistributedCache distributedCache, ICompressionService compressionService)
{
_distributedCache = distributedCache ?? throw new ArgumentNullException(nameof(distributedCache));
_compressionService = compressionService ?? throw new ArgumentNullException(nameof(compressionService));
}
public GitHubService(ICompressionService compressionService)
{
this.compressionService = compressionService;
}
public RoamingSettingsAdapter(ISerializationService serializationService, ICompressionService compressionService)
{
_container = ApplicationData.Current.RoamingSettings;
SerializationService = serializationService;
CompressionService = compressionService;
}
public ExportCommand(SessionContext sessionContext, ICompressionService compressionService)
: base(sessionContext)
{
this.compressionService = compressionService;
}
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));
}
}
void PackModules(ConfuserContext 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 name = context.Modules[i].Assembly.Name.ToUpperInvariant();
modules.Add(name, context.OutputModules[i]);
int strLen = Encoding.UTF8.GetByteCount(name);
if (strLen > maxLen)
maxLen = strLen;
}
foreach (var extModule in context.ExternalModules) {
var name = GetName(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();
}
