コード例 #1
0
        public static void CreateCertificate(string ip)
        {
            try
            {
                var cr = new CertificateRequest(new X500DistinguishedName("cn=ispy-local"), RSA.Create(), HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);
                SubjectAlternativeNameBuilder subjectAlternativeNameBuilder = new SubjectAlternativeNameBuilder();
                subjectAlternativeNameBuilder.AddIpAddress(IPAddress.Parse(ip));
                var locals = MainForm.AddressListIPv4;
                foreach (var lip in locals)
                {
                    subjectAlternativeNameBuilder.AddIpAddress(lip);
                }

                cr.CertificateExtensions.Add(subjectAlternativeNameBuilder.Build());
                string    pw    = "123abc!!D";
                var       cert  = cr.CreateSelfSigned(DateTime.UtcNow.AddDays(-1), DateTime.UtcNow.AddYears(+1));
                var       cert2 = new X509Certificate2(cert.Export(X509ContentType.Pfx, pw), pw);
                X509Store store = new X509Store(StoreName.Root, StoreLocation.LocalMachine);
                store.Open(OpenFlags.ReadWrite);

                X509Certificate2Collection col = store.Certificates.Find(X509FindType.FindBySubjectName, "ispy-local", false);
                if (col.Count > 0)
                {
                    store.RemoveRange(col);
                }

                store.Add(cert2);
                store.Close();
                _sslCertificate = cert2;
            }
            catch (Exception ex)
            {
                Logger.LogException(ex, "X509 Create");
            }
        }
コード例 #2
0
        protected virtual bool DestroyCertificate(X509Store store, string certificateName)
        {
            lock (store)
            {
                X509Certificate2Collection certificates = null;
                try
                {
                    store.Open(OpenFlags.ReadWrite);
                    string certificateSubject = string.Format("CN={0}, O={1}", certificateName, Issuer);

                    certificates = FindCertificates(store, certificateSubject);
                    if (certificates != null)
                    {
                        store.RemoveRange(certificates);
                        certificates = FindCertificates(store, certificateSubject);
                    }
                    return(certificates == null);
                }
                finally
                {
                    store.Close();
                    if (certificates == null &&
                        _certificateCache.ContainsKey(certificateName))
                    {
                        _certificateCache.Remove(certificateName);
                    }
                }
            }
        }
コード例 #3
0
 public bool ClearCertificateCache(bool bClearRoot)
 {
     _rwl.AcquireWriterLock(LOCK_TIMEOUT);
     _certificateCache.Clear();
     if (bClearRoot)
     {
         _root = null;
         var store = new X509Store(StoreName.Root, StoreLocation.CurrentUser);
         try
         {
             store.Open(OpenFlags.OpenExistingOnly | OpenFlags.ReadWrite);
             var roots = store.Certificates.Find(X509FindType.FindBySubjectDistinguishedName, FIDDLER_ROOT_DN, true);
             store.RemoveRange(roots);
         }
         catch
         {
             return(false);
         }
         finally
         {
             store.Close();
         }
     }
     _rwl.ReleaseWriterLock();
     return(true);
 }
コード例 #4
0
        /// <summary>
        /// Removes a certificate from the store. Cleanup purposes.
        /// </summary>
        /// <param name="certificateName"></param>
        /// <param name="certificateStoreLocation"></param>
        /// <returns></returns>
        internal static void RemoveCertificate(string certificateName, StoreLocation certificateStoreLocation)
        {
            Assert.False(string.IsNullOrWhiteSpace(certificateName), "FAILED: certificateName should not be null or empty.");

            X509Store certStore = null;

            try
            {
                certStore = new X509Store(StoreName.My, certificateStoreLocation);
                certStore.Open(OpenFlags.ReadWrite);
                X509Certificate2Collection certificateCollection = certStore.Certificates.Find(X509FindType.FindBySubjectName, certificateName, validOnly: false);

                if (certificateCollection != null && certificateCollection.Count > 0)
                {
                    certStore.RemoveRange(certificateCollection);
                }
            }
            finally
            {
                if (certStore != null)
                {
                    certStore.Close();
                }
            }
        }
