public override void Create(DecompileContext ctx)
{
using (var stream = File.Create(Filename)) {
var data = embeddedResource.GetResourceData();
stream.Write(data, 0, data.Length);
}
}
private static string GetLoadStringFromCall(MethodReference mr)
{
MethodDefinition md = mr.Resolve();
if ((md == null) || !IsResource(md))
{
return(null);
}
string resourceName = GetResourceNameFromResourceGetter(md);
if (resourceName == null)
{
return(null);
}
AssemblyDefinition ad = md.GetAssembly();
string resourceClassName = md.DeclaringType.GetFullName() + ".resources";
EmbeddedResource resource = GetEmbeddedResource(ad, resourceClassName);
if (resource == null)
{
return(null);
}
using (MemoryStream ms = new MemoryStream(resource.GetResourceData()))
using (ResourceSet resourceSet = new ResourceSet(ms)) {
return(resourceSet.GetString(resourceName));
}
}
void VerifyResources(AssemblyDefinition original, AssemblyDefinition linked)
{
var expectedResourceNames = original.MainModule.AllDefinedTypes()
.SelectMany(t => GetCustomAttributeCtorValues <string> (t, nameof(KeptResourceAttribute)))
.ToList();
foreach (var resource in linked.MainModule.Resources)
{
if (!expectedResourceNames.Remove(resource.Name))
{
Assert.True(false, $"Resource '{resource.Name}' should be removed.");
}
EmbeddedResource embeddedResource = (EmbeddedResource)resource;
var expectedResource = (EmbeddedResource)original.MainModule.Resources.First(r => r.Name == resource.Name);
embeddedResource.GetResourceData().Should().BeEquivalentTo(expectedResource.GetResourceData(), $"Resource '{resource.Name}' data doesn't match.");
}
if (expectedResourceNames.Count > 0)
{
Assert.True(false, $"Resource '{expectedResourceNames.First ()}' should be kept.");
}
}
public void initialize(ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob)
{
if (resolverType == null)
{
return;
}
encryptedResource = BabelUtils.findEmbeddedResource(module, resolverType, simpleDeobfuscator, deob);
if (encryptedResource == null)
{
Log.w("Could not find embedded assemblies resource");
return;
}
var decrypted = resourceDecrypter.decrypt(encryptedResource.GetResourceData());
var reader = new BinaryReader(new MemoryStream(decrypted));
int numAssemblies = reader.ReadInt32();
embeddedAssemblyInfos = new EmbeddedAssemblyInfo[numAssemblies];
for (int i = 0; i < numAssemblies; i++)
{
string name = reader.ReadString();
var data = reader.ReadBytes(reader.ReadInt32());
var mod = ModuleDefinition.ReadModule(new MemoryStream(data));
embeddedAssemblyInfos[i] = new EmbeddedAssemblyInfo(name, DeobUtils.getExtension(mod.Kind), data);
}
}
static Gdk.Pixbuf GetEmbeddedIcon(AssemblyDefinition asm, string iconname)
{
Gdk.Pixbuf icon = null;
if (iconname != null && iconname.Length > 0)
{
try
{
// Using the pixbuf resource constructor generates a gdk warning.
EmbeddedResource res = GetResource(asm, iconname);
Gdk.PixbufLoader loader = new Gdk.PixbufLoader(res.GetResourceData());
icon = loader.Pixbuf;
}
catch
{
// Ignore
}
}
if (icon == null)
{
ClassDescriptor cc = Registry.LookupClassByName("Gtk.Bin");
icon = cc.Icon;
}
return(icon);
}
public void initialize(ModuleDefinition module, EmbeddedResource resource)
{
key = resource.GetResourceData();
if (key.Length != 0x100)
{
throw new ApplicationException(string.Format("Unknown key length: {0}", key.Length));
}
}
byte[] Decrypt_v14_r55802()
{
var reader = new BinaryReader(new MemoryStream(Decompress(resource.GetResourceData())));
var encypted = reader.ReadBytes(reader.ReadInt32());
if ((encypted.Length & 1) != 0)
{
throw new ApplicationException("Invalid resource data length");
}
var decrypted = new byte[encypted.Length / 2];
for (int i = 0; i < decrypted.Length; i++)
{
decrypted[i] = (byte)((encypted[i * 2 + 1] ^ key0) * key1 + (encypted[i * 2] ^ key0));
}
reader = new BinaryReader(new MemoryStream(Decompress(decrypted)));
return(reader.ReadBytes(reader.ReadInt32()));
}
public byte[] decrypt()
{
if (encryptedDataResource == null || key == null || iv == null)
{
throw new ApplicationException("Can't decrypt resource");
}
return(DeobUtils.aesDecrypt(encryptedDataResource.GetResourceData(), key, iv));
}
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);
}
public void initialize(ModuleDefinition module, EmbeddedResource resource)
{
var decrypted = new ResourceDecrypter(module).decrypt(resource.GetResourceData());
var reader = new BinaryReader(new MemoryStream(decrypted));
while (reader.BaseStream.Position < reader.BaseStream.Length)
{
offsetToString[(int)reader.BaseStream.Position] = reader.ReadString();
}
}
static string getAssemblyName(EmbeddedResource resource)
{
try {
var resourceModule = ModuleDefinition.ReadModule(new MemoryStream(resource.GetResourceData()));
return(resourceModule.Assembly.Name.FullName);
}
catch {
return(string.Format("unknown_name_{0}", unknownNameCounter++));
}
}
public byte[] decrypt(EmbeddedResource resource)
{
if (!CanDecrypt)
{
throw new ApplicationException("Can't decrypt resources");
}
var encryptedData = resource.GetResourceData();
return(decrypt(encryptedData));
}
public override string GetStringContents()
{
EmbeddedResource er = r as EmbeddedResource;
if (er != null)
{
return(GetStringContents(new MemoryStream(er.GetResourceData())));
}
return(null);
}
public override bool View(DecompilerTextView textView)
{
EmbeddedResource er = r as EmbeddedResource;
if (er != null)
{
return(View(this, textView, new MemoryStream(er.GetResourceData()), er.Name));
}
return(false);
}
protected static byte[] decryptResourceV41SL(EmbeddedResource resource)
{
var data = resource.GetResourceData();
byte k = data[0];
for (int i = 0; i < data.Length - 1; i++)
{
data[i + 1] ^= (byte)((k << (i & 5)) + i);
}
return(inflateIfNeeded(data, 1, data.Length - 1));
}
byte[] decryptResourceAssembly()
{
var decrypted = new ResourceDecrypter(module).decrypt(encryptedResource.GetResourceData());
var reader = new BinaryReader(new MemoryStream(decrypted));
int numResources = reader.ReadInt32();
for (int i = 0; i < numResources; i++)
{
reader.ReadString();
}
return(reader.ReadBytes((int)(reader.BaseStream.Length - reader.BaseStream.Position)));
}
public void initialize(ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob)
{
if (methodsDecrypter == null)
{
return;
}
encryptedResource = BabelUtils.findEmbeddedResource(module, methodsDecrypter, simpleDeobfuscator, deob);
if (encryptedResource != null)
{
addImageReader("", resourceDecrypter.decrypt(encryptedResource.GetResourceData()));
}
}
public byte[] Decrypt(EmbeddedResource resource)
{
var encrypted = resource.GetResourceData();
var decrypted = new byte[encrypted.Length];
uint sum = 0;
for (int i = 0; i < encrypted.Length; i += 4)
{
sum = CalculateMagic(sum + ReadUInt32(key, i % key.Length));
WriteUInt32(decrypted, i, sum ^ ReadUInt32(encrypted, i));
}
return(decrypted);
}
public void initialize(ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob)
{
if (methodsDecrypter == null)
{
return;
}
encryptedResource = BabelUtils.findEmbeddedResource(module, methodsDecrypter, simpleDeobfuscator, deob);
if (encryptedResource == null)
{
Log.w("Could not find encrypted methods resource");
return;
}
addImageReader("", new ResourceDecrypter(module).decrypt(encryptedResource.GetResourceData()));
}
public void initialize(ISimpleDeobfuscator simpleDeobfuscator, IDeobfuscator deob)
{
if (decrypterType == null)
{
return;
}
encryptedResource = BabelUtils.findEmbeddedResource(module, decrypterType, simpleDeobfuscator, deob);
if (encryptedResource == null)
{
Log.w("Could not find encrypted constants resource");
return;
}
var decrypted = resourceDecrypter.decrypt(encryptedResource.GetResourceData());
var reader = new BinaryReader(new MemoryStream(decrypted));
int count;
count = reader.ReadInt32();
decryptedInts = new int[count];
while (count-- > 0)
{
decryptedInts[count] = reader.ReadInt32();
}
count = reader.ReadInt32();
decryptedLongs = new long[count];
while (count-- > 0)
{
decryptedLongs[count] = reader.ReadInt64();
}
count = reader.ReadInt32();
decryptedFloats = new float[count];
while (count-- > 0)
{
decryptedFloats[count] = reader.ReadSingle();
}
count = reader.ReadInt32();
decryptedDoubles = new double[count];
while (count-- > 0)
{
decryptedDoubles[count] = reader.ReadDouble();
}
}
XmlDocument GetGuiDoc(AssemblyDefinition adef)
{
XmlDocument doc = null;
try {
EmbeddedResource res = GetResource(adef, "gui.stetic");
if (res != null)
{
MemoryStream stream = new MemoryStream(res.GetResourceData());
doc = new XmlDocument();
using (stream)
doc.Load(stream);
}
} catch {
doc = null;
}
return(doc);
}
public void Initialize()
{
if (installMethod == null)
{
return;
}
if (!FindKeys())
{
throw new ApplicationException("Could not find keys");
}
if ((resource = FindResource(key0)) == null)
{
throw new ApplicationException("Could not find resource");
}
constants = DecryptResource(resource.GetResourceData());
FindDecrypters();
}
public override Widget GetView()
{
if (box != null)
{
return(box);
}
// Create ui
box = new VBox(false, 10);
store = new ListStore(typeof(string), typeof(string), typeof(object));
tree = new TreeView();
tree.Model = store;
tree.AppendColumn("Name", new CellRendererText(), "text", 0);
tree.AppendColumn("Type", new CellRendererText(), "text", 1);
tree.HeadersVisible = true;
tree.CursorChanged += HandleCursorChanged;
scrolled_tree = new ScrolledWindow();
scrolled_tree.Add(tree);
box.PackStart(scrolled_tree, true, true, 0);
// Load resources
EmbeddedResource embed = resource as EmbeddedResource;
if (embed != null)
{
using (MemoryStream stream = new MemoryStream(embed.GetResourceData())) {
using (ResourceReader reader = new ResourceReader(stream)) {
foreach (DictionaryEntry obj in reader)
{
store.AppendValues(obj.Key.ToString(), obj.Value.GetType().FullName, obj.Value);
}
}
}
}
else
{
Console.WriteLine("Don't know how to handle a resource whose type is {0}", resource.GetType().FullName);
}
return(box);
}
/**<summary>Unpacks the localization files from terraria.</summary>*/
public static void Unpack()
{
// Backup the file first
if (!File.Exists(BackupPath))
{
File.Copy(ExePath, BackupPath, false);
}
var AsmDefinition = AssemblyDefinition.ReadAssembly(ExePath);
var ModDefinition = AsmDefinition.MainModule;
foreach (Resource r in ModDefinition.Resources)
{
EmbeddedResource er = r as EmbeddedResource;
if (er != null && er.Name.StartsWith("Terraria.Localization.Content.") && er.Name.EndsWith(".json"))
{
string path = Path.Combine(OutputDirectory, er.Name);
File.WriteAllBytes(path, er.GetResourceData());
}
}
}
void findEmbeddedAssemblies()
{
var data = bundleData.GetResourceData();
var doc = new XmlDocument();
doc.Load(XmlReader.Create(bundleXmlFile.GetResourceStream()));
var manifest = doc.DocumentElement;
if (manifest.Name.ToLowerInvariant() != "manifest")
{
Log.w("Could not find Manifest element");
return;
}
foreach (var tmp in manifest.ChildNodes)
{
var assemblyElem = tmp as XmlElement;
if (assemblyElem == null)
{
continue;
}
if (assemblyElem.Name.ToLowerInvariant() != "assembly")
{
Log.w("Unknown element: {0}", assemblyElem.Name);
continue;
}
int offset = getAttributeValueInt32(assemblyElem, "offset");
if (offset < 0)
{
Log.w("Could not find offset attribute");
continue;
}
var assemblyData = DeobUtils.inflate(data, offset, data.Length - offset, true);
var mod = ModuleDefinition.ReadModule(new MemoryStream(assemblyData));
infos.Add(new AssemblyInfo(mod.Assembly.FullName, DeobUtils.getExtension(mod.Kind), assemblyData));
}
}
public Stream CreateReadStream()
{
var _data = data;
if (_data == null)
{
// Lock parent's stream and read data.
lock (fileProvider.m_streamlock)
{
// Read data
if (_data == null)
{
_data = data = resource.GetResourceData();
}
}
}
// Wrap into stream.
MemoryStream ms = new MemoryStream(_data);
IDisposable belate = ((IBelatedDisposeList)fileProvider).Belate();
return(new StreamHandle(ms, belate));
}
public void Initialize()
{
if (decryptMethod == null)
{
return;
}
resource = FindResource(decryptMethod);
if (resource == null)
{
throw new ApplicationException("Could not find encrypted strings resource");
}
reader = MemoryImageStream.Create(DeobUtils.Inflate(resource.GetResourceData(), true));
switch (version)
{
case ConfuserVersion.v10_r42915:
case ConfuserVersion.v13_r55604_safe:
decrypter = new Decrypter_v10_r42915(this);
break;
case ConfuserVersion.v10_r48832:
decrypter = new Decrypter_v10_r48832(this);
break;
case ConfuserVersion.v11_r49299:
case ConfuserVersion.v14_r58802_dynamic:
decrypter = new Decrypter_v11_r49299(this);
break;
case ConfuserVersion.v14_r58802_safe:
decrypter = new Decrypter_v10_r42915(this, (int)key1);
break;
default:
throw new ApplicationException("Invalid version");
}
}
byte[] Decrypt(EmbeddedResource resource)
{
var data = resource.GetResourceData();
switch (version)
{
case ConfuserVersion.v10_r42915: return(Decrypt_v10_r42915(data));
case ConfuserVersion.v10_r48717: return(Decrypt_v10_r42915(data));
case ConfuserVersion.v14_r57778: return(Decrypt_v10_r42915(data));
case ConfuserVersion.v14_r58564: return(Decrypt_v14_r58564(data));
case ConfuserVersion.v14_r58802: return(Decrypt_v14_r58564(data));
case ConfuserVersion.v14_r58852: return(Decrypt_v14_r58852(data));
case ConfuserVersion.v15_r60785: return(Decrypt_v15_r60785(data));
case ConfuserVersion.v17_r73404: return(Decrypt_v17_r73404(data));
case ConfuserVersion.v17_r73477: return(Decrypt_v17_r73404(data));
case ConfuserVersion.v17_r73566: return(Decrypt_v17_r73404(data));
case ConfuserVersion.v17_r75076: return(Decrypt_v17_r75076(data));
case ConfuserVersion.v18_r75184: return(Decrypt_v17_r75076(data));
case ConfuserVersion.v18_r75367: return(Decrypt_v17_r75076(data));
case ConfuserVersion.v19_r77172: return(Decrypt_v17_r75076(data));
default: throw new ApplicationException("Unknown version");
}
}
byte[] decryptResourceAssembly()
{
var decrypted = resourceDecrypter.decrypt(encryptedResource.GetResourceData());
var reader = new BinaryReader(new MemoryStream(decrypted));
int numResources = reader.ReadInt32() ^ xorKey1;
for (int i = 0; i < numResources; i++)
{
reader.ReadString();
}
int len;
if (hasXorKeys)
{
len = reader.ReadInt32() ^ xorKey2;
}
else
{
len = (int)(reader.BaseStream.Length - reader.BaseStream.Position);
}
return(reader.ReadBytes(len));
}
public byte[] Decrypt(EmbeddedResource resource)
{
return(DeobUtils.AesDecrypt(resource.GetResourceData(), key, iv));
}
