private AttributeCertificate(Asn1Sequence seq)
 {
     if (seq.Count != 3)
     {
         throw new ArgumentException("Bad sequence size: " + seq.Count);
     }
     acinfo             = AttributeCertificateInfo.GetInstance(seq[0]);
     signatureAlgorithm = AlgorithmIdentifier.GetInstance(seq[1]);
     signatureValue     = DerBitString.GetInstance(seq[2]);
 }
    public AttributeCertificateInfo GenerateAttributeCertificateInfo()
    {
        if (serialNumber == null || signature == null || issuer == null || startDate == null || endDate == null || holder == null || attributes == null)
        {
            throw new InvalidOperationException("not all mandatory fields set in V2 AttributeCertificateInfo generator");
        }
        Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector(version, holder, issuer, signature, serialNumber);

        asn1EncodableVector.Add(new AttCertValidityPeriod(startDate, endDate));
        asn1EncodableVector.Add(new DerSequence(attributes));
        if (issuerUniqueID != null)
        {
            asn1EncodableVector.Add(issuerUniqueID);
        }
        if (extensions != null)
        {
            asn1EncodableVector.Add(extensions);
        }
        return(AttributeCertificateInfo.GetInstance(new DerSequence(asn1EncodableVector)));
    }
示例#3
0
        public void CheckAttributeCertificate(
            int id,
            byte[]  cert)
        {
            Asn1Sequence seq  = (Asn1Sequence)Asn1Object.FromByteArray(cert);
            string       dump = Asn1Dump.DumpAsString(seq);

            AttributeCertificate     obj    = AttributeCertificate.GetInstance(seq);
            AttributeCertificateInfo acInfo = obj.ACInfo;

            // Version
            if (!(acInfo.Version.Equals(new DerInteger(1))) &&
                (!(acInfo.Version.Equals(new DerInteger(2)))))
            {
                Fail("failed AC Version test for id " + id);
            }

            // Holder
            Holder h = acInfo.Holder;

            if (h == null)
            {
                Fail("failed AC Holder test, it's null, for id " + id);
            }

            // Issuer
            AttCertIssuer aci = acInfo.Issuer;

            if (aci == null)
            {
                Fail("failed AC Issuer test, it's null, for id " + id);
            }

            // Signature
            AlgorithmIdentifier sig = acInfo.Signature;

            if (sig == null)
            {
                Fail("failed AC Signature test for id " + id);
            }

            // Serial
            DerInteger serial = acInfo.SerialNumber;

            // Validity
            AttCertValidityPeriod validity = acInfo.AttrCertValidityPeriod;

            if (validity == null)
            {
                Fail("failed AC AttCertValidityPeriod test for id " + id);
            }

            // Attributes
            Asn1Sequence attribSeq = acInfo.Attributes;

            AttributeX509[] att = new AttributeX509[attribSeq.Count];
            for (int i = 0; i < attribSeq.Count; i++)
            {
                att[i] = AttributeX509.GetInstance(attribSeq[i]);
            }

            // IssuerUniqueId
            // TODO, how to best test?

            // X509 Extensions
            X509Extensions ext = acInfo.Extensions;

            if (ext != null)
            {
                foreach (DerObjectIdentifier oid in ext.ExtensionOids)
                {
                    X509Extension extVal = ext.GetExtension(oid);
                }
            }
        }
 public AttributeCertificate(AttributeCertificateInfo acinfo, AlgorithmIdentifier signatureAlgorithm, DerBitString signatureValue)
 {
     this.acinfo             = acinfo;
     this.signatureAlgorithm = signatureAlgorithm;
     this.signatureValue     = signatureValue;
 }