コード例 #5
0
        private static void RemoveExpiredAndDuplicateCertificates(X509Store store)
        {
            var certs    = GetDomainCertificates(store);
            var toRemove = new X509Certificate2Collection();

            foreach (var cert in certs)
            {
                if (cert.NotAfter <= DateTime.Now)
                {
                    Console.WriteLine("The certificate has expired, removing it from store");
                    toRemove.Add(cert);
                }
            }
            foreach (var cert in certs)
            {
                if (certs.Count - toRemove.Count == 1)
                {
                    break;
                }
                if (toRemove.Contains(cert))
                {
                    continue;
                }
                Console.WriteLine("The certificate is a duplicate, removing it from store");
                toRemove.Add(cert);
            }
            store.RemoveRange(toRemove);
        }
        /// <summary>
        /// Remove certificate by name from Local User Certificate Store
        /// </summary>
        /// <param name="certificateName">The name of the certificate to remove.</param>
        /// <returns>Object { bool Success, CryptographicException Error }</returns>
        public static LocalStoreResult RemoveFromLocalUser(string certificateName)
        {
            using (X509Store store = new X509Store(StoreName.My, StoreLocation.CurrentUser))
            {
                store.Open(OpenFlags.ReadWrite);
                X509Certificate2Collection certificatesToDelete = store.Certificates.Find(X509FindType.FindBySubjectName, certificateName, false);
                if (certificatesToDelete.Count != 0)
                {
                    X509Chain ch = new X509Chain();
                    ch.Build(certificatesToDelete[0]);
                    X509Certificate2Collection allCertsInChain = new X509Certificate2Collection();

                    foreach (X509ChainElement el in ch.ChainElements)
                    {
                        allCertsInChain.Add(el.Certificate);
                    }

                    store.RemoveRange(allCertsInChain);
                }
            }

            return(new LocalStoreResult
            {
                Success = true
            });
        }
コード例 #7
0
        public bool DestroyCertificates(X509Store store)
        {
            lock (store)
            {
                try
                {
                    store.Open(OpenFlags.ReadWrite);
                    X509Certificate2Collection certificates = store.Certificates.Find(X509FindType.FindByIssuerName, Issuer, false);

                    store.RemoveRange(certificates);
                    IEnumerable <string> subjectNames = certificates
                                                        .Cast <X509Certificate2>().Select(c => c.GetNameInfo(X509NameType.SimpleName, false));

                    foreach (string subjectName in subjectNames)
                    {
                        if (!_certificateCache.ContainsKey(subjectName))
                        {
                            continue;
                        }
                        _certificateCache.Remove(subjectName);
                    }
                    return(true);
                }
                catch { return(false); }
                finally { store.Close(); }
            }
        }
コード例 #8
0
        public static void RemoveCertificate(string serial, StoreName storeName = StoreName.My, StoreLocation storeLocation = StoreLocation.CurrentUser)
        {
            if (String.IsNullOrEmpty(serial))
            {
                throw new ArgumentNullException("serial");
            }
            X509Store store = null;

            try
            {
                store = new X509Store(storeName, storeLocation);
                store.Open(OpenFlags.ReadWrite);
                var existings = store.Certificates.Find(X509FindType.FindBySerialNumber, serial, false);
                if (existings.Count == 0)
                {
                    return;
                }
                store.RemoveRange(existings);
            }
            finally
            {
                if (store != null)
                {
                    store.Close();
                }
            }
        }
コード例 #9
0
        public void AddOrReplaceToStore(X509Certificate2 certificate, AppCertificates id_store)
        {
            X509Store store = new X509Store("AutoBetCertificates", StoreLocation.CurrentUser);

            store.Open(OpenFlags.ReadWrite);
            store.RemoveRange(store.Certificates.Find(X509FindType.FindByApplicationPolicy, certificate.FriendlyName, false));
            store.Add(certificate);
        }
