private static AssemblyInfo SignSingleAssembly(string assemblyPath, string keyPath, string outputDirectory, string password, params string[] probingPaths) { try { PrintMessage(null, LogLevel.Verbose); PrintMessage(string.Format("Strong-name signing '{0}'...", assemblyPath), LogLevel.Verbose); var oldInfo = SigningHelper.GetAssemblyInfo(assemblyPath); var newInfo = SigningHelper.SignAssembly(assemblyPath, keyPath, outputDirectory, password, probingPaths); if (!oldInfo.IsSigned && newInfo.IsSigned) { PrintMessageColor(string.Format("'{0}' was strong-name signed successfully.", newInfo.FilePath), LogLevel.Changes, ConsoleColor.Green); return(newInfo); } else { PrintMessage("Already strong-name signed...", LogLevel.Verbose); } } catch (BadImageFormatException bife) { PrintMessageColor(string.Format("Warning: {0}", bife.Message), LogLevel.Silent, ConsoleColor.Yellow); } catch (Exception ex) { PrintMessageColor(string.Format("Error: {0}", ex.Message), LogLevel.Silent, ConsoleColor.Red); } return(null); }
private static bool TrySignPackagePart(PackagePart packagePart, string keyPath, string keyPassword, bool signedPackage) { if (packagePart.Uri.ToString().EndsWith(".exe") || packagePart.Uri.ToString().EndsWith(".dll")) { string tempPath = Path.GetTempFileName(); try { using (var stream = new FileStream(tempPath, FileMode.OpenOrCreate, FileAccess.Write)) { packagePart.GetStream().CopyTo(stream); } if (!SigningHelper.GetAssemblyInfo(tempPath).IsSigned) { signedPackage = true; SigningHelper.SignAssembly(tempPath, keyPath ?? string.Empty, Path.GetDirectoryName(tempPath), keyPassword ?? string.Empty); using (var stream = new FileStream(tempPath, FileMode.OpenOrCreate, FileAccess.Read)) { stream.CopyTo(packagePart.GetStream(FileMode.Create, FileAccess.Write)); } } } finally { File.Delete(tempPath); } } return(signedPackage); }
public void SignAssembly_NewLocationWithPdb_Should_Succeed() { var tempDir = Path.Combine(TestAssemblyDirectory, Guid.NewGuid().ToString("N")); Directory.CreateDirectory(tempDir); var outDir = Path.Combine(tempDir, "out"); Directory.CreateDirectory(outDir); try { string sourceAssemblyPath = Path.Combine(tempDir, "Brutal.Dev.StrongNameSigner.TestAssembly.A.dll"); File.Copy(Path.Combine(TestAssemblyDirectory, "Brutal.Dev.StrongNameSigner.TestAssembly.A.dll"), sourceAssemblyPath); File.Copy(Path.Combine(TestAssemblyDirectory, "Brutal.Dev.StrongNameSigner.TestAssembly.A.pdb"), Path.Combine(tempDir, "Brutal.Dev.StrongNameSigner.TestAssembly.A.pdb")); SigningHelper.SignAssembly(sourceAssemblyPath, null, outDir); string outAssembly = Path.Combine(outDir, Path.GetFileName(sourceAssemblyPath)); Assert.IsTrue(File.Exists(outAssembly)); Assert.IsTrue(File.Exists(Path.ChangeExtension(outAssembly, ".pdb"))); var info = SigningHelper.GetAssemblyInfo(outAssembly); Assert.IsTrue(info.IsSigned); } finally { Directory.Delete(tempDir, true); } }
private static bool RemoveInvalidFriendAssemblyReferences(string assemblyPath, string keyFile, string keyFilePassword, params string[] probingPaths) { try { PrintMessage(null, LogLevel.Verbose); PrintMessage(string.Format("Removing invalid friend references from '{0}'...", assemblyPath), LogLevel.Verbose); var info = SigningHelper.GetAssemblyInfo(assemblyPath); if (SigningHelper.RemoveInvalidFriendAssemblies(assemblyPath, keyFile, keyFilePassword, probingPaths)) { PrintMessageColor(string.Format("Invalid friend assemblies removed successfully from '{0}'.", assemblyPath), LogLevel.Changes, ConsoleColor.Green); return(true); } else { PrintMessage("No friend references to fix...", LogLevel.Verbose); } } catch (BadImageFormatException bife) { PrintMessageColor(string.Format("Warning: {0}", bife.Message), LogLevel.Silent, ConsoleColor.Yellow); } catch (Exception ex) { PrintMessageColor(string.Format("Error: {0}", ex.Message), LogLevel.Silent, ConsoleColor.Red); } return(false); }
private void ListViewAssembliesDragDrop(object sender, DragEventArgs e) { var data = e.Data.GetData(DataFormats.FileDrop) as IEnumerable <string>; if (data != null) { var assemblies = data.Where(d => (Path.GetExtension(d).Equals(".exe", StringComparison.OrdinalIgnoreCase) || Path.GetExtension(d).Equals(".dll", StringComparison.OrdinalIgnoreCase)) && File.Exists(d)).ToList(); // Add all files in directories. var directories = data.Where(d => Directory.Exists(d) && File.GetAttributes(d).HasFlag(FileAttributes.Directory)).ToList(); directories.ForEach(d => assemblies.AddRange(Directory.GetFiles(d, "*.exe", SearchOption.AllDirectories))); directories.ForEach(d => assemblies.AddRange(Directory.GetFiles(d, "*.dll", SearchOption.AllDirectories))); foreach (var assembly in assemblies) { try { AddAssemblyToList(SigningHelper.GetAssemblyInfo(assembly)); } catch (BadImageFormatException) { MessageBox.Show(string.Format(CultureInfo.CurrentCulture, "Could not get assembly info for '{0}'. This may not be a .NET assembly.", assembly), "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning); } } ResizeColumnWidths(); buttonSign.Enabled = listViewAssemblies.Items.Count > 0; } }
public void GetAssemblyInfo_Detects_Correct_Version_40_Assembly() { var info = SigningHelper.GetAssemblyInfo(Path.Combine(TestAssemblyDirectory, "Brutal.Dev.StrongNameSigner.TestAssembly.NET40.exe")); info.IsManagedAssembly.ShouldBe(true); info.DotNetVersion.ShouldBe("4.0.30319"); }
private static bool FixSingleAssemblyReference(string assemblyPath, string referencePath, string keyFile, string keyFilePassword, params string[] probingPaths) { try { PrintMessage(null, LogLevel.Verbose); PrintMessage(string.Format("Fixing references to '{1}' in '{0}'...", assemblyPath, referencePath), LogLevel.Verbose); var info = SigningHelper.GetAssemblyInfo(assemblyPath); if (SigningHelper.FixAssemblyReference(assemblyPath, referencePath, keyFile, keyFilePassword, probingPaths)) { PrintMessageColor(string.Format("References to '{1}' in '{0}' were fixed successfully.", assemblyPath, referencePath), LogLevel.Changes, ConsoleColor.Green); return(true); } else { PrintMessage("No assembly references to fix...", LogLevel.Verbose); } } catch (BadImageFormatException bife) { PrintMessageColor(string.Format("Warning: {0}", bife.Message), LogLevel.Silent, ConsoleColor.Yellow); } catch (Exception ex) { PrintMessageColor(string.Format("Error: {0}", ex.Message), LogLevel.Silent, ConsoleColor.Red); } return(false); }
public void GetAssemblyInfo_Detects_Signed_40_Assembly() { var info = SigningHelper.GetAssemblyInfo(Path.Combine(TestAssemblyDirectory, "Brutal.Dev.StrongNameSigner.TestAssembly.NET40-Signed.exe")); info.IsSigned.ShouldBe(true); info.IsAnyCpu.ShouldBe(true); }
public void GetAssemblyInfo_Detects_Obfuscated_Assembly() { var info = SigningHelper.GetAssemblyInfo(Path.Combine(TestAssemblyDirectory, "Brutal.Dev.StrongNameSigner.TestAssembly.NET40-Obfuscated.exe")); info.IsSigned.ShouldBe(false); info.IsAnyCpu.ShouldBe(true); info.Is32BitOnly.ShouldBe(false); info.Is32BitPreferred.ShouldBe(false); info.Is64BitOnly.ShouldBe(false); }
public void GetAssemblyInfo_Public_API_Test() { var info = SigningHelper.GetAssemblyInfo(Path.Combine(TestAssemblyDirectory, "Brutal.Dev.StrongNameSigner.TestAssembly.NET20.exe")); info.ShouldNotBe(null); info.DotNetVersion.ShouldBe("2.0.50727"); info.Is32BitOnly.ShouldBe(false); info.Is32BitPreferred.ShouldBe(false); info.Is64BitOnly.ShouldBe(false); info.IsAnyCpu.ShouldBe(true); info.IsSigned.ShouldBe(false); }
private void ButtonAddClick(object sender, EventArgs e) { if (CommonOpenFileDialog.IsPlatformSupported) { using (CommonOpenFileDialog dialog = new CommonOpenFileDialog()) { dialog.Title = openFileDialogAssembly.Title; dialog.DefaultExtension = openFileDialogAssembly.DefaultExt; dialog.Filters.Add(new CommonFileDialogFilter("Assembly files", "*.exe;*.dll")); dialog.EnsurePathExists = true; dialog.EnsureValidNames = true; dialog.IsFolderPicker = false; dialog.Multiselect = true; if (dialog.ShowDialog() == CommonFileDialogResult.Ok) { foreach (var file in dialog.FileNames) { try { AddAssemblyToList(SigningHelper.GetAssemblyInfo(file)); } catch (BadImageFormatException) { MessageBox.Show(string.Format(CultureInfo.CurrentCulture, "Could not get assembly info for '{0}'. This may not be a .NET assembly.", file), "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning); } } } } } else { if (openFileDialogAssembly.ShowDialog() == DialogResult.OK) { foreach (var file in openFileDialogAssembly.FileNames) { try { AddAssemblyToList(SigningHelper.GetAssemblyInfo(file)); } catch (BadImageFormatException) { MessageBox.Show(string.Format(CultureInfo.CurrentCulture, "Could not get assembly info for '{0}'. This may not be a .NET assembly.", file), "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning); } } } } ResizeColumnWidths(); buttonSign.Enabled = listViewAssemblies.Items.Count > 0; }
public void SignAssembly_InPlaceWithoutPdb_Should_Succeed() { var tempDir = Path.Combine(TestAssemblyDirectory, Guid.NewGuid().ToString("N")); Directory.CreateDirectory(tempDir); try { string targetAssemblyPath = Path.Combine(tempDir, "Brutal.Dev.StrongNameSigner.TestAssembly.A.dll"); File.Copy(Path.Combine(TestAssemblyDirectory, "Brutal.Dev.StrongNameSigner.TestAssembly.A.dll"), targetAssemblyPath); SigningHelper.SignAssembly(targetAssemblyPath); var info = SigningHelper.GetAssemblyInfo(targetAssemblyPath); Assert.IsTrue(info.IsSigned); } finally { Directory.Delete(tempDir, true); } }
private static bool SignSingleAssembly(string assemblyPath, string keyPath, string outputDirectory) { try { C.WriteLine(); C.WriteLine("Strong-name signing {0}...", assemblyPath); var info = SigningHelper.GetAssemblyInfo(assemblyPath); if (!info.IsSigned) { info = SigningHelper.SignAssembly(assemblyPath, keyPath, outputDirectory); C.ForegroundColor = ConsoleColor.Green; C.WriteLine("{0} was strong-name signed successfully!", info.FilePath); C.ResetColor(); return(true); } else { C.WriteLine("Already strong-name signed..."); } } catch (BadImageFormatException bife) { C.ForegroundColor = ConsoleColor.Yellow; C.WriteLine("Warning: {0}", bife.Message); C.ResetColor(); } catch (Exception ex) { C.ForegroundColor = ConsoleColor.Red; C.WriteLine("Error: {0}", ex.Message); C.ResetColor(); } return(false); }
private static bool FixSingleAssemblyReference(string assemblyPath, string referencePath) { try { C.WriteLine(); C.WriteLine("Fixing references to '{1}' in '{0}'...", assemblyPath, referencePath); var info = SigningHelper.GetAssemblyInfo(assemblyPath); if (SigningHelper.FixAssemblyReference(assemblyPath, referencePath)) { C.ForegroundColor = ConsoleColor.Green; C.WriteLine("References were fixed successfully!"); C.ResetColor(); return(true); } else { C.WriteLine("Nothing to fix..."); } } catch (BadImageFormatException bife) { C.ForegroundColor = ConsoleColor.Yellow; C.WriteLine("Warning: {0}", bife.Message); C.ResetColor(); } catch (Exception ex) { C.ForegroundColor = ConsoleColor.Red; C.WriteLine("Error: {0}", ex.Message); C.ResetColor(); } return(false); }
private void BackgroundWorkerDoWork(object sender, DoWorkEventArgs e) { e.Result = string.Empty; int progress = 0; int signedFiles = 0; int referenceFixes = 0; var assemblies = e.Argument as IEnumerable <string>; if (assemblies != null) { // We go through assemblies twice and every assembly -1 for reference fixes. double progressMax = assemblies.Count() + (assemblies.Count() * (assemblies.Count() - 1)); foreach (var assembly in assemblies) { AssemblyInfo info = null; try { log.AppendFormat("Strong-name signing {0}...", assembly).AppendLine(); info = SigningHelper.GetAssemblyInfo(assembly); if (!info.IsSigned) { info = SigningHelper.SignAssembly(assembly, keyFile, outputPath); log.Append("Strong-name signed successfully.").AppendLine(); signedFiles++; } else { log.Append("Already strong-name signed...").AppendLine(); } } catch (Exception ex) { log.AppendFormat("Error strong-name signing {0}: {1}", assembly, ex.Message).AppendLine(); } backgroundWorker.ReportProgress(Convert.ToInt32((++progress / progressMax) * 100), info); if (backgroundWorker.CancellationPending) { e.Cancel = true; break; } } var referencesToFix = new List <string>(assemblies); foreach (var assembly in assemblies) { // Go through all the references excluding the file we are working on. foreach (var reference in referencesToFix.Where(r => !r.Equals(assembly))) { backgroundWorker.ReportProgress(Convert.ToInt32((++progress / progressMax) * 100)); if (backgroundWorker.CancellationPending) { e.Cancel = true; break; } log.AppendFormat("Fixing references to {1} in {0}...", assembly, reference).AppendLine(); if (SigningHelper.FixAssemblyReference(assembly, reference)) { log.Append("Reference was found and fixed.").AppendLine(); referenceFixes++; } else { log.Append("Nothing to fix.").AppendLine(); } } } e.Result = string.Format(CultureInfo.CurrentCulture, "{0} out of {1} assemblies were strong-name signed and {2} references were fixed.", signedFiles, assemblies.Count(), referenceFixes); } }
public void GetAssemblyInfo_Public_API_Invalid_File_Should_Throw_Exception() { Assert.Throws <BadImageFormatException>(() => SigningHelper.GetAssemblyInfo(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.System), "calc.exe"))); }
public void GetAssemblyInfo_Public_API_Invalid_Path_Should_Throw_Exception() { Assert.Throws <FileNotFoundException>(() => SigningHelper.GetAssemblyInfo(Path.Combine(TestAssemblyDirectory, "Brutal.Dev.StrongNameSigner.TestAssembly.NET20.doesnotexist"))); }
private void BackgroundWorkerDoWork(object sender, DoWorkEventArgs e) { e.Result = string.Empty; int progress = 0; int signedFiles = 0; int referenceFixes = 0; var processedAssemblyPaths = new HashSet <string>(StringComparer.OrdinalIgnoreCase); var signedAssemblyPaths = new HashSet <string>(StringComparer.OrdinalIgnoreCase); if (e.Argument is IEnumerable <string> assemblyPaths) { var probingPaths = assemblyPaths.Select(f => Path.GetDirectoryName(f)).Distinct().ToArray(); // We go through assemblies three times and every assembly -1 for reference fixes. double progressMax = (assemblyPaths.Count() + (assemblyPaths.Count() * (assemblyPaths.Count() - 1))) * 3; foreach (var filePath in assemblyPaths) { var assemblyPair = new AssemblyPair(); try { log.AppendFormat("Strong-name signing {0}...", filePath).AppendLine(); assemblyPair.OldInfo = SigningHelper.GetAssemblyInfo(filePath); assemblyPair.NewInfo = SigningHelper.SignAssembly(filePath, keyFile, outputPath, password, probingPaths); if (assemblyPair.NewInfo.SigningType == StrongNameType.DelaySigned) { log.Append("Delay-signed assembly signing is not supported yet...").AppendLine(); } else if (!assemblyPair.OldInfo.IsSigned && assemblyPair.NewInfo.IsSigned) { log.Append("Strong-name signed successfully.").AppendLine(); signedAssemblyPaths.Add(assemblyPair.NewInfo.FilePath); signedFiles++; } else { log.Append("Already strong-name signed...").AppendLine(); } processedAssemblyPaths.Add(assemblyPair.NewInfo.FilePath); } catch (Exception ex) { log.AppendFormat("Error strong-name signing {0}: {1}", filePath, ex.Message).AppendLine(); } backgroundWorker.ReportProgress(Convert.ToInt32((++progress / progressMax) * 100), assemblyPair); if (backgroundWorker.CancellationPending) { e.Cancel = true; break; } } var referencesToFix = new HashSet <string>(processedAssemblyPaths, StringComparer.OrdinalIgnoreCase); foreach (var filePath in processedAssemblyPaths) { // Go through all the references excluding the file we are working on. foreach (var reference in referencesToFix.Where(r => !r.Equals(filePath))) { backgroundWorker.ReportProgress(Convert.ToInt32((++progress / progressMax) * 100)); if (backgroundWorker.CancellationPending) { e.Cancel = true; break; } log.AppendFormat("Fixing references to {1} in {0}...", filePath, reference).AppendLine(); if (SigningHelper.FixAssemblyReference(filePath, reference, keyFile, password, probingPaths)) { log.Append("Reference was found and fixed.").AppendLine(); referenceFixes++; } else { log.Append("Nothing to fix.").AppendLine(); } } } // Go through all processed assemblies and remove invalid friend references. foreach (var filePath in signedAssemblyPaths) { backgroundWorker.ReportProgress(Convert.ToInt32((++progress / progressMax) * 100)); if (backgroundWorker.CancellationPending) { e.Cancel = true; break; } log.AppendFormat("Removing invalid friend references from '{0}'...", filePath).AppendLine(); if (SigningHelper.RemoveInvalidFriendAssemblies(filePath, keyFile, password, probingPaths)) { log.Append("Invalid friend assemblies removed.").AppendLine(); referenceFixes++; } else { log.Append("Nothing to fix.").AppendLine(); } } e.Result = string.Format(CultureInfo.CurrentCulture, "{0} out of {1} assemblies were strong-name signed and {2} references were fixed.", signedFiles, assemblyPaths.Count(), referenceFixes); } }