/// <summary> /// Gets a value indicating whether the assembly manifest at the supplied /// path contains a strong name signature. /// </summary> /// <param name="assemblyPath">The path to the portable executable (.exe or /// .dll) file for the assembly to be verified.</param> /// <returns>True if the verification was successful; otherwise, false.</returns> /// <remarks>VerifyStrongName is a utility function to check the validity /// of an assembly, taking into account registry settings.</remarks> public static bool VerifyStrongName(string assemblyPath) { ICLRStrongName strongName = ClrMetaHost.CurrentRuntime.GetInterface <ICLRStrongName>( new Guid(0xB79B0ACD, 0xF5CD, 0x409b, 0xB5, 0xA5, 0xA1, 0x62, 0x44, 0x61, 0x0B, 0x92)); return(strongName.StrongNameSignatureVerificationEx(assemblyPath, 1) != 0); }
/* leave this out for now. We'll make the command line compilers have this behavior, but * not the compiler library. This differs from previous versions because specifying a keyfile * and container through either the command line or attributes gave this "install the key" behavior. * * * //EDMAURER alink had weird, MSDN spec'd behavior. from MSDN "In case both /keyfile and /keycontainer are * //specified (either by command-line option or by custom attribute) in the same compilation, the compiler * //first tries the key container. If that succeeds, then the assembly is signed with the information in the * //key container. If the compiler does not find the key container, it tries the file specified with /keyfile. * //If this succeeds, the assembly is signed with the information in the key file, and the key information is * //installed in the key container (similar to sn -i) so that on the next compilation, the key container will * //be valid. * * private static ImmutableArray<byte> GetPublicKeyAndPossiblyInstall(string keyFilename, string keyContainer) * { * if (keyContainer != null) * { * ImmutableArray<byte> result = GetPublicKey(keyContainer); * * if (result.IsNotNull) * return result; * } * * if (keyFilename != null) * { * byte[] keyFileContents = System.IO.File.ReadAllBytes(keyFilename); * * if (keyContainer != null) * InstallKey(keyFileContents, keyFilename); * * return GetPublicKey(keyFileContents); * } * * return default(ImmutableArray<byte>); * } */ /// <exception cref="IOException"/> private static void Sign(string filePath, string keyName) { try { ICLRStrongName strongName = GetStrongNameInterface(); int unused; strongName.StrongNameSignatureGeneration(filePath, keyName, IntPtr.Zero, 0, null, out unused); } catch (COMException ex) { throw new IOException(ex.Message, ex); } }
// internal for testing internal static ImmutableArray <byte> GetPublicKey(string keyContainer) { ICLRStrongName strongName = GetStrongNameInterface(); IntPtr keyBlob; int keyBlobByteCount; strongName.StrongNameGetPublicKey(keyContainer, default(IntPtr), 0, out keyBlob, out keyBlobByteCount); byte[] pubKey = new byte[keyBlobByteCount]; Marshal.Copy(keyBlob, pubKey, 0, keyBlobByteCount); strongName.StrongNameFreeBuffer(keyBlob); return(pubKey.AsImmutableOrNull()); }
/// <exception cref="IOException"/> private static void Sign(string filePath, ImmutableArray <byte> keyPair) { try { ICLRStrongName strongName = GetStrongNameInterface(); using (var pinned = PinnedImmutableArray.Create(keyPair)) { int unused; strongName.StrongNameSignatureGeneration(filePath, null, pinned.Pointer, keyPair.Length, null, out unused); } } catch (COMException ex) { throw new IOException(ex.Message, ex); } }
// internal for testing /// <exception cref="IOException"/> internal static ImmutableArray <byte> GetPublicKey(byte[] keyFileContents) { try { var lastSeen = lastSeenKeyPair; if (lastSeen != null && ByteSequenceComparer.ValueEquals(lastSeen.Item1, keyFileContents)) { return(lastSeen.Item2); } ICLRStrongName strongName = GetStrongNameInterface(); IntPtr keyBlob; int keyBlobByteCount; //EDMAURER use marshal to be safe? unsafe { fixed(byte *p = keyFileContents) { try { strongName.StrongNameGetPublicKey(null, (IntPtr)p, keyFileContents.Length, out keyBlob, out keyBlobByteCount); } catch (ArgumentException ex) { throw new IOException(ex.Message); } } } byte[] pubKey = new byte[keyBlobByteCount]; Marshal.Copy(keyBlob, pubKey, 0, keyBlobByteCount); strongName.StrongNameFreeBuffer(keyBlob); var result = pubKey.AsImmutableOrNull(); lastSeenKeyPair = Tuple.Create(keyFileContents, result); return(result); } catch (COMException ex) { throw new IOException(ex.Message); } }
/// <exception cref="IOException"/> private static unsafe void Sign(string filePath, ImmutableArray <byte> keyPair) { try { ICLRStrongName strongName = GetStrongNameInterface(); fixed(byte *pinned = keyPair.ToArray()) { int unused; strongName.StrongNameSignatureGeneration(filePath, null, (IntPtr)pinned, keyPair.Length, null, out unused); } } catch (COMException ex) { throw new IOException(ex.Message, ex); } }
private unsafe static void InstallKey(byte[] keyBlob, string keyName) { try { ICLRStrongName strongName = DesktopStrongNameProvider.GetStrongNameInterface(); //EDMAURER use marshal to be safe? fixed(byte *p = keyBlob) { strongName.StrongNameKeyInstall(keyName, (IntPtr)p, keyBlob.Length); } } catch (COMException ex) { if (unchecked ((uint)ex.ErrorCode) != 0x8009000F) { throw; } } }