コード例 #10
0
ファイル: X509StoreTest.cs プロジェクト: pmq20/mono_forked
        public void RemoveRange_OpenReadOnly_Unexisting()
        {
            X509Store xs = new X509Store("ReadOnlyStore");

            xs.Open(OpenFlags.ReadOnly);
            // note: cert1 wasn't present, RemoveRange "succeed"
            xs.RemoveRange(coll);
        }
コード例 #11
0
 public void Dispose()
 {
     using (var store = new X509Store(StoreName.My, StoreLocation.CurrentUser, OpenFlags.ReadWrite))
     {
         var certs = store.Certificates.Find(X509FindType.FindByThumbprint, TestCertificateValues.Thumbprint, false);
         store.RemoveRange(certs);
         store.Close();
     }
 }
コード例 #12
0
 private static void CleanupCertificates()
 {
     using (var store = new X509Store(StoreName.My, StoreLocation.CurrentUser))
     {
         store.Open(OpenFlags.ReadWrite);
         store.RemoveRange(store.Certificates.Find(X509FindType.FindBySubjectName, "CN=SigningKeysLoaderTest", validOnly: false));
         store.Close();
     }
 }
コード例 #13
0
ファイル: CertUtil.cs プロジェクト: Guerra24/LRReader
        public static bool UninstallCertificate(string thumb)
        {
            var col = Store.Certificates.Find(X509FindType.FindByThumbprint, thumb.ToUpper(), false);

            if (col != null && col.Count > 0)
            {
                Store.RemoveRange(col);
            }
            return(true);
        }
コード例 #14
0
ファイル: X509StoreTest.cs プロジェクト: pmq20/mono_forked
        public void RemoveRange_Empty_Certificate()
        {
            X509Store xs = new X509Store("ReadWriteStore");

            xs.Open(OpenFlags.ReadWrite);
            // note: impossible to add cert_empty, so we add something else
            // to be sure we'll follow the complete code path (loop) of removal
            xs.AddRange(coll);
            xs.RemoveRange(new X509Certificate2Collection(cert_empty));
        }
コード例 #15
0
ファイル: X509StoreTest.cs プロジェクト: pmq20/mono_forked
        public void RemoveRange_OpenReadOnly_Existing()
        {
            X509Store xs = new X509Store("ReadWriteStore");

            xs.Open(OpenFlags.ReadWrite);
            xs.AddRange(coll);
            xs.Close();
            xs.Open(OpenFlags.ReadOnly);
            xs.RemoveRange(coll);
        }
コード例 #16
0
        private static void Main(string[] args)
        {
            Task.Run(async() =>
            {
                Console.WriteLine("Enter PIN: ");
                string pin = Console.ReadLine();

                WebRequestHandler handler = new WebRequestHandler();
                handler.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(ValidateServerCertificate);

                using (HttpClient client = new HttpClient(handler, true))
                {
                    client.BaseAddress = new Uri(string.Format(@"https://{0}:{1}", MachineName, RemotePort));

                    X509Store store = null;

                    try
                    {
                        var response = await client.GetAsync("certs/" + pin);
                        response.EnsureSuccessStatusCode();

                        byte[] rawCert = await response.Content.ReadAsByteArrayAsync();

                        X509Certificate2Collection certs = new X509Certificate2Collection();
                        certs.Import(rawCert, "", X509KeyStorageFlags.Exportable | X509KeyStorageFlags.PersistKeySet | X509KeyStorageFlags.UserKeySet);

                        store = new X509Store(StoreName.My, StoreLocation.CurrentUser);
                        store.Open(OpenFlags.ReadWrite);

                        X509Certificate2Collection oldCerts = new X509Certificate2Collection();

                        foreach (var cert in certs)
                        {
                            oldCerts.AddRange(store.Certificates.Find(X509FindType.FindBySubjectDistinguishedName, cert.Subject, false));
                        }
                        store.RemoveRange(certs);
                        store.AddRange(certs);
                        store.Close();

                        Console.WriteLine("Success");
                    }
                    catch (HttpRequestException e)
                    {
                        Console.WriteLine("Error communicating with vcremote. Make sure that vcremote is running in secure mode and that a new client cert has been generated.");
                    }
                    finally
                    {
                        if (store != null)
                        {
                            store.Close();
                        }
                    }
                }
            }).Wait();
        }
