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 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 IDirectory BuildInMemoryDirectoryWithTestFiles(string filesInformation)
{
var directory = new InMemoryDirectory();
var filesArray = filesInformation.Split('|');
foreach (var file in filesArray)
{
var pathSegments = PathUtils.SplitPathIntoSegments(file);
var fileName = pathSegments[pathSegments.Length - 1];
string dir = string.Empty;
if (pathSegments.Length > 1)
{
for (int i = 0; i < pathSegments.Length - 1; i++)
{
dir = dir + "/" + pathSegments[i];
}
}
var fileContents = Guid.NewGuid();
IFileInfo fileInfo = new StringFileInfo(fileContents.ToString(), fileName);
directory.AddFile(dir, fileInfo);
}
return(directory);
}
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]);
}
}
internal VersionInfo(VersionResource versionResource, uint languageId, FixedFileInfo fixedInfo, StringFileInfo stringInfo, VarFileInfo varInfo)
{
resource = versionResource;
language_id = languageId;
fixed_file_info = fixedInfo;
string_file_info = stringInfo;
var_file_info = varInfo;
}
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);
}
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);
}
public void Setup()
{
_mapperMock = new Mock <IMapper>(MockBehavior.Strict);
_reportRepositoryMock = new Mock <IReportRepository>(MockBehavior.Strict);
_fileProviderMock = new Mock <IFileProvider>();
_updateReportHandler = new UpdateReportHandler(_mapperMock.Object, _reportRepositoryMock.Object);
var fileInfo = new StringFileInfo("", "QuestionConfig.json");
_fileProviderMock.Setup(s => s.GetFileInfo(It.IsAny <string>())).Returns(fileInfo);
}
private void ClearLengths(StringFileInfo i)
{
ClearHeader(i);
foreach (var st in i.Children)
{
ClearHeader(st);
foreach (var s in st.Children)
{
ClearHeader(s);
}
}
}
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();
}
public StringFileInfo(BinaryReader reader)
{
StringFileInfo hdr = new StringFileInfo();
this = hdr;
byte[] buffer = new byte[Marshal.SizeOf(this)];
reader.Read(buffer, 0, buffer.Length);
hdr = buffer.ToStructure <StringFileInfo>();
this = hdr;
}
/// <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);
}
}
// -----------------------------------------------------
void ReplaceVersionInfo(Options options)
{
// Find version info resources
ResourceInfo ri = new ResourceInfo();
ri.Load(options.outputExeFile);
List <Resource> resources = ri.Resources[new ResourceId(Kernel32.ResourceTypes.RT_VERSION)];
ri.Dispose();
// Delete old version resource(s) from file
foreach (Resource resource in resources)
{
resource.DeleteFrom(options.outputExeFile);
}
// Create new version info resource
VersionResource versionResource = new VersionResource();
versionResource.FileVersion = options.versionInfo.fileVersion;
versionResource.ProductVersion = options.versionInfo.productVersion;
// Set all the info / strings
StringFileInfo stringFileInfo = new StringFileInfo();
versionResource[stringFileInfo.Key] = stringFileInfo;
StringTable stringFileInfoStrings = new StringTable();
stringFileInfoStrings.LanguageID = ResourceUtil.USENGLISHLANGID;
stringFileInfoStrings.CodePage = 1200;
stringFileInfo.Strings.Add(stringFileInfoStrings.Key, stringFileInfoStrings);
// stringFileInfoStrings["ProductName"] = "not used";
stringFileInfoStrings["FileVersion"] = options.versionInfo.fileVersion;
stringFileInfoStrings["FileDescription"] = options.versionInfo.productName;
stringFileInfoStrings["LegalCopyright"] = options.versionInfo.legalCopyright;
stringFileInfoStrings["CompanyName"] = options.versionInfo.companyName;
// stringFileInfoStrings["Comments"] = "not used";
stringFileInfoStrings["ProductVersion"] = options.versionInfo.productVersion;
// Don't really understand what this chunk does, but leaving it in anyway
VarFileInfo varFileInfo = new VarFileInfo();
versionResource[varFileInfo.Key] = varFileInfo;
VarTable varFileInfoTranslation = new VarTable("Translation");
varFileInfo.Vars.Add(varFileInfoTranslation.Key, varFileInfoTranslation);
varFileInfoTranslation[ResourceUtil.USENGLISHLANGID] = 1300;
// Save to file
versionResource.SaveTo(options.outputExeFile);
}
public override bool Execute()
{
if (!Regex.IsMatch(FileVersion, @"\d+\.\d+.\d+\.\d+"))
{
Log.LogError("FileVersion value '{0}' is invalid - must be NNN.NNN.NNN.NNN (where N is any digit).", FileVersion);
return(false);
}
if (!Regex.IsMatch(ProductVersion, @"\d+\.\d+\.\d+\.\d+"))
{
Log.LogError("ProductVersion value '{0}' is invalid - must be NNN.NNN.NNN.NNN (where N is any digit).", ProductVersion);
return(false);
}
foreach (ITaskItem file in InputFiles)
{
string fileName = file.GetMetadata("FileName") + file.GetMetadata("Extension");
VersionResource resource = new VersionResource();
resource.FileVersion = FileVersion;
resource.ProductVersion = ProductVersion;
resource.FileFlags = 0;
StringTable table = new StringTable();
table.LanguageID = 0x0409;
table.CodePage = 0x04B0;
table["CompanyName"] = CompanyName;
table["FileDescription"] = FileDescription;
table["FileVersion"] = FileVersion;
table["InternalName"] = fileName;
table["LegalCopyright"] = LegalCopyright;
table["OriginalFilename"] = fileName;
table["ProductName"] = ProductName;
table["ProductVersion"] = ProductVersion;
StringFileInfo stringInfo = new StringFileInfo();
stringInfo.Strings["040904B0"] = table;
resource.Resources["StringFileInfo"] = stringInfo;
VarTable varTable = new VarTable("Translation");
varTable.Languages[0x0409] = 0x04B0;
VarFileInfo varInfo = new VarFileInfo();
varInfo.Vars["Translation"] = varTable;
resource.Resources["VarFileInfo"] = varInfo;
resource.SaveTo(file.GetMetadata("FullPath"));
}
return(true);
}
public static void AddFile(this InMemoryFileProvider fs, string pathAndName, string content)
{
var path = System.IO.Path.GetDirectoryName(pathAndName);
if (path == "\\")
{
path = "";
}
var name = System.IO.Path.GetFileName(pathAndName);
var strFi = new StringFileInfo(content, name);
fs.Directory.AddFile(path, new FakeFileInfo(strFi, path));
}
public void Can_Rename_A_Folder_With_Child_Items()
{
// arrange
// build a directory /root/child/grandchild
var rootFolder = new FolderDirectoryItem("root", null);
var childFolder = rootFolder.GetOrAddFolder("child");
var grandChildFolder = childFolder.GetOrAddFolder("grandchild");
// add a file /root/child/foo.txt
var fileInfo = new StringFileInfo("contents", "foo.txt");
var someOtherFile = childFolder.AddFile(fileInfo);
// add a file /root/child/grandchild/bar.txt
var barFile = grandChildFolder.AddFile(new StringFileInfo("should trigger", "bar.txt"));
// Subscribe to event handlers as we want to test if we are notified appropriately when
// a folder is renamed.
bool notified = false;
bool fileNotified = false;
// We are going to rename this folder, so we should see if we get notified that it is
// updated.
grandChildFolder.Updated += (sender, e) =>
{
DirectoryItemUpdatedEventArgs args = e;
IDirectoryItem oldItem = e.OldItem;
IDirectoryItem newItem = e.NewItem;
Assert.Equal("grandchild", oldItem.Name);
Assert.Equal("grandchild-renamed", newItem.Name);
notified = true;
};
// We are going to rename the folder which this file lives in, which means this files
// path will have changed. We should register to see if we get notified that it was updated.
barFile.Updated += (sender, e) =>
{
DirectoryItemUpdatedEventArgs args = e;
IDirectoryItem oldItem = e.OldItem;
IDirectoryItem newItem = e.NewItem;
Assert.Equal("bar.txt", oldItem.Name);
Assert.Equal("bar.txt", newItem.Name);
Assert.Equal("root/child/grandchild/bar.txt", oldItem.Path);
Assert.Equal("root/child/grandchild-renamed/bar.txt", newItem.Path);
fileNotified = true;
};
grandChildFolder.Rename("grandchild-renamed");
Assert.True(notified);
Assert.True(fileNotified);
}
private string ReadResourceString(StringFileInfo stringFileInfo, string key)
{
string?Result = stringFileInfo[key];
if (Result != null)
{
if (Result.Length > 0 && Result[Result.Length - 1] == '\0')
{
Result = Result.Substring(0, Result.Length - 1);
}
return(Result);
}
else
{
return(string.Empty);
}
}
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 void Setup()
{
_mapperMock = new Mock <IMapper>(MockBehavior.Strict);
_reportRepositoryMock = new Mock <IReportRepository>(MockBehavior.Strict);
_fileProviderMock = new Mock <IFileProvider>();
_createReportHandler = new CreateReportHandler(_reportRepositoryMock.Object, _mapperMock.Object, _fileProviderMock.Object);
_report = new Report
{
EmployerId = _employerId,
ReportingPeriod = _reportingPeriod,
Id = Guid.NewGuid(),
Submitted = false
};
var fileInfo = new StringFileInfo("", "QuestionConfig.json");
_fileProviderMock.Setup(s => s.GetFileInfo(It.IsAny <string>())).Returns(fileInfo);
_mapperMock.Setup(s => s.Map <Report>(It.IsAny <ReportDto>())).Returns(_report);
}
public void Can_Add_Then_Retrieve_A_File()
{
// Arrange
IDirectory directory = new InMemoryDirectory();
var fileContents = "greetings!";
IFileInfo fileInfo = new StringFileInfo(fileContents, "hello.txt");
// Act
// Add the file to the directory, to the folder path: /foo/bar
directory.AddFile("/foo", fileInfo);
// Assert
// Assert that we can get the file from the directory using its full path.
var retrievedFile = directory.GetFile("/foo/hello.txt");
Assert.NotNull(retrievedFile);
Assert.Equal(fileInfo, retrievedFile.FileInfo);
}
public void PersistentStringFileInfo()
{
// Prepare mock data.
var versionInfo = new VersionInfoResource();
var stringFileInfo = new StringFileInfo();
var table = new StringTable(0, 0x4b0)
{
[StringTable.ProductNameKey] = "Sample product",
[StringTable.FileVersionKey] = "1.2.3.4",
[StringTable.ProductVersionKey] = "1.0.0.0",
[StringTable.FileDescriptionKey] = "This is a sample description"
};
stringFileInfo.Tables.Add(table);
versionInfo.AddEntry(stringFileInfo);
// Serialize.
var tempStream = new MemoryStream();
versionInfo.Write(new BinaryStreamWriter(tempStream));
// Reload.
var infoReader = ByteArrayDataSource.CreateReader(tempStream.ToArray());
var newVersionInfo = VersionInfoResource.FromReader(ref infoReader);
// Verify.
var newStringFileInfo = newVersionInfo.GetChild <StringFileInfo>(StringFileInfo.StringFileInfoKey);
Assert.NotNull(newStringFileInfo);
Assert.Single(newStringFileInfo.Tables);
var newTable = newStringFileInfo.Tables[0];
foreach ((string key, string value) in table)
{
Assert.Equal(value, newTable[key]);
}
}
internal static StringFileInfo ReadStringFileInfo(this PeReader reader)
{
var orgPos = reader.GetPosition();
var info = new StringFileInfo();
if (!reader.ReadFileInfo(info, "StringFileInfo"))
{
return(null);
}
// Read all children (StringTables)
var children = new List <StringTable>();
while (reader.GetPosition() < orgPos + info.Length)
{
children.Add(reader.ReadStringTable());
}
info.Children = children.ToImmutableList();
return(info);
}
public void Can_Rename_A_Folder()
{
var rootFolder = new FolderDirectoryItem("root", null);
var childFolder = rootFolder.GetOrAddFolder("child");
var fileInfo = new StringFileInfo("contents", "foo.txt");
var someOtherFile = childFolder.AddFile(fileInfo);
bool notified = false;
childFolder.Updated += (sender, e) =>
{
DirectoryItemUpdatedEventArgs args = e;
IDirectoryItem oldItem = e.OldItem;
IDirectoryItem newItem = e.NewItem;
Assert.Equal("child", oldItem.Name);
Assert.Equal("child-renamed", newItem.Name);
notified = true;
};
childFolder.Rename("child-renamed");
Assert.True(notified);
Assert.Equal("root/child-renamed/foo.txt", someOtherFile.Path);
}
private static void StampVersion(string path, Version version)
{
var versionResource = new VersionResource
{
FileVersion = version.ToString(),
ProductVersion = version.ToString()
};
var stringFileInfo = new StringFileInfo();
versionResource[stringFileInfo.Key] = stringFileInfo;
var stringFileInfoStrings = new StringTable
{
LanguageID = 1033,
CodePage = 1200
};
stringFileInfo.Strings.Add(stringFileInfoStrings.Key, stringFileInfoStrings);
stringFileInfoStrings["CompanyName"] = Config.Global.Version.CompanyName;
stringFileInfoStrings["FileDescription"] = Config.Global.Version.FileDescription;
stringFileInfoStrings["FileVersion"] = version.ToString();
stringFileInfoStrings["InternalName"] = Config.Global.Version.InternalName;
stringFileInfoStrings["LegalCopyright"] = Config.Global.Version.LegalCopyright;
stringFileInfoStrings["OriginalFilename"] = Config.Global.Version.OriginalFilename;
stringFileInfoStrings["ProductName"] = Config.Global.Version.ProductName;
stringFileInfoStrings["ProductVersion"] = version.ToString();
var varFileInfo = new VarFileInfo();
versionResource[varFileInfo.Key] = varFileInfo;
var varFileInfoTranslation = new VarTable("Translation");
varFileInfo.Vars.Add(varFileInfoTranslation.Key, varFileInfoTranslation);
varFileInfoTranslation[ResourceUtil.USENGLISHLANGID] = 1300;
versionResource.SaveTo(path);
}
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 override IntPtr Read(IntPtr hModule, IntPtr lpRes)
{
_resources = new Dictionary<string, ResourceTable>();
IntPtr pFixedFileInfo = _header.Read(lpRes);
_fixedfileinfo = (Kernel32.VS_FIXEDFILEINFO)Marshal.PtrToStructure(
pFixedFileInfo, typeof(Kernel32.VS_FIXEDFILEINFO));
IntPtr pChild = ResourceUtil.Align(pFixedFileInfo.ToInt32() + _header.Header.wValueLength);
while (pChild.ToInt32() < (lpRes.ToInt32() + _header.Header.wLength))
{
ResourceTable rc = new ResourceTable(pChild);
switch (rc.Key)
{
case "StringFileInfo":
rc = new StringFileInfo(pChild);
break;
default:
rc = new VarFileInfo(pChild);
break;
}
_resources.Add(rc.Key, rc);
pChild = ResourceUtil.Align(pChild.ToInt32() + rc.Header.wLength);
}
return new IntPtr(lpRes.ToInt32() + _header.Header.wLength);
}
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]);
}
}
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());
}
private static bool ProcessStringsInStringFileInfo(StringFileInfo stringFileInfo, Func<string, string> process)
{
return stringFileInfo.Children.Select(child => ProcessStringsInStringTable(child, process)).AnyOfAll();
}
/// <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 Save(bool autoHandleDependencies = false)
{
lock (this) {
if (_manifest != null)
{
_pendingChanges = _manifest.Modified || _pendingChanges;
}
// Logger.Message("Saving Binary '{0}' : Pending Changes: {1} ", _filename, _pendingChanges);
if (_pendingChanges)
{
// saves any changes made to the binary.
// work on a back up of the file
var tmpFilename = _filename.CreateWritableWorkingCopy();
try {
// remove any digital signatures from the binary before doing anything
if (!IsManaged)
{
StripSignatures(tmpFilename); // this is irrelevant if the binary is managed--we'll be writing out a new one.
}
// rewrite any native resources that we want to change.
if (IsManaged && ILOnly)
{
// we can only edit the file if it's IL only, mixed mode assemblies can only be strong named, signed and native-resource-edited.
// set the strong name key data
MutableAssembly.PublicKey = StrongNameKey.ToList();
// change any assembly attributes we need to change
if (MutableAssembly != null)
{
if (StrongNameKeyCertificate != null)
{
foreach (var ar in MutableAssembly.AssemblyReferences)
{
if (!ar.PublicKeyToken.Any())
{
var dep = FindAssembly(ar.Name.Value, ar.Version.ToString());
if (dep == null)
{
// can't strong name a file that doesn't have its deps all strong named.
throw new ClrPlusException("dependent assembly '{0}-{1}' not available for strong naming".format(ar.Name.Value, ar.Version.ToString()));
}
lock (dep) {
// this should wait until the dependency is finished saving, right?
}
if (dep.MutableAssembly.PublicKey.IsNullOrEmpty())
{
if (autoHandleDependencies)
{
Console.WriteLine(
"Warning: Non-strong-named dependent reference found: '{0}-{1}' updating with same strong-name-key.",
ar.Name, ar.Version);
dep.StrongNameKeyCertificate = StrongNameKeyCertificate;
dep.SigningCertificate = SigningCertificate;
dep.AssemblyCopyright = AssemblyCopyright;
dep.AssemblyCompany = AssemblyCompany;
dep.AssemblyProduct = AssemblyProduct;
dep.Save();
}
else
{
throw new ClrPlusException("dependent assembly '{0}-{1}' not strong named".format(ar.Name.Value, ar.Version.ToString()));
}
}
(ar as Microsoft.Cci.MutableCodeModel.AssemblyReference).PublicKeyToken = dep.MutableAssembly.PublicKeyToken.ToList();
(ar as Microsoft.Cci.MutableCodeModel.AssemblyReference).PublicKey = dep.MutableAssembly.PublicKey;
}
}
}
// we should see if we can get assembly attributes, since sometimes they can be set, but not the native ones.
try {
foreach (var a in MutableAssembly.AssemblyAttributes)
{
var attributeArgument = (a.Arguments.FirstOrDefault() as MetadataConstant);
if (attributeArgument != null)
{
var attributeName = a.Type.ToString();
switch (attributeName)
{
case "System.Reflection.AssemblyTitleAttribute":
attributeArgument.Value = string.IsNullOrEmpty(AssemblyTitle) ? string.Empty : AssemblyTitle;
break;
case "System.Reflection.AssemblyDescriptionAttribute":
attributeArgument.Value = string.IsNullOrEmpty(AssemblyDescription) ? string.Empty : AssemblyDescription;
break;
case "System.Reflection.AssemblyCompanyAttribute":
attributeArgument.Value = string.IsNullOrEmpty(AssemblyCompany) ? string.Empty : AssemblyCompany;
break;
case "System.Reflection.AssemblyProductAttribute":
attributeArgument.Value = string.IsNullOrEmpty(AssemblyProduct) ? string.Empty : AssemblyProduct;
break;
case "System.Reflection.AssemblyVersionAttribute":
attributeArgument.Value = string.IsNullOrEmpty(AssemblyVersion) ? string.Empty : AssemblyVersion;
break;
case "System.Reflection.AssemblyFileVersionAttribute":
attributeArgument.Value = string.IsNullOrEmpty(AssemblyFileVersion) ? string.Empty : AssemblyFileVersion;
break;
case "System.Reflection.AssemblyCopyrightAttribute":
attributeArgument.Value = string.IsNullOrEmpty(AssemblyCopyright) ? string.Empty : AssemblyCopyright;
break;
case "System.Reflection.AssemblyTrademarkAttribute":
attributeArgument.Value = string.IsNullOrEmpty(AssemblyTrademark) ? string.Empty : AssemblyTrademark;
break;
case "BugTrackerAttribute":
attributeArgument.Value = string.IsNullOrEmpty(BugTracker) ? string.Empty : BugTracker;
break;
}
}
}
} catch {
// hmm. carry on.
}
}
// save it to disk
using (var peStream = File.Create(tmpFilename)) {
PeWriter.WritePeToStream(MutableAssembly, _host, peStream);
}
}
// update native metadata
try {
var ri = new ResourceInfo();
ri.Load(tmpFilename);
if (_manifest != null && _manifest.Modified)
{
// GS01: We only support one manifest right now.
// so we're gonna remove the extra ones.
// figure out the bigger case later.
var manifestKeys = ri.Resources.Keys.Where(each => each.ResourceType == ResourceTypes.RT_MANIFEST).ToArray();
foreach (var k in manifestKeys)
{
ri.Resources.Remove(k);
}
var manifestResource = new ManifestResource();
manifestResource.ManifestText = _manifest.ToString();
ri.Resources.Add(new ResourceId(ResourceTypes.RT_MANIFEST), new List <Resource> {
manifestResource
});
manifestResource.SaveTo(tmpFilename);
}
VersionResource versionResource;
StringTable versionStringTable;
var versionKey = ri.Resources.Keys.Where(each => each.ResourceType == ResourceTypes.RT_VERSION).FirstOrDefault();
if (versionKey != null)
{
versionResource = ri.Resources[versionKey].First() as VersionResource;
versionStringTable = (versionResource["StringFileInfo"] as StringFileInfo).Strings.Values.First();
}
else
{
versionResource = new VersionResource();
ri.Resources.Add(new ResourceId(ResourceTypes.RT_VERSION), new List <Resource> {
versionResource
});
var sfi = new StringFileInfo();
versionResource["StringFileInfo"] = sfi;
sfi.Strings["040904b0"] = (versionStringTable = new StringTable("040904b0"));
var vfi = new VarFileInfo();
versionResource["VarFileInfo"] = vfi;
var translation = new VarTable("Translation");
vfi.Vars["Translation"] = translation;
translation[0x0409] = 0x04b0;
}
versionResource.FileVersion = FileVersion;
versionResource.ProductVersion = ProductVersion;
versionStringTable["ProductName"] = ProductName;
versionStringTable["CompanyName"] = CompanyName;
versionStringTable["FileDescription"] = FileDescription;
versionStringTable["Comments"] = _comments;
versionStringTable["Assembly Version"] = _assemblyVersion;
versionStringTable["FileVersion"] = _fileVersion;
versionStringTable["ProductVersion"] = _productVersion;
versionStringTable["InternalName"] = _internalName;
versionStringTable["OriginalFilename"] = _originalFilename;
versionStringTable["LegalCopyright"] = _legalCopyright;
versionStringTable["LegalTrademarks"] = _legalTrademarks;
versionStringTable["BugTracker"] = _bugTracker;
versionResource.SaveTo(tmpFilename);
} catch (Exception e) {
Console.WriteLine("{0} -- {1}", e.Message, e.StackTrace);
}
// strong name the binary
if (IsManaged && StrongNameKeyCertificate != null && (StrongNameKeyCertificate.Certificate.PrivateKey is RSACryptoServiceProvider))
{
ApplyStrongName(tmpFilename, StrongNameKeyCertificate);
}
// sign the binary
if (_signingCertificate != null)
{
SignFile(tmpFilename, SigningCertificate.Certificate);
}
_filename.TryHardToDelete();
File.Move(tmpFilename, _filename);
} catch (Exception e) {
#if TODO
Logger.Error(e);
#endif
// get rid of whatever we tried
tmpFilename.TryHardToDelete();
// as you were...
throw;
}
}
_pendingChanges = false;
if (_manifest != null)
{
_manifest.Modified = false;
}
}
}
public void Save(bool autoHandleDependencies = false) {
lock (this) {
if (_manifest != null) {
_pendingChanges = _manifest.Modified || _pendingChanges;
}
// Logger.Message("Saving Binary '{0}' : Pending Changes: {1} ", _filename, _pendingChanges);
if (_pendingChanges) {
// saves any changes made to the binary.
// work on a back up of the file
var tmpFilename = _filename.CreateWritableWorkingCopy();
try {
// remove any digital signatures from the binary before doing anything
if (!IsManaged) {
StripSignatures(tmpFilename); // this is irrelevant if the binary is managed--we'll be writing out a new one.
}
// rewrite any native resources that we want to change.
if (IsManaged && ILOnly) {
// we can only edit the file if it's IL only, mixed mode assemblies can only be strong named, signed and native-resource-edited.
// set the strong name key data
MutableAssembly.PublicKey = StrongNameKey.ToList();
// change any assembly attributes we need to change
if (MutableAssembly != null) {
if (StrongNameKeyCertificate != null) {
foreach (var ar in MutableAssembly.AssemblyReferences) {
if (!ar.PublicKeyToken.Any()) {
var dep = FindAssembly(ar.Name.Value, ar.Version.ToString());
if (dep == null) {
// can't strong name a file that doesn't have its deps all strong named.
throw new ClrPlusException("dependent assembly '{0}-{1}' not available for strong naming".format(ar.Name.Value, ar.Version.ToString()));
}
lock (dep) {
// this should wait until the dependency is finished saving, right?
}
if (dep.MutableAssembly.PublicKey.IsNullOrEmpty()) {
if (autoHandleDependencies) {
Console.WriteLine(
"Warning: Non-strong-named dependent reference found: '{0}-{1}' updating with same strong-name-key.",
ar.Name, ar.Version);
dep.StrongNameKeyCertificate = StrongNameKeyCertificate;
dep.SigningCertificate = SigningCertificate;
dep.AssemblyCopyright = AssemblyCopyright;
dep.AssemblyCompany = AssemblyCompany;
dep.AssemblyProduct = AssemblyProduct;
dep.Save();
} else {
throw new ClrPlusException("dependent assembly '{0}-{1}' not strong named".format(ar.Name.Value, ar.Version.ToString()));
}
}
(ar as Microsoft.Cci.MutableCodeModel.AssemblyReference).PublicKeyToken = dep.MutableAssembly.PublicKeyToken.ToList();
(ar as Microsoft.Cci.MutableCodeModel.AssemblyReference).PublicKey = dep.MutableAssembly.PublicKey;
}
}
}
// we should see if we can get assembly attributes, since sometimes they can be set, but not the native ones.
try {
foreach (var a in MutableAssembly.AssemblyAttributes) {
var attributeArgument = (a.Arguments.FirstOrDefault() as MetadataConstant);
if (attributeArgument != null) {
var attributeName = a.Type.ToString();
switch (attributeName) {
case "System.Reflection.AssemblyTitleAttribute":
attributeArgument.Value = string.IsNullOrEmpty(AssemblyTitle) ? string.Empty : AssemblyTitle;
break;
case "System.Reflection.AssemblyDescriptionAttribute":
attributeArgument.Value = string.IsNullOrEmpty(AssemblyDescription) ? string.Empty : AssemblyDescription;
break;
case "System.Reflection.AssemblyCompanyAttribute":
attributeArgument.Value = string.IsNullOrEmpty(AssemblyCompany) ? string.Empty : AssemblyCompany;
break;
case "System.Reflection.AssemblyProductAttribute":
attributeArgument.Value = string.IsNullOrEmpty(AssemblyProduct) ? string.Empty : AssemblyProduct;
break;
case "System.Reflection.AssemblyVersionAttribute":
attributeArgument.Value = string.IsNullOrEmpty(AssemblyVersion) ? string.Empty : AssemblyVersion;
break;
case "System.Reflection.AssemblyFileVersionAttribute":
attributeArgument.Value = string.IsNullOrEmpty(AssemblyFileVersion) ? string.Empty : AssemblyFileVersion;
break;
case "System.Reflection.AssemblyCopyrightAttribute":
attributeArgument.Value = string.IsNullOrEmpty(AssemblyCopyright) ? string.Empty : AssemblyCopyright;
break;
case "System.Reflection.AssemblyTrademarkAttribute":
attributeArgument.Value = string.IsNullOrEmpty(AssemblyTrademark) ? string.Empty : AssemblyTrademark;
break;
case "BugTrackerAttribute":
attributeArgument.Value = string.IsNullOrEmpty(BugTracker) ? string.Empty : BugTracker;
break;
}
}
}
} catch {
// hmm. carry on.
}
}
// save it to disk
using (var peStream = File.Create(tmpFilename)) {
PeWriter.WritePeToStream(MutableAssembly, _host, peStream);
}
}
// update native metadata
try {
var ri = new ResourceInfo();
ri.Load(tmpFilename);
if (_manifest != null && _manifest.Modified) {
// GS01: We only support one manifest right now.
// so we're gonna remove the extra ones.
// figure out the bigger case later.
var manifestKeys = ri.Resources.Keys.Where(each => each.ResourceType == ResourceTypes.RT_MANIFEST).ToArray();
foreach (var k in manifestKeys) {
ri.Resources.Remove(k);
}
var manifestResource = new ManifestResource();
manifestResource.ManifestText = _manifest.ToString();
ri.Resources.Add(new ResourceId(ResourceTypes.RT_MANIFEST), new List<Resource> {
manifestResource
});
manifestResource.SaveTo(tmpFilename);
}
VersionResource versionResource;
StringTable versionStringTable;
var versionKey = ri.Resources.Keys.Where(each => each.ResourceType == ResourceTypes.RT_VERSION).FirstOrDefault();
if (versionKey != null) {
versionResource = ri.Resources[versionKey].First() as VersionResource;
versionStringTable = (versionResource["StringFileInfo"] as StringFileInfo).Strings.Values.First();
} else {
versionResource = new VersionResource();
ri.Resources.Add(new ResourceId(ResourceTypes.RT_VERSION), new List<Resource> {
versionResource
});
var sfi = new StringFileInfo();
versionResource["StringFileInfo"] = sfi;
sfi.Strings["040904b0"] = (versionStringTable = new StringTable("040904b0"));
var vfi = new VarFileInfo();
versionResource["VarFileInfo"] = vfi;
var translation = new VarTable("Translation");
vfi.Vars["Translation"] = translation;
translation[0x0409] = 0x04b0;
}
versionResource.FileVersion = FileVersion;
versionResource.ProductVersion = ProductVersion;
versionStringTable["ProductName"] = ProductName;
versionStringTable["CompanyName"] = CompanyName;
versionStringTable["FileDescription"] = FileDescription;
versionStringTable["Comments"] = _comments;
versionStringTable["Assembly Version"] = _assemblyVersion;
versionStringTable["FileVersion"] = _fileVersion;
versionStringTable["ProductVersion"] = _productVersion;
versionStringTable["InternalName"] = _internalName;
versionStringTable["OriginalFilename"] = _originalFilename;
versionStringTable["LegalCopyright"] = _legalCopyright;
versionStringTable["LegalTrademarks"] = _legalTrademarks;
versionStringTable["BugTracker"] = _bugTracker;
versionResource.SaveTo(tmpFilename);
} catch (Exception e) {
Console.WriteLine("{0} -- {1}", e.Message, e.StackTrace);
}
// strong name the binary
if (IsManaged && StrongNameKeyCertificate != null && (StrongNameKeyCertificate.Certificate.PrivateKey is RSACryptoServiceProvider)) {
ApplyStrongName(tmpFilename, StrongNameKeyCertificate);
}
// sign the binary
if (_signingCertificate != null) {
SignFile(tmpFilename, SigningCertificate.Certificate);
}
_filename.TryHardToDelete();
File.Move(tmpFilename, _filename);
} catch (Exception e) {
#if TODO
Logger.Error(e);
#endif
// get rid of whatever we tried
tmpFilename.TryHardToDelete();
// as you were...
throw;
}
}
_pendingChanges = false;
if (_manifest != null) {
_manifest.Modified = false;
}
}
}
private static bool SetVersionString(StringFileInfo stringFileInfo, string versionName, string value)
{
return stringFileInfo.Children.Select(t => SetVersionString(t, versionName, value)).AnyOfAll();
}
public VersionInfo GetInfo(uint languageId)
{
byte[] data = GetBytes(languageId);
using (MemoryStream mem = new MemoryStream(data))
{
ushort len = Utils.ReadUInt16(mem);
ushort val_len = Utils.ReadUInt16(mem);
ushort type = Utils.ReadUInt16(mem);
string key = Utils.ReadUnicodeString(mem);
if (mem.Position % 4 != 0)
Utils.ReadUInt16(mem);
FixedFileInfo fixed_file_info = new FixedFileInfo(mem);
if (mem.Position % 4 != 0)
Utils.ReadUInt16(mem);
StringFileInfo string_file_info = new StringFileInfo(this, mem);
if (mem.Position % 4 != 0)
Utils.ReadUInt16(mem);
VarFileInfo var_file_info = new VarFileInfo(this, mem);
VersionInfo info = new VersionInfo(this, languageId, fixed_file_info, string_file_info, var_file_info);
return info;
}
}
public FakeFileInfo(StringFileInfo strFi, string path)
{
_fi = strFi;
PhysicalPath = Path.Combine(path, strFi.Name);
}
public Task<Binary> Save()
{
lock (this) {
if (_saving != null) {
return _saving;
}
if (Unloaded) {
throw new CoAppBinaryException("Binary '{0}' has been unloaded", Filename);
}
if (!Modified) {
return this.AsResultTask();
}
_saving = Task<Binary>.Factory.StartNew(() => {
// Console.WriteLine("Actual Signing Process started for [{0}]/[{1}]", Filename , WorkingCopy);
if (!IsManaged) {
StripSignatures(WorkingCopy); // this is irrelevant if the binary is managed--we'll be writing out a new one.
}
if (!_loadOptions.HasFlag(BinaryLoadOptions.NoManaged) && IsManaged && (_modifiedManaged || _modifiedResources)) {
WaitForResourceAndManagedLoaders();
// handle managed code rewrites
// we can only edit the file if it's IL only, mixed mode assemblies can only be strong named, signed and native-resource-edited.
// set the strong name key data
if (!StrongNameKey.IsNullOrEmpty()) {
if (_mutableAssembly == null) {
Console.WriteLine("HEY! : {0}", Filename);
}
_mutableAssembly.PublicKey = StrongNameKey.ToList();
// change any assembly attributes we need to change
if (_mutableAssembly != null) {
if (StrongNameKeyCertificate != null) {
foreach (var ar in _mutableAssembly.AssemblyReferences) {
// rewrite assembly references that need to be updated.
if (!ar.PublicKeyToken.Any()) {
var dep = FindAssembly(ar.Name.Value, ar.Version.ToString());
if (dep == null) {
// can't strong name a file that doesn't have its deps all strong named.
throw new CoAppException("dependent assembly '{0}-{1}' not available for strong naming".format(ar.Name.Value,
ar.Version.ToString()));
}
if (dep._mutableAssembly.PublicKey.IsNullOrEmpty()) {
if (!_loadOptions.HasFlag(BinaryLoadOptions.NoUnsignedManagedDependencies)) {
Console.WriteLine(
"Warning: Non-strong-named dependent reference found: '{0}-{1}' updating with same strong-name-key.",
ar.Name, ar.Version);
dep.StrongNameKeyCertificate = StrongNameKeyCertificate;
dep.SigningCertificate = SigningCertificate;
dep.AssemblyCopyright = AssemblyCopyright;
dep.AssemblyCompany = AssemblyCompany;
dep.AssemblyProduct = AssemblyProduct;
// wait for the dependency to finish saving.
dep.Save().Wait();
} else {
throw new CoAppException("dependent assembly '{0}-{1}' not strong named".format(ar.Name.Value,
ar.Version.ToString()));
}
}
(ar as Microsoft.Cci.MutableCodeModel.AssemblyReference).PublicKeyToken =
dep._mutableAssembly.PublicKeyToken.ToList();
(ar as Microsoft.Cci.MutableCodeModel.AssemblyReference).PublicKey = dep._mutableAssembly.PublicKey;
}
}
}
}
// we should see if we can get assembly attributes, since sometimes they can be set, but not the native ones.
try {
if (!_mutableAssembly.AssemblyAttributes.IsNullOrEmpty()) {
foreach (var a in _mutableAssembly.AssemblyAttributes) {
var attributeArgument = (a.Arguments.FirstOrDefault() as MetadataConstant);
if (attributeArgument != null) {
var attributeName = a.Type.ToString();
switch (attributeName) {
case "System.Reflection.AssemblyTitleAttribute":
attributeArgument.Value = string.IsNullOrEmpty(AssemblyTitle) ? string.Empty : AssemblyTitle;
break;
case "System.Reflection.AssemblyDescriptionAttribute":
attributeArgument.Value = string.IsNullOrEmpty(AssemblyDescription) ? string.Empty : AssemblyDescription;
break;
case "System.Reflection.AssemblyCompanyAttribute":
attributeArgument.Value = string.IsNullOrEmpty(AssemblyCompany) ? string.Empty : AssemblyCompany;
break;
case "System.Reflection.AssemblyProductAttribute":
attributeArgument.Value = string.IsNullOrEmpty(AssemblyProduct) ? string.Empty : AssemblyProduct;
break;
//case "System.Reflection.AssemblyVersionAttribute":
// attributeArgument.Value = (string)AssemblyVersion;
// break;
case "System.Reflection.AssemblyFileVersionAttribute":
attributeArgument.Value = (string)AssemblyFileVersion;
break;
case "System.Reflection.AssemblyCopyrightAttribute":
attributeArgument.Value = string.IsNullOrEmpty(AssemblyCopyright) ? string.Empty : AssemblyCopyright;
break;
case "System.Reflection.AssemblyTrademarkAttribute":
attributeArgument.Value = string.IsNullOrEmpty(AssemblyTrademark) ? string.Empty : AssemblyTrademark;
break;
case "BugTrackerAttribute":
attributeArgument.Value = string.IsNullOrEmpty(BugTracker) ? string.Empty : BugTracker;
break;
}
}
}
}
} catch {
// hmm. carry on.
}
}
// save it to disk
WorkingCopy.TryHardToMakeFileWriteable();
using (var peStream = File.Create(WorkingCopy)) {
PeWriter.WritePeToStream(_mutableAssembly, _host, peStream);
}
}
if (!_loadOptions.HasFlag(BinaryLoadOptions.NoManifest) && Manifest.Value != null && Manifest.Value.Modified) {
// rewrite Manifests
// GS01: We only support one manifest right now.
// so we're gonna remove the extra ones.
// figure out the bigger case later.
var manifestKeys = NativeResources.Value.Resources.Keys.Where(each => each.ResourceType == ResourceTypes.RT_MANIFEST).ToArray();
foreach (var k in manifestKeys) {
var v = NativeResources.Value.Resources[k];
if (!v.IsNullOrEmpty()) {
foreach (var inst in v) {
Resource.Delete(WorkingCopy, inst.Type, inst.Name, inst.Language);
}
}
NativeResources.Value.Resources.Remove(k);
}
var IsLibrary = Path.GetExtension(Filename).ToLower() == ".dll";
var manifestResource = new ManifestResource(IsLibrary ? ManifestType.IsolationAware : ManifestType.CreateProcess) {ManifestText = Manifest.Value.ToString(), Language = 1033};
// GS01: I'm hardcoding this for now. We're probably gonna have to be way smarter about this.
NativeResources.Value.Resources.Add(new ResourceId(ResourceTypes.RT_MANIFEST), new List<Resource> {
manifestResource
});
manifestResource.SaveTo(WorkingCopy);
}
if (!_loadOptions.HasFlag(BinaryLoadOptions.NoResources) && _modifiedResources) {
// rewrite Resources
VersionResource versionResource;
StringTable versionStringTable;
var versionKey = NativeResources.Value.Resources.Keys.FirstOrDefault(each => each.ResourceType == ResourceTypes.RT_VERSION);
if (versionKey != null) {
versionResource = NativeResources.Value.Resources[versionKey].First() as VersionResource;
versionStringTable = (versionResource["StringFileInfo"] as StringFileInfo).Strings.Values.First();
} else {
versionResource = new VersionResource();
NativeResources.Value.Resources.Add(new ResourceId(ResourceTypes.RT_VERSION), new List<Resource> {
versionResource
});
var sfi = new StringFileInfo();
versionResource["StringFileInfo"] = sfi;
sfi.Strings["040904b0"] = (versionStringTable = new StringTable("040904b0"));
var vfi = new VarFileInfo();
versionResource["VarFileInfo"] = vfi;
var translation = new VarTable("Translation");
vfi.Vars["Translation"] = translation;
translation[0x0409] = 0x04b0;
}
versionResource.FileVersion = FileVersion;
versionResource.ProductVersion = ProductVersion;
versionStringTable["ProductName"] = ProductName;
versionStringTable["CompanyName"] = CompanyName;
versionStringTable["FileDescription"] = FileDescription;
versionStringTable["Comments"] = _comments;
versionStringTable["Assembly Version"] = AssemblyVersion.Value;
versionStringTable["FileVersion"] = _fileVersion;
versionStringTable["ProductVersion"] = _productVersion;
versionStringTable["InternalName"] = _internalName;
versionStringTable["OriginalFilename"] = _originalFilename;
versionStringTable["LegalCopyright"] = _legalCopyright;
versionStringTable["LegalTrademarks"] = _legalTrademarks;
versionStringTable["BugTracker"] = _bugTracker;
versionResource.SaveTo(WorkingCopy);
}
if (!_loadOptions.HasFlag(BinaryLoadOptions.NoSignature) && _modifiedSignature && _signingCertificate != null) {
// Strongname & Sign the package
// strong name the binary (if we're doing managed stuff).
if (!_loadOptions.HasFlag(BinaryLoadOptions.NoManaged) && IsManaged && StrongNameKeyCertificate != null &&
(StrongNameKeyCertificate.Certificate.PrivateKey is RSACryptoServiceProvider)) {
ApplyStrongName(WorkingCopy, StrongNameKeyCertificate);
}
// sign the binary
SignFile(WorkingCopy, SigningCertificate.Certificate);
}
if (_loadingMD5 != null) {
_loadingMD5 = null;
}
LoadMD5().Wait();
// Console.WriteLine("Replacing original File [{0}]", Filename);
Filename.TryHardToDelete();
File.Copy(WorkingCopy, Filename);
_modified = false;
_modifiedResources = false;
_modifiedManaged = false;
_modifiedSignature = false;
// Console.WriteLine("Completed Signing Process started for [{0}]/[{1}]", Filename, WorkingCopy);
return this;
});
_saving.ContinueWith((a) => {
_saving = null;
}, TaskContinuationOptions.AttachedToParent);
}
return _saving;
}
