/// <summary> /// Get the public key from a key pair blob /// </summary> /// <exception cref="ArgumentNullException"> /// If <paramref name="keyPair"/> is null /// </exception> /// <exception cref="InvalidOperationException"> /// If the key could not be extracted /// </exception> /// <param name="keyPair">key blob to get the public key from</param> /// <returns>public key blob</returns> public static byte[] ExtractPublicKeyFromKeyPair(byte[] keyPair) { if (keyPair == null) { throw new ArgumentNullException("keyPair"); } // extract the public key portion of the blob IntPtr publicKeyBuffer = IntPtr.Zero; try { int publicKeyBlobSize = 0; if (!StrongNameNative.StrongNameGetPublicKey( null, keyPair, keyPair.Length, out publicKeyBuffer, out publicKeyBlobSize)) { Marshal.ThrowExceptionForHR(StrongNameNative.StrongNameErrorInfo()); } // copy the key out of unmanaged memory, and return it byte[] publicKeyBlob = new byte[publicKeyBlobSize]; Marshal.Copy(publicKeyBuffer, publicKeyBlob, 0, publicKeyBlobSize); return(publicKeyBlob); } finally { if (publicKeyBuffer != IntPtr.Zero) { StrongNameNative.StrongNameFreeBuffer(publicKeyBuffer); } } }
/// <summary> /// Get the public key from a key container /// </summary> /// <exception cref="ArgumentNullException"> /// If <paramref name="keyContainer"/> is null /// </exception> /// <exception cref="ArgumentException"> /// If <paramref name="keyContainer"/> is empty /// </exception> /// <exception cref="InvalidOperationException"> /// If the key could not be extracted /// </exception> /// <param name="keyContainer">key container to get the public key from</param> /// <returns>public key blob</returns> public static byte[] ExtractPublicKeyFromKeyContainer(string keyContainerName) { if (string.IsNullOrEmpty(keyContainerName)) { throw new ArgumentNullOrEmptyException("keyContainerName"); } // extract the public key portion of the blob IntPtr publicKeyBuffer = IntPtr.Zero; try { int publicKeyBlobSize = 0; if (!StrongNameNative.StrongNameGetPublicKey( keyContainerName, null, 0, out publicKeyBuffer, out publicKeyBlobSize)) { Marshal.ThrowExceptionForHR(StrongNameNative.StrongNameErrorInfo()); } // copy the key out of unmanaged memory, and return it byte[] publicKeyBlob = new byte[publicKeyBlobSize]; Marshal.Copy(publicKeyBuffer, publicKeyBlob, 0, publicKeyBlobSize); return(publicKeyBlob); } finally { if (publicKeyBuffer != IntPtr.Zero) { StrongNameNative.StrongNameFreeBuffer(publicKeyBuffer); } } }
/// <summary> /// Delete a key from a key container /// </summary> /// <exception cref="ArgumentNullException"> /// If <paramref name="keyContainerName"/> is null /// </exception> /// <exception cref="InvalidOperationException"> /// If the key container could not be deleted /// </exception> /// <param name="keyContainerName">name of the key container to delete</param> public static void DeleteKey(string keyContainerName) { if (string.IsNullOrEmpty(keyContainerName)) { throw new ArgumentNullOrEmptyException("keyContainerName"); } if (!StrongNameNative.StrongNameKeyDelete(keyContainerName)) { Marshal.ThrowExceptionForHR(StrongNameNative.StrongNameErrorInfo()); } }
/// <summary> /// Install a key into a key container /// </summary> /// <param name="keyBlob">Key pair blob</param> /// <param name="keyContainerName">Name of the key container to install the keys into</param> public static void InstallKey(byte[] keyBlob, string keyContainerName) { if (keyBlob == null) { throw new ArgumentNullException("keyBlob"); } if (string.IsNullOrEmpty(keyContainerName)) { throw new ArgumentNullOrEmptyException("keyContainerName"); } if (!StrongNameNative.StrongNameKeyInstall(keyContainerName, keyBlob, keyBlob.Length)) { Marshal.ThrowExceptionForHR(StrongNameNative.StrongNameErrorInfo()); } }
/// <summary> /// Verify an assembly's strong name /// </summary> /// <exception cref="ArgumentNullException"> /// If <paramref name="filePath"/> is null /// </exception> /// <exception cref="ArgumentException"> /// If <paramref name="filePath"/> is empty /// </exception> /// <exception cref="InvalidOperationException"> /// If verification could not complete /// </exception> /// <param name="filePath">assembly to verify</param> /// <param name="forceVerification">true to ignore the skip verify registry </param> /// <returns>result of the strong name verification</returns> public static bool VerifyAssembly(string filePath, bool forceVerification) { try { // do the verification bool wasVerified = false; if (!StrongNameNative.StrongNameSignatureVerificationEx( filePath, forceVerification, ref wasVerified)) { return(false); } return(wasVerified); } catch (Exception) { return(false); } }
/// <summary> /// Generate a key pair blob /// </summary> /// <exception cref="ArgumentOutOfRangeException"> /// If <paramref name="keySize"/> is not positive /// </exception> /// <exception cref="InvalidOperationException"> /// If the key could not be generated /// </exception> /// <param name="keySize">size, in bits, of the key to generate</param> /// <returns>generated key pair blob</returns> public static byte[] GenerateKeyPair(int keySize) { if (keySize <= 0) { throw new ArgumentOutOfRangeException("keySize"); } // variables that hold the unmanaged key IntPtr keyBlob = IntPtr.Zero; long generatedSize = 0; try { // create the key if (!StrongNameNative.StrongNameKeyGenEx( null, StrongNameKeyGenFlags.None, (int)keySize, out keyBlob, out generatedSize)) { Marshal.ThrowExceptionForHR(StrongNameNative.StrongNameErrorInfo()); } // make sure the key size makes sense if (generatedSize <= 0 || generatedSize > int.MaxValue) { throw new InvalidOperationException(); } // get the key into managed memory byte[] key = new byte[generatedSize]; Marshal.Copy(keyBlob, key, 0, (int)generatedSize); return(key); } finally { // release the unmanaged memory the key resides in if (keyBlob != IntPtr.Zero) { StrongNameNative.StrongNameFreeBuffer(keyBlob); } } }
/// <summary> /// Create a public key token from a signed assembly /// </summary> /// <exception cref="ArgumentNullException"> /// If <paramref name="filePath"/> is null /// </exception> /// <exception cref="ArgumentException"> /// If <paramref name="filePath"/> is empty /// </exception> /// <exception cref="InvalidOperationException"> /// If the token could not be generated /// </exception> /// <param name="filePath">assembly to generate the token of</param> /// <returns>public key token of <paramref name="filePath"/></returns> public static byte[] CreateTokenFromAssembly(string filePath) { if (string.IsNullOrEmpty(filePath)) { throw new ArgumentNullOrEmptyException("filePath"); } // get the key and token IntPtr blobBuffer = IntPtr.Zero; IntPtr tokenBuffer = IntPtr.Zero; try { int blobSize = 0; int tokenSize = 0; // extract the public key token if (!StrongNameNative.StrongNameTokenFromAssemblyEx( filePath, out tokenBuffer, out tokenSize, out blobBuffer, out blobSize)) { Marshal.ThrowExceptionForHR(StrongNameNative.StrongNameErrorInfo()); } // copy the token out of unmanaged memory, and return it byte[] token = new byte[tokenSize]; Marshal.Copy(tokenBuffer, token, 0, tokenSize); return(token); } finally { if (blobBuffer != IntPtr.Zero) { StrongNameNative.StrongNameFreeBuffer(blobBuffer); } if (tokenBuffer != IntPtr.Zero) { StrongNameNative.StrongNameFreeBuffer(tokenBuffer); } } }
/// <summary> /// Create a public key token from a public key /// </summary> /// <exception cref="ArgumentNullException"> /// If <paramref name="publicKey"/> is null /// </exception> /// <exception cref="InvalidOperationException"> /// If the token could not be generated /// </exception> /// <param name="publicKey">public key to generate the token for</param> /// <returns>public key token of <paramref name="publicKey"/></returns> public static byte[] CreateTokenFromPublicKey(byte[] publicKey) { if (publicKey == null || publicKey.Length == 0) { throw new ArgumentNullOrEmptyException("publicKey"); } IntPtr tokenPointer = IntPtr.Zero; int tokenSize = 0; try { // generate the token if (!StrongNameNative.StrongNameTokenFromPublicKey( publicKey, publicKey.Length, out tokenPointer, out tokenSize)) { Marshal.ThrowExceptionForHR(StrongNameNative.StrongNameErrorInfo()); } // make sure the key size makes sense if (tokenSize <= 0 || tokenSize > int.MaxValue) { throw new InvalidOperationException(); } // get the key into managed memory byte[] token = new byte[tokenSize]; Marshal.Copy(tokenPointer, token, 0, tokenSize); return(token); } finally { // release the token memory if (tokenPointer != IntPtr.Zero) { StrongNameNative.StrongNameFreeBuffer(tokenPointer); } } }
/// <summary> /// Generates a strong name signature for the specified assembly, according to the specified flags. /// </summary> /// <param name="filePath">The path to the file that contains the manifest of the assembly for which the /// strong name signature will be generated.</param> /// <param name="keyPair">A pointer to the public/private key pair.</param> /// <param name="flags">Flags</param> public static byte[] GenerateSignatureFromKeyContainer(string filePath, string keyContainerName, StrongNameGenerationFlags flags) { if (string.IsNullOrEmpty(filePath)) { throw new ArgumentNullOrEmptyException("filePath"); } if (string.IsNullOrEmpty(keyContainerName)) { throw new ArgumentNullOrEmptyException("keyContainerName"); } IntPtr signatureBlobPtr = IntPtr.Zero; try { int signatureBlobSize = 0; if (!StrongNameNative.StrongNameSignatureGenerationEx( filePath, keyContainerName, null, 0, out signatureBlobPtr, out signatureBlobSize, flags)) { Marshal.ThrowExceptionForHR(StrongNameNative.StrongNameErrorInfo()); } byte[] signatureBlob = new byte[signatureBlobSize]; Marshal.Copy(signatureBlobPtr, signatureBlob, 0, signatureBlobSize); return(signatureBlob); } finally { if (signatureBlobPtr != IntPtr.Zero) { StrongNameNative.StrongNameFreeBuffer(signatureBlobPtr); } } }