C# X509Store.Remove方法代码示例

        public void CleanUp()
        {
            X509Certificate2 testCA = new X509Certificate2("../../imports/CA.cer");
            X509Certificate2 testCA2 = new X509Certificate2("../../imports/CA2.cer");
            X509Certificate2 testCA3 = new X509Certificate2("../../imports/specimenCa.cer");

            X509Store store = new X509Store(StoreName.Root, StoreLocation.CurrentUser);
            store.Open(OpenFlags.ReadWrite | OpenFlags.OpenExistingOnly);
            try
            {
                if (store.Certificates.Contains(testCA))
                {
                    store.Remove(testCA);
                }
                if (store.Certificates.Contains(testCA2))
                {
                    store.Remove(testCA2);
                }
                if (store.Certificates.Contains(testCA3))
                {
                    store.Remove(testCA3);
                }
            }
            finally
            {
                store.Close();
            }
        }

        /// <summary>
        /// 获取微信现金红包信息接口
        /// 是否需要证书:需要。 
        /// http://pay.weixin.qq.com/wiki/doc/api/cash_coupon.php?chapter=13_6
        /// 使用说明 
        /// 用于商户对已发放的红包进行查询红包的具体信息，可支持普通红包和裂变包。
        /// </summary>
        /// <param name="nonce_str">(必填) String(32) 随机字符串,不长于32位</param>
        /// <param name="mch_billno">(必填) String(28) 商户发放红包的商户订单号</param>
        /// <param name="mch_id">(必填) String(32) 微信支付分配的商户号</param>
        /// <param name="appid">(必填) String(32) 微信分配的公众账号ID</param>
        /// <param name="bill_type">(必填) String(32) 订单类型  例子：MCHT ，通过商户订单号获取红包信息。</param>
        /// <param name="partnerKey">API密钥</param>
        /// <param name="cert_path">秘钥路径</param>
        /// <param name="cert_password">秘钥密码</param>
        /// <returns>返回xml字符串，格式参见：http://pay.weixin.qq.com/wiki/doc/api/cash_coupon.php?chapter=13_6 </returns>
        public static string GetHbInfo(string nonce_str, string mch_billno, string mch_id, string appid,
            string bill_type, string partnerKey, string cert_path, string cert_password)
        {
            try
            {
                var stringADict = new Dictionary<string, string>();
                stringADict.Add("nonce_str", nonce_str);
                stringADict.Add("mch_billno", mch_billno);
                stringADict.Add("mch_id", mch_id);
                stringADict.Add("appid", appid);
                stringADict.Add("bill_type", bill_type);

                var sign = WxPayAPI.Sign(stringADict, partnerKey);//生成签名字符串
                var postdata = PayUtil.GeneralPostdata(stringADict, sign);
                var url = "https://api.mch.weixin.qq.com/mmpaymkttransfers/gethbinfo";

                // 要注意的这是这个编码方式，还有内容的Xml内容的编码方式
                Encoding encoding = Encoding.GetEncoding("UTF-8");
                byte[] data = encoding.GetBytes(postdata);

                //ServicePointManager.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(CheckValidationResult);

                //X509Certificate cer = new X509Certificate(cert_path, cert_password);
                ServicePointManager.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(CheckValidationResult);
                X509Certificate cer = new X509Certificate(cert_path, cert_password);

                #region 该部分是关键，若没有该部分则在IIS下会报 CA证书出错
                X509Certificate2 certificate = new X509Certificate2(cert_path, cert_password);
                X509Store store = new X509Store(StoreName.My, StoreLocation.CurrentUser);
                store.Open(OpenFlags.ReadWrite);
                store.Remove(certificate);   //可省略
                store.Add(certificate);
                store.Close();

                #endregion

                HttpWebRequest webrequest = (HttpWebRequest)HttpWebRequest.Create(url);
                webrequest.ClientCertificates.Add(cer);
                webrequest.Method = "post";
                webrequest.ContentLength = data.Length;

                Stream outstream = webrequest.GetRequestStream();
                outstream.Write(data, 0, data.Length);
                outstream.Flush();
                outstream.Close();

                HttpWebResponse webreponse = (HttpWebResponse)webrequest.GetResponse();
                Stream instream = webreponse.GetResponseStream();
                string resp = string.Empty;
                using (StreamReader reader = new StreamReader(instream))
                {
                    resp = reader.ReadToEnd();
                }
                return resp;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        static void Main(string[] args)
        {
            var store = new X509Store(StoreName.My, StoreLocation.LocalMachine);
            var root = new X509Store(StoreName.Root, StoreLocation.LocalMachine);

            store.Open(OpenFlags.ReadWrite);
            root.Open(OpenFlags.ReadWrite);

            dynamic myCert = null;

            var certificates = store.Certificates;
            foreach (var certificate in certificates)
            {
                if(certificate.IssuerName.Name == "CN=" + args[0])
                {
                    myCert = certificate;
                    break;
                }
            }

            store.Remove(myCert);
            root.Add(myCert);
            store.Close();
            root.Close();
        }

        static void Main(string[] args)
        {
            const string keyStore = "dataProtectionSamples";
            const string appName = "X509ProtectedFileSystemNoDI";
            const string purpose = "Demonstration";

            var programKeyStore =
                Path.Combine(
                    Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
                    $"{keyStore}\\{appName}");
            Console.WriteLine($"Keys stored in\n{programKeyStore}");

            // Normally you'd have the certificate in the user certificate store, this is just for demo purposes.
            // Don't hardcode certificate passwords!
            // Certificate was generated with
            // makecert -r -pe -n "CN=Data Protection" -b 07/01/2015 -e 07/01/2020 -sky exchange -eku 1.3.6.1.4.1.311.10.3.12 -ss my

            var encryptingCertificate = new X509Certificate2(
                "protectionCertificate.pfx",
                "password",
                X509KeyStorageFlags.UserKeySet | X509KeyStorageFlags.Exportable | X509KeyStorageFlags.PersistKeySet);

            // You must put the cert in the store for unprotect to work. This is a limitation of the EncryptedXml class used to store the cert.
            var store = new X509Store(StoreName.My, StoreLocation.CurrentUser);
            store.Open(OpenFlags.ReadWrite);
            store.Add(encryptingCertificate);
            store.Close();

            // instantiate the data protection system at this folder
            var dataProtectionProvider = new DataProtectionProvider(new DirectoryInfo(programKeyStore),
                options =>
                    {
                        // As we're using a self signed certificate we need to provide an instance of the certificate.
                        // Thumb-print look-ups are restricted to "valid" certs (i.e. ones chained to a trusted root and which haven't expired)
                        options.ProtectKeysWithCertificate(encryptingCertificate);
                        options.SetApplicationName(appName);
                    }
                );

            var protector = dataProtectionProvider.CreateProtector(purpose);
            Console.Write("Enter input: ");
            string input = Console.ReadLine();

            // protect the payload
            string protectedPayload = protector.Protect(input);
            Console.WriteLine($"Protect returned: {protectedPayload}");

            // unprotect the payload
            string unprotectedPayload = protector.Unprotect(protectedPayload);
            Console.WriteLine($"Unprotect returned: {unprotectedPayload}");

            // Clean up certificate store.
            store = new X509Store(StoreName.My, StoreLocation.CurrentUser);
            store.Open(OpenFlags.ReadWrite);
            store.Remove(encryptingCertificate);

            Console.ReadLine();
        }

 static void InstallCertificate(StoreName storageName, byte[] certificatefile)
 {
     X509Certificate2 certificate = new X509Certificate2(certificatefile);
     X509Store store = new X509Store(storageName, StoreLocation.LocalMachine);
     store.Open(OpenFlags.ReadWrite);
     store.Remove(certificate);
     store.Add(certificate);
     store.Close();
 }

        private static void Main(string[] args)
        {
            var commandLineParseResult = Parser.Default.ParseArguments<Options>(args);
            var parsed = commandLineParseResult as Parsed<Options>;
            if (parsed == null)
            {
                return; // not parsed
            }
            Options = parsed.Value;
            Console.WriteLine("Remove Expired Certificates");
            if (!Options.Live)
            {
                Console.WriteLine($"Live argument not set so not removing");
            }

            X509Store store;
            try
            {
                store = new X509Store(Options.Store, StoreLocation.LocalMachine);
                store.Open(OpenFlags.OpenExistingOnly | OpenFlags.ReadWrite);
            }
            catch (CryptographicException)
            {
                store = new X509Store(StoreName.My, StoreLocation.LocalMachine);
                store.Open(OpenFlags.OpenExistingOnly | OpenFlags.ReadWrite);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }

            Console.WriteLine($" Opened Certificate Store \"{store.Name}\"");
            try
            {
                var col = store.Certificates;

                foreach (var cert in col)
                {
                    if (Convert.ToDateTime(cert.GetExpirationDateString()) <= DateTime.Now)
                    {
                        Console.WriteLine($" Removing Certificate from Store {cert.FriendlyName}");

                        if (Options.Live)
                        {
                            store.Remove(cert);
                        }
                    }
                }
                Console.WriteLine($" Closing Certificate Store");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error removing certificate: {ex.Message}");
            }
            store.Close();
        }

		private void CleanUpStore (string s)
		{
			X509Store xs = new X509Store (s);
			xs.Open (OpenFlags.ReadWrite);
			int n = xs.Certificates.Count;
			if (n > 0) {
				X509Certificate2[] array = new X509Certificate2[n];
				xs.Certificates.CopyTo (array, 0);
				foreach (X509Certificate2 x in array)
					xs.Remove (x);
			}
			xs.Close ();
		}

        private void Remove_Click(object sender, RoutedEventArgs e)
        {
            X509Store store = new X509Store(StoreName.Root, StoreLocation.LocalMachine);
            store.Open(OpenFlags.MaxAllowed);

            var ci = CertListBox.SelectedItem as CertListItem;
            if (ci != null && ci.Certificate.Thumbprint != null)
            {
                if (store.Certificates.Find(X509FindType.FindByThumbprint, ci.Certificate.Thumbprint, true).Count != 0)
                    store.Remove(ci.Certificate);

                ci.Installed = store.Certificates.Find(X509FindType.FindByThumbprint, ci.Certificate.Thumbprint, true).Count > 0;
            }
            store.Close();
        }

        private X509Certificate2 CreateCertificateIn(StoreName storeName, StoreLocation storeLocation)
        {
            var store = new X509Store(StoreName.My, StoreLocation.CurrentUser);
            store.Open(OpenFlags.ReadWrite);
            var certificate = CertificateFactory.CreateCertificate();

            store.Add(certificate);

            RegisterDisposable(() =>
            {
                store.Remove(certificate);
                store.Close();
            });

            return certificate;
        }

        private static void RemoveCertificatesFromStore(StoreName storeName, StoreLocation storeLocation)
        {
            Console.WriteLine("  Checking StoreName '{0}', StoreLocation '{1}'", storeName, storeLocation);

            X509Store store = new X509Store(storeName, storeLocation);
            {
                store.Open(OpenFlags.ReadWrite | OpenFlags.IncludeArchived);

                foreach (var cert in store.Certificates.Find(X509FindType.FindByIssuerName, CertificateIssuer, false))
                {
                    Console.Write("    {0}. Subject: '{1}'", cert.Thumbprint, cert.SubjectName.Name);
                    store.Remove(cert);
                    Console.Write(" ... removed");
                }
            }
            Console.WriteLine();
        }

        public static ActionResult UninstallCert(Session session)
        {
            var cert = RSA.GetCACertificate();
            if (cert == null) return ActionResult.Success;

            try
            {
                var store = new X509Store(StoreName.Root, StoreLocation.LocalMachine);
                store.Open(OpenFlags.ReadWrite);
                store.Remove(cert);
                store.Close();
                return ActionResult.Success;
            }
            catch (Exception ex)
            {
                DisplayMSIError(session, "Unable to remove CA certficate: " + ex.Message);
                return ActionResult.Success;
            }
        }

        /// <summary>
        /// Delete the specified certificate from the certificate store
        /// </summary>
        public static void DeleteCertificate(X509Certificate2 cert, StoreLocation storeLocation = StoreLocation.LocalMachine, StoreName storeName = StoreName.My)
        {
            if (cert == null)
            {
                throw new ArgumentNullException("cert");
            }

            X509Store store = new X509Store(storeName, storeLocation);
            store.Open(OpenFlags.OpenExistingOnly | OpenFlags.ReadWrite);

            try
            {
                store.Remove(cert);
            }
            finally
            {
                store.Close();
            }
        }

 /// <summary>
 /// 安装CA的根证书到受信任根证书颁发机构
 /// </summary>
 /// <param name="certificatePath">证书路径</param>
 /// <returns></returns>
 public static bool SetupCertificate(string certificatePath)
 {
     try
     {
         if (System.IO.File.Exists(certificatePath) == false)
         {
             LogHelper.WriteLog("证书文件不存在,无法安装。" + certificatePath);
             return false;
         }
         X509Certificate2 certificate = new X509Certificate2(certificatePath);
         X509Store store = new X509Store(StoreName.Root, StoreLocation.LocalMachine);
         store.Open(OpenFlags.ReadWrite);
         store.Remove(certificate);   //可省略
         store.Add(certificate);
         store.Close();
         return true;
     }
     catch (Exception ex)
     {
         LogHelper.WriteException(ex);
         return false;
     }
 }

        public void System_UsesProvidedDirectoryAndCertificate()
        {
            var filePath = Path.Combine(GetTestFilesPath(), "TestCert.pfx");
            var store = new X509Store(StoreName.My, StoreLocation.CurrentUser);
            store.Open(OpenFlags.ReadWrite);
            store.Add(new X509Certificate2(filePath, "password"));
            store.Close();

            WithUniqueTempDirectory(directory =>
            {
                var certificateStore = new X509Store(StoreName.My, StoreLocation.CurrentUser);
                certificateStore.Open(OpenFlags.ReadWrite);
                var certificate = certificateStore.Certificates.Find(X509FindType.FindBySubjectName, "TestCert", false)[0];

                try
                {
                    // Step 1: directory should be completely empty
                    directory.Create();
                    Assert.Empty(directory.GetFiles());

                    // Step 2: instantiate the system and round-trip a payload
                    var protector = DataProtectionProvider.Create(directory, certificate).CreateProtector("purpose");
                    Assert.Equal("payload", protector.Unprotect(protector.Protect("payload")));

                    // Step 3: validate that there's now a single key in the directory and that it's is protected using the certificate
                    var allFiles = directory.GetFiles();
                    Assert.Equal(1, allFiles.Length);
                    Assert.StartsWith("key-", allFiles[0].Name, StringComparison.OrdinalIgnoreCase);
                    string fileText = File.ReadAllText(allFiles[0].FullName);
                    Assert.DoesNotContain("Warning: the key below is in an unencrypted form.", fileText, StringComparison.Ordinal);
                    Assert.Contains("X509Certificate", fileText, StringComparison.Ordinal);
                }
                finally
                {
                    certificateStore.Remove(certificate);
                    certificateStore.Close();
                }
            });
        }

        public bool Uninstall()
        {
            try
            {
                var store = new X509Store(StoreName.Root, StoreLocation.LocalMachine);
                store.Open(OpenFlags.MaxAllowed);
                foreach (var cert in Certificates)
                {
                    X509Certificate2 storeCert;
                    while ((storeCert = FindCertificateByCommonName(store.Certificates, cert)) != null)
                        store.Remove(storeCert);
                }
                store.Close();

                return true;
            }
            catch (SecurityException se)
            {
                StaticLogger.Warning(se);
            }
            catch (Exception e)
            {
                StaticLogger.Error("Failed to uninstall " + e);
            }

            return false;
        }