public byte[] decrypt()
{
if (assemblyEncryptedResource == null)
{
return(null);
}
var reader = new BinaryReader(assemblyEncryptedResource.GetResourceStream());
var encryptedData = DeobUtils.gunzip(reader.BaseStream, reader.ReadInt32());
reader = new BinaryReader(new MemoryStream(encryptedData));
var serializedData = reader.ReadBytes(reader.ReadInt32());
for (int i = 0; i < serializedData.Length; i++)
{
serializedData[i] ^= 0xAD;
}
var encryptedAssembly = reader.ReadBytes((int)(reader.BaseStream.Length - reader.BaseStream.Position));
var passwordFinder = new PasswordFinder(serializedData);
PasswordInfo mainAsmPassword;
passwordFinder.find(out mainAsmPassword, out embedPassword);
return(decrypt(mainAsmPassword, encryptedAssembly));
}
Stream LoadBaml(Resource res, string name)
{
EmbeddedResource er = res as EmbeddedResource;
if (er != null)
{
Stream s = er.GetResourceStream();
s.Position = 0;
ResourcesFile resources;
try {
resources = new ResourcesFile(s);
} catch (ArgumentException) {
return(null);
}
foreach (var entry in resources.OrderBy(e => e.Key))
{
if (entry.Key == name)
{
if (entry.Value is Stream)
{
return((Stream)entry.Value);
}
if (entry.Value is byte[])
{
return(new MemoryStream((byte[])entry.Value));
}
}
}
}
return(null);
}
private static Dictionary <string, List <int> > GetIkvmExportsListsFromResource(EmbeddedResource extra)
{
Dictionary <string, List <int> > ikvmExportsLists = new Dictionary <string, List <int> >();
BinaryReader rdr = new BinaryReader(extra.GetResourceStream());
int assemblyCount = rdr.ReadInt32();
for (int i = 0; i < assemblyCount; i++)
{
var str = rdr.ReadString();
int typeCount = rdr.ReadInt32();
if (typeCount == 0)
{
ikvmExportsLists.Add(str, null);
}
else
{
var types = new List <int>();
ikvmExportsLists.Add(str, types);
for (int j = 0; j < typeCount; j++)
{
types.Add(rdr.ReadInt32());
}
}
}
return(ikvmExportsLists);
}
private Resource FixResxResource(
AssemblyDefinition containingAssembly,
EmbeddedResource er,
List <IResProcessor> resourcePrcessors,
IEmbeddedResourceProcessor embeddedResourceProcessor)
{
MemoryStream stream = (MemoryStream)er.GetResourceStream();
var output = new MemoryStream((int)stream.Length);
var rw = new ResourceWriter(output);
using (var rr = new ResReader(stream))
{
foreach (var res in rr)
{
foreach (var processor in resourcePrcessors)
{
if (processor.Process(res, containingAssembly, er, rr, rw))
{
break;
}
}
}
}
// do a final processing, if any, on the embeddedResource itself
embeddedResourceProcessor?.Process(er, rw);
rw.Generate();
output.Position = 0;
return(new EmbeddedResource(er.Name, er.Attributes, output));
}
protected override void LoadChildren()
{
EmbeddedResource er = this.Resource as EmbeddedResource;
if (er != null)
{
Stream s = er.GetResourceStream();
s.Position = 0;
ResourceReader reader;
try {
reader = new ResourceReader(s);
}
catch {
// NotSupportedException, IOException, BadImageFormatException, ArgumentException
// and any other possible exception
return;
}
try {
foreach (DictionaryEntry entry in reader.Cast <DictionaryEntry>().OrderBy(e => e.Key.ToString()))
{
ProcessResourceEntry(entry);
}
}
catch {
}
}
}
public bool TryGetMainResource(EmbeddedResource embeddedResource, string resourceName, out object value)
{
value = null;
if (values == null)
{
// Build cache of resources values
values = new Dictionary <EmbeddedResource, Dictionary <string, object> > ();
}
Dictionary <string, object> fileResources;
if (!values.TryGetValue(embeddedResource, out fileResources))
{
fileResources = new Dictionary <string, object> ();
using (Stream resourceStream = embeddedResource.GetResourceStream())
using (ResourceSet resourceSet = new ResourceSet(resourceStream)) {
foreach (DictionaryEntry entry in resourceSet)
{
fileResources.Add((string)entry.Key, entry.Value);
}
}
values.Add(embeddedResource, fileResources);
}
return(fileResources.TryGetValue(resourceName, out value));
}
public void Execute(TextViewContext context)
{
if (context.SelectedTreeNodes == null)
{
return;
}
AssemblyTreeNode node = (AssemblyTreeNode)context.SelectedTreeNodes[0];
AssemblyDefinition asm = AssemblyDefinition.ReadAssembly(node.LoadedAssembly.FileName);
ModuleDefinition module = asm.MainModule;
string assemblyPath = Path.GetDirectoryName(node.LoadedAssembly.FileName);
foreach (var resource in module.Resources)
{
if (!resource.Name.StartsWith("costura.") && !resource.Name.EndsWith(".dll.compressed"))
{
continue;
}
string fileName = assemblyPath + "/" + resource.Name.Substring(8, resource.Name.LastIndexOf(".compressed") - 8);
if (File.Exists(fileName))
{
// Assembly has already been decompressed and saved in the local path, just load it.
MainWindow.Instance.CurrentAssemblyList.OpenAssembly(fileName);
}
else
{
EmbeddedResource er = resource as EmbeddedResource;
MemoryStream memoryStream = DecompressEmbeddedAssembly(er.GetResourceStream());
WriteAssemblyToFile(memoryStream, fileName);
OpenAssemblyFromStream(memoryStream, fileName);
}
}
}
List <ResXDataNode> ReadResourceEntries(DecompileContext ctx)
{
var list = new List <ResXDataNode>();
try {
using (var reader = new ResourceReader(embeddedResource.GetResourceStream())) {
var iter = reader.GetEnumerator();
while (iter.MoveNext())
{
ctx.CancellationToken.ThrowIfCancellationRequested();
string key = null;
try {
key = iter.Key as string;
if (key == null)
{
continue;
}
//TODO: Some resources, like images, should be saved as separate files. Use ResXFileRef.
// Don't do it if it's a satellite assembly.
list.Add(new ResXDataNode(key, iter.Value, TypeNameConverter));
}
catch (Exception ex) {
ctx.Logger.Error(string.Format("Could not add resource '{0}', Message: {1}", key, ex.Message));
}
}
}
}
catch (Exception ex) {
ctx.Logger.Error(string.Format("Could not read resources from {0}, Message: {1}", embeddedResource.Name, ex.Message));
}
return(list);
}
public static int GetResourcesCount(Dictionary <ModuleDefinition, Collection <Resource> > resources, bool decompileDangerousResources)
{
int result = 0;
foreach (Collection <Resource> moduleResources in resources.Values)
{
foreach (Resource resource in moduleResources)
{
if (!decompileDangerousResources && DangerousResourceIdentifier.IsDangerousResource(resource))
{
continue;
}
if (resource.ResourceType != ResourceType.Embedded)
{
continue;
}
EmbeddedResource embeddedResource = (EmbeddedResource)resource;
if (resource.Name.EndsWith(".g.resources", StringComparison.OrdinalIgnoreCase))
{
using (ResourceReader resourceReader = new ResourceReader(embeddedResource.GetResourceStream()))
{
result += resourceReader.OfType <System.Collections.DictionaryEntry>().Count();
}
}
else
{
result++;
}
}
}
return(result);
}
public static void ExtractResource(ModuleDefinition module, string name, string path, bool remove)
{
for (int i = 0; i < module.Resources.Count; i++)
{
EmbeddedResource embedded = module.Resources[i] as EmbeddedResource;
if (embedded == null || embedded.Name != name)
{
continue;
}
string dirname = Path.GetDirectoryName(path);
if (!Directory.Exists(dirname))
{
Directory.CreateDirectory(dirname);
}
using (Stream ostream = File.OpenWrite(path)) {
embedded.GetResourceStream().CopyTo(ostream);
}
if (remove)
{
module.Resources.RemoveAt(i);
}
break;
}
}
private (string, string) ReadResource(EmbeddedResource resource)
{
using (var s = new StreamReader(resource.GetResourceStream()))
{
return(resource.Name, s.ReadToEnd());
}
}
public void Decrypt(ResourceDecrypter resourceDecrypter, ISimpleDeobfuscator simpleDeobfuscator)
{
if (decryptMethod == null)
{
return;
}
resource = CoUtils.GetResource(module, decrypterCctor);
if (resource == null)
{
return;
}
var decrypted = resourceDecrypter.Decrypt(resource.GetResourceStream());
var reader = MemoryImageStream.Create(decrypted);
int numEncrypted = reader.ReadInt32();
Logger.v("Restoring {0} encrypted methods", numEncrypted);
Logger.Instance.Indent();
for (int i = 0; i < numEncrypted; i++)
{
int delegateTypeToken = reader.ReadInt32();
uint codeOffset = reader.ReadUInt32();
var origOffset = reader.Position;
reader.Position = codeOffset;
Decrypt(reader, delegateTypeToken, simpleDeobfuscator);
reader.Position = origOffset;
}
Logger.Instance.DeIndent();
}
public override bool View(DecompilerTextView textView)
{
EmbeddedResource er = r as EmbeddedResource;
if (er != null)
{
Stream s = er.GetResourceStream();
if (s != null && s.Length < DecompilerTextView.DefaultOutputLengthLimit)
{
s.Position = 0;
FileType type = GuessFileType.DetectFileType(s);
if (type != FileType.Binary)
{
s.Position = 0;
AvalonEditTextOutput output = new AvalonEditTextOutput();
output.Write(FileReader.OpenStream(s, Encoding.UTF8).ReadToEnd());
string ext;
if (type == FileType.Xml)
{
ext = ".xml";
}
else
{
ext = Path.GetExtension(DecompilerTextView.CleanUpName(er.Name));
}
textView.ShowNode(output, this, HighlightingManager.Instance.GetDefinitionByExtension(ext));
return(true);
}
}
}
return(false);
}
public override bool Save(DecompilerTextView textView)
{
EmbeddedResource er = this.Resource as EmbeddedResource;
if (er != null)
{
SaveFileDialog dlg = new SaveFileDialog();
dlg.FileName = DecompilerTextView.CleanUpName(er.Name);
dlg.Filter = "Resources file (*.resources)|*.resources|Resource XML file|*.resx";
if (dlg.ShowDialog() == true)
{
Stream s = er.GetResourceStream();
s.Position = 0;
switch (dlg.FilterIndex)
{
case 1:
using (var fs = dlg.OpenFile()) {
s.CopyTo(fs);
}
break;
case 2:
using (var writer = new ResXResourceWriter(dlg.OpenFile())) {
foreach (var entry in new ResourcesFile(s))
{
writer.AddResource(entry.Key, entry.Value);
}
}
break;
}
}
return(true);
}
return(false);
}
protected override void LoadChildren()
{
EmbeddedResource er = this.Resource as EmbeddedResource;
if (er != null)
{
Stream s = er.GetResourceStream();
s.Position = 0;
ResourceReader reader;
try {
reader = new ResourceReader(s);
}
catch (ArgumentException) {
return;
}
foreach (DictionaryEntry entry in reader.Cast <DictionaryEntry>().OrderBy(e => e.Key.ToString()))
{
if (entry.Value is String)
{
filteredEntries.Add(new KeyValuePair <string, string>(entry.Key.ToString(), (string)entry.Value));
}
else if (entry.Value is byte[])
{
Children.Add(ResourceEntryNode.Create(entry.Key.ToString(), new MemoryStream((byte[])entry.Value)));
}
else
{
Children.Add(ResourceEntryNode.Create(entry.Key.ToString(), entry.Value));
}
}
}
}
public void decrypt(ResourceDecrypter resourceDecrypter)
{
if (decryptMethod == null)
{
return;
}
resource = CoUtils.getResource(module, decrypterCctor);
if (resource == null)
{
return;
}
var decrypted = resourceDecrypter.decrypt(resource.GetResourceStream());
var reader = new BinaryReader(new MemoryStream(decrypted));
int numEncrypted = reader.ReadInt32();
Log.v("Restoring {0} encrypted methods", numEncrypted);
Log.indent();
for (int i = 0; i < numEncrypted; i++)
{
int delegateTypeToken = reader.ReadInt32();
uint codeOffset = reader.ReadUInt32();
var origOffset = reader.BaseStream.Position;
reader.BaseStream.Position = codeOffset;
decrypt(reader, delegateTypeToken);
reader.BaseStream.Position = origOffset;
}
Log.deIndent();
}
private List <XamlResource> GetXamlResources(Dictionary <ModuleDefinition, Mono.Collections.Generic.Collection <Resource> > resources)
{
List <XamlResource> result = new List <XamlResource>();
foreach (KeyValuePair <ModuleDefinition, Mono.Collections.Generic.Collection <Resource> > moduleResources in resources)
{
foreach (Resource resource in moduleResources.Value)
{
if (resource.ResourceType != ResourceType.Embedded)
{
continue;
}
EmbeddedResource embeddedResource = (EmbeddedResource)resource;
if (resource.Name.EndsWith(".g.resources", StringComparison.OrdinalIgnoreCase))
{
using (ResourceReader resourceReader = new ResourceReader(embeddedResource.GetResourceStream()))
{
foreach (System.Collections.DictionaryEntry resourceEntry in resourceReader)
{
result.Add(new XamlResource(resourceEntry, moduleResources.Key));
}
}
}
}
}
return(result);
}
public static bool IsXaml(this EmbeddedResource resource, out string classname)
{
classname = null;
if (!resource.Name.EndsWith(".xaml", StringComparison.InvariantCulture))
{
return(false);
}
using (var resourceStream = resource.GetResourceStream()) {
var xmlDoc = new XmlDocument();
xmlDoc.Load(resourceStream);
var nsmgr = new XmlNamespaceManager(xmlDoc.NameTable);
var root = xmlDoc.SelectSingleNode("/*", nsmgr);
if (root == null)
{
return(false);
}
var rootClass = root.Attributes ["Class", "http://schemas.microsoft.com/winfx/2006/xaml"] ??
root.Attributes ["Class", "http://schemas.microsoft.com/winfx/2009/xaml"];
if (rootClass == null)
{
return(false);
}
classname = rootClass.Value;
return(true);
}
}
Stream LoadBaml(Resource res, string name)
{
EmbeddedResource er = res as EmbeddedResource;
if (er != null)
{
Stream s = er.GetResourceStream();
s.Position = 0;
ResourceReader reader;
try {
reader = new ResourceReader(s);
} catch (ArgumentException) {
return(null);
}
foreach (DictionaryEntry entry in reader.Cast <DictionaryEntry>().OrderBy(e => e.Key.ToString()))
{
if (entry.Key.ToString() == name)
{
if (entry.Value is Stream)
{
return((Stream)entry.Value);
}
if (entry.Value is byte[])
{
return(new MemoryStream((byte[])entry.Value));
}
}
}
}
return(null);
}
private static void WriteResourceFile(EmbeddedResource resource, string outputPath)
{
Directory.CreateDirectory(Path.GetDirectoryName(outputPath));
using (var outputStream = File.OpenWrite(outputPath))
{
resource.GetResourceStream().CopyTo(outputStream);
}
}
private static void WriteResourceToAssembly(EmbeddedResource resource, string filename)
{
using (Stream stream = resource.GetResourceStream())
using (FileStream fileStream = File.Create(filename))
{
stream.CopyTo(fileStream);
}
}
public static byte[] FixedGetResourceData(this EmbeddedResource resource)
{
// There's a bug in Mono.Cecil so when you access a resources data
// the stream is not reset after use.
var data = resource.GetResourceData();
resource.GetResourceStream().Position = 0;
return(data);
}
private static byte[] ReadResource(EmbeddedResource r)
{
using (var ms = new MemoryStream())
using (var s = r.GetResourceStream())
{
s.CopyTo(ms);
return(ms.ToArray());
}
}
public ILSpyTreeNode CreateNode(Resource resource)
{
EmbeddedResource er = resource as EmbeddedResource;
if (er != null)
{
return(CreateNode(er.Name, er.GetResourceStream()));
}
return(null);
}
internal virtual string ReadEmbeddedResource(EmbeddedResource resource)
{
using (var resourcesStream = resource.GetResourceStream())
{
using (StreamReader reader = new StreamReader(resourcesStream))
{
return(reader.ReadToEnd());
}
}
}
public void init(ResourceDecrypter resourceDecrypter)
{
if (decrypterType == null)
{
return;
}
encryptedResource = CoUtils.getResource(module, DotNetUtils.getCodeStrings(DotNetUtils.getMethod(decrypterType, ".cctor")));
constantsData = resourceDecrypter.decrypt(encryptedResource.GetResourceStream());
}
byte[] getMethodsData(EmbeddedResource resource)
{
var reader = new BinaryReader(resource.GetResourceStream());
reader.BaseStream.Position = startOffset;
if ((reader.ReadInt32() & 1) != 0)
{
return(decompress(reader));
}
else
{
return(reader.ReadBytes((int)(reader.BaseStream.Length - reader.BaseStream.Position)));
}
}
void Initialize()
{
reader = new BinaryReader(encryptedResource.GetResourceStream());
short len = (short)(reader.ReadInt16() ^ s1);
if (len != 0)
{
theKey = reader.ReadBytes(len);
}
else
{
keyLen = reader.ReadInt16() ^ s2;
}
}
public System.IO.Stream GetResourceStream(object asm, string resourceName)
{
AssemblyDefinition adef = (AssemblyDefinition)asm;
foreach (Resource res in adef.MainModule.Resources)
{
EmbeddedResource r = res as EmbeddedResource;
if (r != null && r.Name == resourceName)
{
return(r.GetResourceStream());
}
}
throw new InvalidOperationException("Resource not found: " + resourceName);
}
private IEnumerable <XamlTypeDeclaration> ReadResource(EmbeddedResource resource)
{
if (resource.Name.EndsWith(".resources", StringComparison.Ordinal))
{
IEnumerable <XamlTypeDeclaration> declaredTypes = new List <XamlTypeDeclaration>();
var resourceReader = new ResourceReader(resource.GetResourceStream());
IDictionaryEnumerator dict = resourceReader.GetEnumerator();
while (dict.MoveNext())
{
foreach (var typeDeclaration in ReadXamlStream(dict.Key.ToString(), dict.Value as Stream))
{
yield return(typeDeclaration);
}
}
}
else
{
foreach (var typeDeclaration in ReadXamlStream(resource.Name, resource.GetResourceStream()))
{
yield return(typeDeclaration);
}
}
}
