Esempio n. 1
0
        private static string ConfirmedOidValue(IFindPal findPal, object findValue, OidGroup oidGroup)
        {
            string maybeOid = ConfirmedCast <string>(findValue);

            if (maybeOid.Length == 0)
            {
                throw new ArgumentException(SR.Argument_InvalidOidValue);
            }

            return(findPal.NormalizeOid(maybeOid, oidGroup));
        }
Esempio n. 2
0
        public static X509Certificate2Collection FindFromCollection(
            X509Certificate2Collection coll,
            X509FindType findType,
            object findValue,
            bool validOnly)
        {
            X509Certificate2Collection results = new X509Certificate2Collection();

            using (IFindPal findPal = OpenPal(coll, results, validOnly))
            {
                switch (findType)
                {
                case X509FindType.FindByThumbprint:
                {
                    byte[] thumbPrint = ConfirmedCast <string>(findValue).LaxDecodeHexString();
                    findPal.FindByThumbprint(thumbPrint);
                    break;
                }

                case X509FindType.FindBySubjectName:
                {
                    string subjectName = ConfirmedCast <string>(findValue);
                    findPal.FindBySubjectName(subjectName);
                    break;
                }

                case X509FindType.FindBySubjectDistinguishedName:
                {
                    string subjectDistinguishedName = ConfirmedCast <string>(findValue);
                    findPal.FindBySubjectDistinguishedName(subjectDistinguishedName);
                    break;
                }

                case X509FindType.FindByIssuerName:
                {
                    string issuerName = ConfirmedCast <string>(findValue);
                    findPal.FindByIssuerName(issuerName);
                    break;
                }

                case X509FindType.FindByIssuerDistinguishedName:
                {
                    string issuerDistinguishedName = ConfirmedCast <string>(findValue);
                    findPal.FindByIssuerDistinguishedName(issuerDistinguishedName);
                    break;
                }

                case X509FindType.FindBySerialNumber:
                {
                    string decimalOrHexString = ConfirmedCast <string>(findValue);

                    // FindBySerialNumber allows the input format to be either in
                    // hex or decimal. Since we can't know which one was intended,
                    // it compares against both interpretations and treats a match
                    // of either as a successful find.

                    // string is big-endian
                    byte[] hexBytes = decimalOrHexString.LaxDecodeHexString();

                    BigInteger hexValue     = new BigInteger(hexBytes, isUnsigned: true, isBigEndian: true);
                    BigInteger decimalValue = LaxParseDecimalBigInteger(decimalOrHexString);
                    findPal.FindBySerialNumber(hexValue, decimalValue);
                    break;
                }

                case X509FindType.FindByTimeValid:
                {
                    DateTime dateTime = ConfirmedCast <DateTime>(findValue);
                    findPal.FindByTimeValid(dateTime);
                    break;
                }

                case X509FindType.FindByTimeNotYetValid:
                {
                    DateTime dateTime = ConfirmedCast <DateTime>(findValue);
                    findPal.FindByTimeNotYetValid(dateTime);
                    break;
                }

                case X509FindType.FindByTimeExpired:
                {
                    DateTime dateTime = ConfirmedCast <DateTime>(findValue);
                    findPal.FindByTimeExpired(dateTime);
                    break;
                }

                case X509FindType.FindByTemplateName:
                {
                    string expected = ConfirmedCast <string>(findValue);
                    findPal.FindByTemplateName(expected);
                    break;
                }

                case X509FindType.FindByApplicationPolicy:
                {
                    string oidValue = ConfirmedOidValue(findPal, findValue, OidGroup.Policy);
                    findPal.FindByApplicationPolicy(oidValue);
                    break;
                }

                case X509FindType.FindByCertificatePolicy:
                {
                    string oidValue = ConfirmedOidValue(findPal, findValue, OidGroup.Policy);
                    findPal.FindByCertificatePolicy(oidValue);
                    break;
                }

                case X509FindType.FindByExtension:
                {
                    string oidValue = ConfirmedOidValue(findPal, findValue, OidGroup.ExtensionOrAttribute);
                    findPal.FindByExtension(oidValue);
                    break;
                }

                case X509FindType.FindByKeyUsage:
                {
                    X509KeyUsageFlags keyUsage = ConfirmedX509KeyUsage(findValue);
                    findPal.FindByKeyUsage(keyUsage);
                    break;
                }

                case X509FindType.FindBySubjectKeyIdentifier:
                {
                    byte[] keyIdentifier = ConfirmedCast <string>(findValue).LaxDecodeHexString();
                    findPal.FindBySubjectKeyIdentifier(keyIdentifier);
                    break;
                }

                default:
                    throw new CryptographicException(SR.Cryptography_X509_InvalidFindType);
                }
            }

            return(results);
        }