コード例 #17
0
        static void Main(string[] args)
        {
            if (args.Length != 4)
            {
                Console.WriteLine("Requires <Cert StoreName> <pfxfile> <friendlyname> and <password> arguments");
                return;
            }
            string certStoreName = args[0];
            string pfxFile       = args[1];
            string friendlyName  = args[2];
            string password      = args[3];

            X509Store store = new X509Store(certStoreName, StoreLocation.LocalMachine);

            store.Open(OpenFlags.ReadWrite);


            var newCert = new X509Certificate2(pfxFile, password, X509KeyStorageFlags.Exportable | X509KeyStorageFlags.PersistKeySet | X509KeyStorageFlags.MachineKeySet);

            newCert.FriendlyName = friendlyName;
            store.Add(newCert);


            if (File.Exists("previousHash.txt") && File.Exists("previousHash.bin"))
            {
                var oldHashText = File.ReadAllText("previousHash.txt").Trim();
                if (oldHashText == newCert.GetCertHashString())
                {
                    return;
                }
                var oldCert = store.Certificates.Find(X509FindType.FindByThumbprint, oldHashText, false);

                ServerManager mgr = new ServerManager();
                foreach (Site s in mgr.Sites)
                {
                    Console.WriteLine(s.Name);
                    foreach (var b in s.Bindings.Where(x => x.Protocol == "https" && x.CertificateHash.SequenceEqual(File.ReadAllBytes("previousHash.bin"))))
                    {
                        b.CertificateHash      = newCert.GetCertHash();
                        b.CertificateStoreName = certStoreName;
                        b.SetAttributeValue("certificateStoreName", certStoreName);
                        b.SetAttributeValue("certificateHash", newCert.GetCertHashString());
                    }
                }
                mgr.CommitChanges();
                store.RemoveRange(oldCert);
                store.Close();
                store.Dispose();
            }


            File.WriteAllBytes("previousHash.bin", newCert.GetCertHash());
            File.WriteAllText("previousHash.txt", newCert.GetCertHashString());
        }
コード例 #18
0
        public void RemoveRange_Certificate_OK()
        {
            X509Store xs = new X509Store("ReadWriteStore");

            xs.Open(OpenFlags.ReadWrite);
            xs.AddRange(coll);
            int countBeforeRemove = xs.Certificates.Count;

            xs.RemoveRange(coll);
            Assert.AreEqual(countBeforeRemove - coll.Count, xs.Certificates.Count);
        }
コード例 #19
0
	static void RemoveCertificatesFromStore(string cert , string password , StoreLocation loc)
		{
		//Import the pfx certificates
		X509Certificate2Collection certificates = new X509Certificate2Collection() ; 
		certificates.Import( cert , password , X509KeyStorageFlags.Exportable | X509KeyStorageFlags.PersistKeySet);
		
		//Add the Certificate
		X509Store store = new X509Store( storeName , loc) ; // , "Cool Store" ) ; 
		store.Open( OpenFlags.ReadWrite ) ;
		store.RemoveRange( certificates ) ; 			
		store.Close() ; 
		}
