public PublicKey Open() { var dialog = new OpenFileDialog() { Filter = PickFilenameConstants.StrongNameKeyFilter, RestoreDirectory = true, }; if (dialog.ShowDialog() != DialogResult.OK) return null; if (string.IsNullOrEmpty(dialog.FileName)) return null; try { var snk = new StrongNameKey(dialog.FileName); return new PublicKey(snk.PublicKey); } catch { } try { var snk = new StrongNamePublicKey(dialog.FileName); return new PublicKey(snk.CreatePublicKey()); } catch { } Shared.App.MsgBox.Instance.Show(string.Format(dnSpy_AsmEditor_Resources.Error_NotSNKFile, dialog.FileName), MsgBoxButton.OK, ownerWindow); return null; }
/// <summary> /// Protects the stub using original project settings replace the current output with the protected stub. /// </summary> /// <param name="context">The working context.</param> /// <param name="fileName">The result file name.</param> /// <param name="module">The stub module.</param> /// <param name="snKey">The strong name key.</param> /// <param name="prot">The packer protection that applies to the stub.</param> protected void ProtectStub(ConfuserContext context, string fileName, byte[] module, StrongNameKey snKey, Protection prot = null) { string tmpDir = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName()); string outDir = Path.Combine(tmpDir, Path.GetRandomFileName()); Directory.CreateDirectory(tmpDir); for (int i = 0; i < context.OutputModules.Count; i++) { string path = Path.GetFullPath(Path.Combine(tmpDir, context.OutputPaths[i])); var dir = Path.GetDirectoryName(path); if (!Directory.Exists(dir)) Directory.CreateDirectory(dir); File.WriteAllBytes(path, context.OutputModules[i]); } File.WriteAllBytes(Path.Combine(tmpDir, fileName), module); var proj = new ConfuserProject(); proj.Seed = context.Project.Seed; foreach (Rule rule in context.Project.Rules) proj.Rules.Add(rule); proj.Add(new ProjectModule { Path = fileName }); proj.BaseDirectory = tmpDir; proj.OutputDirectory = outDir; foreach (var path in context.Project.ProbePaths) proj.ProbePaths.Add(path); proj.ProbePaths.Add(context.Project.BaseDirectory); PluginDiscovery discovery = null; if (prot != null) { var rule = new Rule { Preset = ProtectionPreset.None, Inherit = true, Pattern = "true" }; rule.Add(new SettingItem<Protection> { Id = prot.Id, Action = SettingItemAction.Add }); proj.Rules.Add(rule); discovery = new PackerDiscovery(prot); } try { ConfuserEngine.Run(new ConfuserParameters { Logger = new PackerLogger(context.Logger), PluginDiscovery = discovery, Marker = new PackerMarker(snKey), Project = proj, PackerInitiated = true }, context.token).Wait(); } catch (AggregateException ex) { context.Logger.Error("Failed to protect packer stub."); throw new ConfuserException(ex); } context.OutputModules = new[] { File.ReadAllBytes(Path.Combine(outDir, fileName)) }; context.OutputPaths = new[] { fileName }; }
/// <summary> /// Calculates and returns the strong name signature /// </summary> /// <param name="snk">Strong name key used for signing</param> /// <param name="snSigOffset">Offset (relative to start of PE file) of the strong /// name signature.</param> /// <returns>The strong name signature</returns> public byte[] CalculateSignature(StrongNameKey snk, long snSigOffset) { uint snSigSize = (uint)snk.SignatureSize; var hashAlg = snk.HashAlgorithm == 0 ? AssemblyHashAlgorithm.SHA1 : snk.HashAlgorithm; var hash = StrongNameHashData(hashAlg, snSigOffset, snSigSize); var snSig = GetStrongNameSignature(snk, hashAlg, hash); if (snSig.Length != snSigSize) throw new InvalidOperationException("Invalid strong name signature size"); return snSig; }
public PublicKey Open() { var dialog = new OpenFileDialog() { Filter = PickFilenameConstants.StrongNameKeyFilter, RestoreDirectory = true, }; if (dialog.ShowDialog() != DialogResult.OK) return null; if (string.IsNullOrEmpty(dialog.FileName)) return null; try { var snk = new StrongNameKey(dialog.FileName); return new PublicKey(snk.PublicKey); } catch { } MainWindow.Instance.ShowMessageBox(string.Format("'{0}' is not a strong name key file (snk)", dialog.FileName), MessageBoxButton.OK, ownerWindow); return null; }
/// <summary> /// Creates a counter signature, just like /// <c>sn -a IdentityPubKey.snk IdentityKey.snk SignaturePubKey.snk</c> can do. /// The public key <c>sn</c> prints is <paramref name="signaturePubKey"/>'s value. /// </summary> /// <param name="identityPubKey">Identity public key</param> /// <param name="identityKey">Identity strong name key pair</param> /// <param name="signaturePubKey">Signature public key</param> /// <returns>The counter signature</returns> public static byte[] CreateCounterSignature(StrongNamePublicKey identityPubKey, StrongNameKey identityKey, StrongNamePublicKey signaturePubKey) { var hash = AssemblyHash.Hash(signaturePubKey.CreatePublicKey(), identityPubKey.HashAlgorithm); using (var rsa = identityKey.CreateRSA()) { var rsaFmt = new RSAPKCS1SignatureFormatter(rsa); string hashName = identityPubKey.HashAlgorithm.GetName(); rsaFmt.SetHashAlgorithm(hashName); var snSig = rsaFmt.CreateSignature(hash); Array.Reverse(snSig); return snSig; } }
/// <summary> /// Creates a counter signature, just like /// <c>sn -a IdentityPubKey.snk IdentityKey.snk SignaturePubKey.snk</c> can do. /// The public key <c>sn</c> prints is <paramref name="signaturePubKey"/>'s value. /// </summary> /// <param name="identityPubKey">Identity public key</param> /// <param name="identityKey">Identity strong name key pair</param> /// <param name="signaturePubKey">Signature public key</param> /// <returns>The counter signature as a hex string</returns> public static string CreateCounterSignatureAsString(StrongNamePublicKey identityPubKey, StrongNameKey identityKey, StrongNamePublicKey signaturePubKey) { var counterSignature = CreateCounterSignature(identityPubKey, identityKey, signaturePubKey); return Utils.ToHex(counterSignature, false); }
public PackerMarker(StrongNameKey snKey) { this.snKey = snKey; }
/// <summary> /// Calculates the strong name signature and writes it to the stream. The signature /// is also returned. /// </summary> /// <param name="snk">Strong name key used for signing</param> /// <param name="snSigOffset">Offset (relative to the start of the PE file) of the strong /// name signature.</param> /// <returns>The strong name signature</returns> public byte[] WriteSignature(StrongNameKey snk, long snSigOffset) { var sign = CalculateSignature(snk, snSigOffset); stream.Position = baseOffset + snSigOffset; stream.Write(sign, 0, sign.Length); return sign; }
/// <summary> /// Returns the strong name signature /// </summary> /// <param name="snk">Strong name key</param> /// <param name="hashAlg">Hash algorithm</param> /// <param name="hash">Strong name hash of the .NET PE file</param> /// <returns>Strong name signature</returns> byte[] GetStrongNameSignature(StrongNameKey snk, AssemblyHashAlgorithm hashAlg, byte[] hash) { using (var rsa = snk.CreateRSA()) { var rsaFmt = new RSAPKCS1SignatureFormatter(rsa); string hashName = hashAlg.GetName() ?? AssemblyHashAlgorithm.SHA1.GetName(); rsaFmt.SetHashAlgorithm(hashName); var snSig = rsaFmt.CreateSignature(hash); Array.Reverse(snSig); return snSig; } }
/// <summary> /// Adds or updates an existing <c>System.Reflection.AssemblySignatureKeyAttribute</c> /// attribute. This attribute is used in enhanced strong naming with key migration. /// See http://msdn.microsoft.com/en-us/library/hh415055.aspx /// </summary> /// <param name="identityPubKey">Identity public key</param> /// <param name="identityKey">Identity strong name key pair</param> /// <param name="signaturePubKey">Signature public key</param> public void UpdateOrCreateAssemblySignatureKeyAttribute(StrongNamePublicKey identityPubKey, StrongNameKey identityKey, StrongNamePublicKey signaturePubKey) { var manifestModule = ManifestModule; if (manifestModule == null) { return; } // Remove all existing attributes var ca = CustomAttributes.ExecuteLocked <CustomAttribute, object, CustomAttribute>(null, (tsList, arg) => { CustomAttribute foundCa = null; for (int i = 0; i < tsList.Count_NoLock(); i++) { var caTmp = tsList.Get_NoLock(i); if (caTmp.TypeFullName != "System.Reflection.AssemblySignatureKeyAttribute") { continue; } tsList.RemoveAt_NoLock(i); i--; if (foundCa == null) { foundCa = caTmp; } } return(foundCa); }); if (IsValidAssemblySignatureKeyAttribute(ca)) { ca.NamedArguments.Clear(); } else { ca = CreateAssemblySignatureKeyAttribute(); } var counterSig = StrongNameKey.CreateCounterSignatureAsString(identityPubKey, identityKey, signaturePubKey); ca.ConstructorArguments[0] = new CAArgument(manifestModule.CorLibTypes.String, new UTF8String(signaturePubKey.ToString())); ca.ConstructorArguments[1] = new CAArgument(manifestModule.CorLibTypes.String, new UTF8String(counterSig)); CustomAttributes.Add(ca); }
/// <summary> /// Creates a counter signature, just like /// <c>sn -a IdentityPubKey.snk IdentityKey.snk SignaturePubKey.snk</c> can do. /// The public key <c>sn</c> prints is <paramref name="signaturePubKey"/>'s value. /// </summary> /// <param name="identityPubKey">Identity public key</param> /// <param name="identityKey">Identity strong name key pair</param> /// <param name="signaturePubKey">Signature public key</param> /// <returns>The counter signature</returns> public static byte[] CreateCounterSignature(StrongNamePublicKey identityPubKey, StrongNameKey identityKey, StrongNamePublicKey signaturePubKey) { var hash = AssemblyHash.Hash(signaturePubKey.CreatePublicKey(), identityPubKey.HashAlgorithm); using (var rsa = identityKey.CreateRSA()) { var rsaFmt = new RSAPKCS1SignatureFormatter(rsa); string hashName = identityPubKey.HashAlgorithm.GetName(); rsaFmt.SetHashAlgorithm(hashName); var snSig = rsaFmt.CreateSignature(hash); Array.Reverse(snSig); return(snSig); } }
/// <summary> /// Creates a counter signature, just like /// <c>sn -a IdentityPubKey.snk IdentityKey.snk SignaturePubKey.snk</c> can do. /// The public key <c>sn</c> prints is <paramref name="signaturePubKey"/>'s value. /// </summary> /// <param name="identityPubKey">Identity public key</param> /// <param name="identityKey">Identity strong name key pair</param> /// <param name="signaturePubKey">Signature public key</param> /// <returns>The counter signature as a hex string</returns> public static string CreateCounterSignatureAsString(StrongNamePublicKey identityPubKey, StrongNameKey identityKey, StrongNamePublicKey signaturePubKey) { var counterSignature = CreateCounterSignature(identityPubKey, identityKey, signaturePubKey); return(Utils.ToHex(counterSignature, false)); }
/// <summary> /// Adds or updates an existing <c>System.Reflection.AssemblySignatureKeyAttribute</c> /// attribute. This attribute is used in enhanced strong naming with key migration. /// See http://msdn.microsoft.com/en-us/library/hh415055.aspx /// </summary> /// <param name="identityPubKey">Identity public key</param> /// <param name="identityKey">Identity strong name key pair</param> /// <param name="signaturePubKey">Signature public key</param> public void UpdateOrCreateAssemblySignatureKeyAttribute(StrongNamePublicKey identityPubKey, StrongNameKey identityKey, StrongNamePublicKey signaturePubKey) { if (ManifestModule == null) { return; } // Remove all existing attributes CustomAttribute ca = null; for (int i = 0; i < CustomAttributes.Count; i++) { var caTmp = CustomAttributes[i]; if (caTmp.TypeFullName != "System.Reflection.AssemblySignatureKeyAttribute") { continue; } CustomAttributes.RemoveAt(i); i--; if (ca == null) { ca = caTmp; } } if (IsValidAssemblySignatureKeyAttribute(ca)) { ca.NamedArguments.Clear(); } else { ca = CreateAssemblySignatureKeyAttribute(); } var counterSig = StrongNameKey.CreateCounterSignatureAsString(identityPubKey, identityKey, signaturePubKey); ca.ConstructorArguments[0] = new CAArgument(ManifestModule.CorLibTypes.String, new UTF8String(signaturePubKey.ToString())); ca.ConstructorArguments[1] = new CAArgument(ManifestModule.CorLibTypes.String, new UTF8String(counterSig)); CustomAttributes.Add(ca); }