コード例 #20
0
        private static void DeleteOldCertificatesIfFound(X509Store store, X509Certificate2 newCertificate)
        {
            var subject = newCertificate.GetNameInfo(X509NameType.SimpleName, false);

            if (subject == null)
            {
                return;
            }

            var certificateCollection = store.Certificates.Find(X509FindType.FindBySubjectName, subject, false);

            store.RemoveRange(certificateCollection);
        }
コード例 #21
0
        /// <summary>
        /// Remove the KAZ certs
        /// </summary>
        private void RemoveKAZrootCerts()
        {
            var store = new X509Store(StoreName.Root, StoreLocation.CurrentUser);

            store.Open(OpenFlags.ReadWrite);

            foreach (string sThumb in _sCertThumb)
            {
                X509Certificate2Collection col = store.Certificates.Find(X509FindType.FindByThumbprint, sThumb, false);

                X509Chain ch = new X509Chain();

                if (col.Count > 0)
                {
                    ch.Build(col[0]);
                    X509Certificate2Collection allCertsInChain = new X509Certificate2Collection();

                    foreach (X509ChainElement el in ch.ChainElements)
                    {
                        allCertsInChain.Add(el.Certificate);
                    }
                    store.RemoveRange(allCertsInChain);
                }
            }
            store.Close();

            store = new X509Store(StoreName.CertificateAuthority, StoreLocation.CurrentUser);
            store.Open(OpenFlags.ReadWrite);

            foreach (string sThumb in _sCertThumb)
            {
                X509Certificate2Collection col = store.Certificates.Find(X509FindType.FindByThumbprint, sThumb, false);

                X509Chain ch = new X509Chain();

                if (col.Count > 0)
                {
                    ch.Build(col[0]);
                    X509Certificate2Collection allCertsInChain = new X509Certificate2Collection();

                    foreach (X509ChainElement el in ch.ChainElements)
                    {
                        allCertsInChain.Add(el.Certificate);
                    }
                    store.RemoveRange(allCertsInChain);
                }
            }
            store.Close();

            DetectCerts(false);
        }
コード例 #22
0
ファイル: storebug.cs プロジェクト: leeholder/Netduino_SDK
    static void RemoveCertificatesFromStore(string cert, string password, StoreLocation loc)
    {
        //Import the pfx certificates
        X509Certificate2Collection certificates = new X509Certificate2Collection();

        certificates.Import(cert, password, X509KeyStorageFlags.Exportable | X509KeyStorageFlags.PersistKeySet);

        //Add the Certificate
        X509Store store = new X509Store(storeName, loc);            // , "Cool Store" ) ;

        store.Open(OpenFlags.ReadWrite);
        store.RemoveRange(certificates);
        store.Close();
    }
コード例 #23
0
ファイル: TestUtil.cs プロジェクト: Grinderofl/ksi-net-sdk
        public static X509Store CreateCertStore(params string[] certPaths)
        {
            X509Store store = new X509Store("test", StoreLocation.CurrentUser);

            store.Open(OpenFlags.ReadWrite);
            store.RemoveRange(store.Certificates);

            foreach (string certPath in certPaths)
            {
                X509Certificate2 certificate = new X509Certificate2(Path.Combine(TestSetup.LocalPath, certPath));
                store.Add(certificate);
            }
            return(store);
        }
コード例 #24
0
        void RemoveAll(StoreName storeName)
        {
            X509Store store = null;

            try
            {
                store = new X509Store(storeName, MachineContext ? StoreLocation.LocalMachine : StoreLocation.CurrentUser);
                store.Open(OpenFlags.ReadWrite);
                var crtToDelete = store.Certificates.OfType <X509Certificate2>().Where(crt => thumbprints.Contains(crt.Thumbprint)).ToArray();
                store.RemoveRange(new X509Certificate2Collection(crtToDelete));
                RemovedCertificates += crtToDelete.Length;
                store.Close();
            }
            finally
            {
                store?.Close();
            }
        }
コード例 #25
0
 internal static void removeFiddlerGeneratedCerts()
 {
     if (oCertProvider != null)
     {
         oCertProvider.ClearCertificateCache();
     }
     else
     {
         lock (oRootCertCreationLock)
         {
             string sFullSubject = string.Format("CN={0}{1}", CONFIG.sMakeCertRootCN, CONFIG.sMakeCertSubjectO);
             X509Certificate2Collection certificates = FindCertsBySubject(StoreName.Root, StoreLocation.CurrentUser, sFullSubject);
             if (certificates.Count > 0)
             {
                 X509Store store = new X509Store(StoreName.Root, StoreLocation.CurrentUser);
                 store.Open(OpenFlags.OpenExistingOnly | OpenFlags.ReadWrite);
                 try
                 {
                     store.RemoveRange(certificates);
                 }
                 catch
                 {
                 }
                 store.Close();
             }
             certificates = FindCertsByIssuer(StoreName.My, sFullSubject);
             if (certificates.Count > 0)
             {
                 X509Store store2 = new X509Store(StoreName.My, StoreLocation.CurrentUser);
                 store2.Open(OpenFlags.OpenExistingOnly | OpenFlags.ReadWrite);
                 try
                 {
                     store2.RemoveRange(certificates);
                 }
                 catch
                 {
                 }
                 store2.Close();
             }
         }
     }
 }
コード例 #26
0
        private static void RemoveCertificate(string thumbprint, StoreName storeName, StoreLocation storeLocation)
        {
            var store = new X509Store(storeName, storeLocation);

            store.Open(OpenFlags.ReadWrite);

            Console.WriteLine($"Removing certificate '{thumbprint}' from store.");

            var certificates = store.Certificates.Find(X509FindType.FindByThumbprint, thumbprint, false);

            if (certificates.Count > 0)
            {
                throw new ArgumentNullException($"Unable to find certificate '{thumbprint}' from store.");
            }

            store.RemoveRange(certificates);
            Console.WriteLine("Done.");

            store.Close();
        }
コード例 #27
0
ファイル: Certificate.cs プロジェクト: jeason0813/Plato.NET
        /// <summary>
        /// Removes the cert.
        /// </summary>
        /// <param name="storeName">Name of the store.</param>
        /// <param name="storeLoc">The store loc.</param>
        /// <param name="fType">Type of the f.</param>
        /// <param name="findValue">The find value.</param>
        public static void RemoveCert(string storeName, StoreLocation storeLoc, X509FindType fType, object findValue)
        {
            var loc = new X509Store(storeName, storeLoc);

            loc.Open(OpenFlags.ReadWrite | OpenFlags.IncludeArchived | OpenFlags.OpenExistingOnly);
            try
            {
                var col = loc.Certificates.Find(fType, findValue, false);
                if (col == null || col.Count == 0)
                {
                    return;
                }

                loc.RemoveRange(col);
            }
            finally
            {
                loc.Close();
            }
        }
コード例 #28
0
        private static void UninstallAllCertificatesByIssuer(StoreName storeName,
                                                             StoreLocation storeLocation,
                                                             Dictionary <string, CertificateCacheEntry> cache,
                                                             string issuerDistinguishedName)
        {
            lock (s_certificateLock)
            {
                X509Store store = null;

                try
                {
                    // We assume Bridge is running elevated
                    store = new X509Store(storeName, storeLocation);
                    store.Open(OpenFlags.ReadWrite);

                    var collection = store.Certificates.Find(X509FindType.FindByIssuerDistinguishedName, issuerDistinguishedName, false);

                    Trace.WriteLine(string.Format("[CertificateManager] Forcibly removing {0} certificates from store where:", collection.Count));
                    Trace.WriteLine(string.Format("    {0} = {1}", "StoreName", storeName));
                    Trace.WriteLine(string.Format("    {0} = {1}", "StoreLocation", storeLocation));
                    Trace.WriteLine(string.Format("    {0} = {1}", "IssuedBy", issuerDistinguishedName));

                    foreach (var cert in collection)
                    {
                        Trace.WriteLine(string.Format("        {0} = {1}", "CN", cert.SubjectName.Name));
                        Trace.WriteLine(string.Format("        {0} = {1}", "Thumbpint", cert.Thumbprint));
                    }

                    store.RemoveRange(collection);
                }
                finally
                {
                    cache.Clear();

                    if (store != null)
                    {
                        store.Close();
                    }
                }
            }
        }
コード例 #29
0
        /// <summary>
        /// Delete certs that match the provided issuer.  Used for cleaning up test certs.
        /// </summary>
        /// <param name="matcher"></param>
        internal static void DeleteCertsByIssuer(string issuerName)
        {
            X509Store store = new X509Store(StoreName.CertificateAuthority, StoreLocation.LocalMachine);

            store.Open(OpenFlags.ReadWrite);

            // Get a collection of our certs.
            var toRemove = new X509Certificate2Collection();

            foreach (var c in store.Certificates)
            {
                var issuer = c.IssuerName.Name;
                if (issuer.Contains(issuerName))
                {
                    toRemove.Add(c);
                }
            }

            store.RemoveRange(toRemove);
            store.Close();
        }
コード例 #30
0
ファイル: CryptoModule.cs プロジェクト: SosnoV/PKRYLast
        public bool DeleteCerts(string subjectName,
                                StoreName name         = StoreName.My,
                                StoreLocation location = StoreLocation.CurrentUser)
        {
            bool      isCompleted = false;
            X509Store store       = new X509Store(name, location);

            try
            {
                store.Open(OpenFlags.ReadWrite);
                X509Certificate2Collection certsToRemove = store.Certificates.Find(X509FindType.FindBySubjectName, subjectName, false);
                if (certsToRemove != null && certsToRemove.Count > 0)
                {
                    store.RemoveRange(certsToRemove);
                    isCompleted = true;
                }
            }
            catch (Exception e) { Console.WriteLine(e.Message); }
            finally { store.Close(); }

            return(isCompleted);
        }
コード例 #31
0
        public bool ClearCertificateCache(bool bRemoveRoot)
        {
            bool flag = true;

            try
            {
                X509Certificate2Collection certificates;
                this.oRWLock.AcquireWriterLock(-1);
                this.certServerCache.Clear();
                this.certRoot = null;
                string sFullSubject = string.Format("CN={0}{1}", sMakeCertRootCN, sMakeCertSubjectO);
                if (bRemoveRoot)
                {
                    certificates = FindCertsBySubject(StoreName.Root, StoreLocation.CurrentUser, sFullSubject);
                    if (certificates.Count > 0)
                    {
                        X509Store store = new X509Store(StoreName.Root, StoreLocation.CurrentUser);
                        store.Open(OpenFlags.OpenExistingOnly | OpenFlags.ReadWrite);
                        try
                        {
                            store.RemoveRange(certificates);
                        }
                        catch
                        {
                            flag = false;
                        }
                        store.Close();
                    }
                }
                certificates = FindCertsByIssuer(StoreName.My, sFullSubject);
                if (certificates.Count <= 0)
                {
                    return(flag);
                }
                if (!bRemoveRoot)
                {
                    X509Certificate2 rootCertificate = this.GetRootCertificate();
                    if (rootCertificate != null)
                    {
                        certificates.Remove(rootCertificate);
                        if (certificates.Count < 1)
                        {
                            return(true);
                        }
                    }
                }
                X509Store store2 = new X509Store(StoreName.My, StoreLocation.CurrentUser);
                store2.Open(OpenFlags.OpenExistingOnly | OpenFlags.ReadWrite);
                try
                {
                    store2.RemoveRange(certificates);
                }
                catch
                {
                    flag = false;
                }
                store2.Close();
            }
            finally
            {
                this.oRWLock.ReleaseWriterLock();
            }
            return(flag);
        }