// methods

		public int Add (AsnEncodedData asnEncodedData)
		{
			if (asnEncodedData == null)
				throw new ArgumentNullException ("asnEncodedData");

			return _list.Add (asnEncodedData);
		}
		private void CommonStuff (CryptographicAttributeObjectCollection coll)
		{
			Assert.IsFalse (coll.IsSynchronized, "IsSynchronized");
			Assert.AreSame (coll, coll.SyncRoot, "SyncRoot");
			Assert.IsNotNull (coll.GetEnumerator (), "GetEnumerator");

			int i = coll.Count;
			Oid o1 = new Oid ("1.2.840.113549.1.7.3");
			AsnEncodedData aed = new AsnEncodedData (o1, new byte[] { 0x05, 0x00 });
			Assert.AreEqual (i, coll.Add (aed), "Add(AsnEncodedData)");
			Assert.IsTrue ((coll[i++] is CryptographicAttributeObject), "converted");

			Oid o2 = new Oid ("1.2.840.113549.1.7.2");
			CryptographicAttributeObject cao = new CryptographicAttributeObject (o2);
			Assert.AreEqual (i, coll.Add (cao), "Add(CryptographicAttributeObject)");

			CryptographicAttributeObject[] array = new CryptographicAttributeObject [coll.Count];
			coll.CopyTo (array, 0);

			Array a = (Array) new object [coll.Count];
			ICollection c = (ICollection) coll;
			c.CopyTo (a, 0);

			IEnumerable e = (IEnumerable) coll;
			Assert.IsNotNull (e.GetEnumerator (), "GetEnumerator");

			coll.Remove (cao);
			Assert.AreEqual (i, coll.Count, "Remove(CryptographicAttributeObject)");
		}
		public void CopyFrom ()
		{
			byte[] data = { 0x04, 0x10, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F };
			AsnEncodedData aed = new AsnEncodedData (data);
			Pkcs9MessageDigest md = new Pkcs9MessageDigest ();
			md.CopyFrom (aed);
		}
        public int Add(AsnEncodedData asnEncodedData)
        {
            if (asnEncodedData == null)
                throw new ArgumentNullException(nameof(asnEncodedData));

            return Add(new CryptographicAttributeObject(asnEncodedData.Oid, new AsnEncodedDataCollection(asnEncodedData)));
        }
		public void CopyFrom_BadData ()
		{
			byte[] data = { 0x30, 0x18, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x09, 0x03, 0x30, 0x0B, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x07, 0x01 };
			AsnEncodedData aed = new AsnEncodedData (data);
			Pkcs9MessageDigest md = new Pkcs9MessageDigest ();
			md.CopyFrom (aed);
		}
 protected X509SubjectAltNameExtension GetAltNameExtensionFromCSRInfo(Org.BouncyCastle.Asn1.Pkcs.CertificationRequestInfo info)
 {
     try
     {
         for (int i = 0; i < info.Attributes.Count; i++)
         {
             var sequence = Org.BouncyCastle.Asn1.Asn1Sequence.GetInstance(info.Attributes[i].ToAsn1Object());
             var oid      = Org.BouncyCastle.Asn1.DerObjectIdentifier.GetInstance(sequence[0].ToAsn1Object());
             if (oid.Equals(Org.BouncyCastle.Asn1.Pkcs.PkcsObjectIdentifiers.Pkcs9AtExtensionRequest))
             {
                 var extensionInstance = Org.BouncyCastle.Asn1.DerSet.GetInstance(sequence[1]);
                 var extensionSequence = Org.BouncyCastle.Asn1.Asn1Sequence.GetInstance(extensionInstance[0]);
                 var extensions        = Org.BouncyCastle.Asn1.X509.X509Extensions.GetInstance(extensionSequence);
                 Org.BouncyCastle.Asn1.X509.X509Extension extension = extensions.GetExtension(Org.BouncyCastle.Asn1.X509.X509Extensions.SubjectAlternativeName);
                 var asnEncodedAltNameExtension = new System.Security.Cryptography.AsnEncodedData(Org.BouncyCastle.Asn1.X509.X509Extensions.SubjectAlternativeName.ToString(), extension.Value.GetOctets());
                 var altNameExtension           = new X509SubjectAltNameExtension(asnEncodedAltNameExtension, extension.IsCritical);
                 return(altNameExtension);
             }
         }
     }
     catch
     {
         throw new ServiceResultException(StatusCodes.BadInvalidArgument, "CSR altNameExtension invalid.");
     }
     return(null);
 }
Exemple #7
0
 public override void CopyFrom (AsnEncodedData asnEncodedData) {
     if (asnEncodedData == null)
         throw new ArgumentNullException("asnEncodedData");
     Pkcs9AttributeObject att = asnEncodedData as Pkcs9AttributeObject;
     if (att == null)
         throw new ArgumentException(SecurityResources.GetResourceString("Cryptography_Pkcs9_AttributeMismatch"));
     base.CopyFrom(asnEncodedData);
 }
 public virtual void CopyFrom(AsnEncodedData asnEncodedData)
 {
     if (asnEncodedData == null)
     {
         throw new ArgumentNullException("asnEncodedData");
     }
     this.Reset(asnEncodedData.m_oid, asnEncodedData.m_rawData);
 }
		public void CopyFrom ()
		{
			/* byte[] data = ASN1Convert.FromOid ("1.2.840.113549.1.7.1").GetBytes (); */
			byte[] data = { 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x07, 0x01 };
			AsnEncodedData aed = new AsnEncodedData (data);
			Pkcs9ContentType ct = new Pkcs9ContentType ();
			ct.CopyFrom (aed);
		}
Exemple #10
0
		public void LinkDemand_Deny_Unrestricted ()
		{
			Type[] types = new Type[2] { typeof (AsnEncodedData), typeof (bool) };
			ConstructorInfo ci = typeof (X509Extension).GetConstructor (types);
			Assert.IsNotNull (ci, ".ctor(AsnEncodedData,bool)");
			AsnEncodedData aed = new AsnEncodedData (new Oid ("2.5.29.37"), new byte[] { 0x30, 0x05, 0x06, 0x03, 0x2A, 0x03, 0x04 });
			Assert.IsNotNull (ci.Invoke (new object [2] { aed, false }), "invoke");
		}
		public void ConstructorAsnEncodedData_BadAsn ()
		{
			AsnEncodedData aed = new AsnEncodedData ("1.2.3", new byte[0]);
			X509SubjectKeyIdentifierExtension ski = new X509SubjectKeyIdentifierExtension (aed, true);
			Assert.AreEqual (String.Empty, ski.Format (true), "Format(true)");
			Assert.AreEqual (String.Empty, ski.Format (false), "Format(false)");
			string s = ski.SubjectKeyIdentifier;
		}
 public int Add(AsnEncodedData asnEncodedData)
 {
     if (asnEncodedData == null)
     {
         throw new ArgumentNullException("asnEncodedData");
     }
     return this.Add(new CryptographicAttributeObject(asnEncodedData));
 }
 public static void Pkcs9AttributeCopyFromAsnNotAPkcs9Attribute()
 {
     // Pkcs9AttributeObject.CopyFrom(AsnEncodedData) refuses to accept any AsnEncodedData that isn't a Pkcs9AttributeObject-derived class. 
     Pkcs9AttributeObject p = new Pkcs9AttributeObject();
     byte[] rawData = "041e4d00790020004400650073006300720069007000740069006f006e000000".HexToByteArray();
     AsnEncodedData a = new AsnEncodedData(Oids.DocumentName, rawData);
     Assert.Throws<ArgumentException>(() => p.CopyFrom(a));
 }
		public void ConstructorAsnEncodedData_BadAsn ()
		{
			AsnEncodedData aed = new AsnEncodedData ("1.2.3", new byte[0]);
			X509KeyUsageExtension ku = new X509KeyUsageExtension (aed, true);
			Assert.AreEqual (String.Empty, ku.Format (true), "Format(true)");
			Assert.AreEqual (String.Empty, ku.Format (false), "Format(false)");
			X509KeyUsageFlags kuf = ku.KeyUsages;
		}
		public void ConstructorAsnEncodedData_BadAsn ()
		{
			AsnEncodedData aed = new AsnEncodedData ("1.2.3", new byte[0]);
			X509EnhancedKeyUsageExtension eku = new X509EnhancedKeyUsageExtension (aed, true);
			Assert.AreEqual (String.Empty, eku.Format (true), "Format(true)");
			Assert.AreEqual (String.Empty, eku.Format (false), "Format(false)");
			OidCollection oc = eku.EnhancedKeyUsages;
		}
Exemple #16
0
		public void Constructor_StringData ()
		{
			AsnEncodedData aed = new AsnEncodedData ("oid", asnNullBytes);
			Assert.AreEqual ("oid", aed.Oid.Value, "Oid.Value");
			Assert.IsNull (aed.Oid.FriendlyName, "Oid.FriendlyName");
			Assert.AreEqual (BitConverter.ToString (asnNullBytes), BitConverter.ToString (aed.RawData), "RawData");
			Assert.AreEqual (asnNullString, aed.Format (true), "Format");
		}
 public void Remove(AsnEncodedData asnEncodedData)
 {
     if (asnEncodedData == null)
     {
         throw new ArgumentNullException("asnEncodedData");
     }
     this.m_list.Remove(asnEncodedData);
 }
		public AsnEncodedData (AsnEncodedData asnEncodedData)
		{
			if (asnEncodedData == null)
				throw new ArgumentNullException ("asnEncodedData");

			Oid = new Oid (asnEncodedData._oid);
			RawData = asnEncodedData._raw;
		}
        public static void Pkcs9AttributeAsnEncodedDataCtorEmptyOidValue()
        {
            Oid oid = new Oid(Oids.Aes128);
            oid.Value = string.Empty;

            AsnEncodedData a = new AsnEncodedData(oid, new byte[3]);
            object ign;
            Assert.Throws<ArgumentException>(() => ign = new Pkcs9AttributeObject(a));
        }
        public int Add(AsnEncodedData asnEncodedData)
        {
            if (asnEncodedData == null)
                throw new ArgumentNullException(nameof(asnEncodedData));

            int indexOfNewItem = _list.Count;
            _list.Add(asnEncodedData);
            return indexOfNewItem;
        }
Exemple #21
0
 public Pkcs9AttributeObject (AsnEncodedData asnEncodedData) : base (asnEncodedData) {
     if (asnEncodedData.Oid == null)
         throw new ArgumentNullException("asnEncodedData.Oid");
     string szOid = base.Oid.Value;
     if (szOid == null)
         throw new ArgumentNullException("oid.Value");
     if (szOid.Length == 0)
         throw new ArgumentException(SecurityResources.GetResourceString("Arg_EmptyOrNullString"), "oid.Value");
 }
		public void CopyFrom_BadData ()
		{
			byte[] data = { 0x30, 0x18, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x09, 0x03, 0x30, 0x0B, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x07, 0x01 };
			AsnEncodedData aed = new AsnEncodedData (data);
			Pkcs9MessageDigest md = new Pkcs9MessageDigest ();
			md.CopyFrom (aed);
			// CopyFrom works, but the exception comes when accessing the ContentType property
			Assert.IsNull (md.MessageDigest);
		}
 public override void CopyFrom (AsnEncodedData asnEncodedData) {
     if (asnEncodedData == null)
     {
         throw new ArgumentNullException("asnEncodedData");
     }
     X509Extension extension = asnEncodedData as X509Extension;
     if (extension == null)
         throw new ArgumentException(SR.GetString(SR.Cryptography_X509_ExtensionMismatch));
     base.CopyFrom(asnEncodedData);
     m_critical = extension.Critical;
 }
		public void ConstructorAsnEncodedData ()
		{
			AsnEncodedData aed = new AsnEncodedData (new Oid ("2.5.29.37"), new byte[] { 0x30, 0x05, 0x06, 0x03, 0x2A, 0x03, 0x04 });
			X509Extension ex = new X509Extension (aed, true);
			Assert.IsTrue (ex.Critical, "Critical");
			Assert.AreEqual (7, ex.RawData.Length, "RawData");	// original Oid ignored
			Assert.AreEqual ("2.5.29.37", ex.Oid.Value, "Oid.Value");
			Assert.AreEqual ("Enhanced Key Usage", ex.Oid.FriendlyName, "Oid.FriendlyName");
			Assert.AreEqual ("Unknown Key Usage (1.2.3.4)" + Environment.NewLine, ex.Format (true), "Format(true)");
			Assert.AreEqual ("Unknown Key Usage (1.2.3.4)", ex.Format (false), "Format(false)");
		}
		public void CopyFrom ()
		{
			/* byte[] data = ASN1Convert.FromOid ("1.2.840.113549.1.7.1").GetBytes (); */
			byte[] data = { 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x07, 0x01 };
			AsnEncodedData aed = new AsnEncodedData (data);
			Pkcs9ContentType ct = new Pkcs9ContentType ();
			ct.CopyFrom (aed);
			Assert.AreEqual ("1.2.840.113549.1.7.1", ct.ContentType.Value, "ContentType");
			Assert.IsNull (ct.Oid, "Oid");
			Assert.AreEqual (data, ct.RawData, "RawData");
		}
		public void CopyFrom ()
		{
			byte[] data = { 0x04, 0x10, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F };
			AsnEncodedData aed = new AsnEncodedData (data);
			Pkcs9MessageDigest md = new Pkcs9MessageDigest ();
			md.CopyFrom (aed);
			Assert.AreEqual ("00-01-02-03-04-05-06-07-08-09-0A-0B-0C-0D-0E-0F", BitConverter.ToString (md.MessageDigest), "MessageDigest");
			Assert.IsNull (md.Oid, "Oid");
			// null ??? reported as FDBK25795
			// http://lab.msdn.microsoft.com/ProductFeedback/viewfeedback.aspx?feedbackid=15bb72f0-22dd-4911-846e-143d6038c7cf
			Assert.AreEqual (data, md.RawData, "RawData");
		}
		public void ConstructorAsnEncodedData ()
		{
			AsnEncodedData aed = new AsnEncodedData (new byte[] { 0x04, 0x08, 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF });
			X509SubjectKeyIdentifierExtension ski = new X509SubjectKeyIdentifierExtension (aed, true);
			Assert.IsTrue (ski.Critical, "Critical");
			Assert.AreEqual (oid, ski.Oid.Value, "Oid.Value");
			Assert.AreEqual (fname, ski.Oid.FriendlyName, "Oid.FriendlyName");
			Assert.AreEqual ("04-08-01-23-45-67-89-AB-CD-EF", BitConverter.ToString (ski.RawData), "RawData");
			Assert.AreEqual ("0123456789ABCDEF", ski.SubjectKeyIdentifier, "SubjectKeyIdentifier");
			Assert.AreEqual ("01 23 45 67 89 ab cd ef" + Environment.NewLine, ski.Format (true), "Format(true)");
			Assert.AreEqual ("01 23 45 67 89 ab cd ef", ski.Format (false), "Format(false)");
		}
        public void CopyTo(AsnEncodedData[] array, int index)
        {
            // Need to do part of the argument validation ourselves as AsnEncodedDataCollection throws
            // ArgumentOutOfRangeException where List<>.CopyTo() throws ArgumentException.

            if (array == null)
                throw new ArgumentNullException(nameof(array));
            if (index < 0 || index >= array.Length)
                throw new ArgumentOutOfRangeException(nameof(index), SR.ArgumentOutOfRange_Index);

             _list.CopyTo(array, index);
        }
		public void ConstructorAsnEncodedData ()
		{
			AsnEncodedData aed = new AsnEncodedData ("1.2.3", new byte[] { 0x03, 0x01, 0x00 });
			X509KeyUsageExtension ku = new X509KeyUsageExtension (aed, true);
			Assert.IsTrue (ku.Critical, "Critical");
			Assert.AreEqual (3, ku.RawData.Length, "RawData");	// original Oid ignored
			Assert.AreEqual (oid, ku.Oid.Value, "Oid.Value");
			Assert.AreEqual (fname, ku.Oid.FriendlyName, "Oid.FriendlyName");
			Assert.AreEqual ("Information Not Available", ku.Format (true), "Format(true)");
			Assert.AreEqual ("Information Not Available", ku.Format (false), "Format(false)");
			Assert.AreEqual (0, (int)ku.KeyUsages, "KeyUsages");
		}
		public void ConstructorAsnEncodedData ()
		{
			AsnEncodedData aed = new AsnEncodedData (new byte[] { 0x30, 0x05, 0x06, 0x03, 0x2A, 0x03, 0x04 });
			X509EnhancedKeyUsageExtension eku = new X509EnhancedKeyUsageExtension (aed, true);
			Assert.IsTrue (eku.Critical, "Critical");
			Assert.AreEqual (7, eku.RawData.Length, "RawData");	// original Oid ignored
			Assert.AreEqual (oid, eku.Oid.Value, "Oid.Value");
			Assert.AreEqual (fname, eku.Oid.FriendlyName, "Oid.FriendlyName");
			Assert.AreEqual (1, eku.EnhancedKeyUsages.Count, "EnhancedKeyUsages");
			Assert.AreEqual ("1.2.3.4", eku.EnhancedKeyUsages[0].Value, "EnhancedKeyUsages Oid");
			Assert.AreEqual ("Unknown Key Usage (1.2.3.4)" + Environment.NewLine, eku.Format (true), "Format(true)");
			Assert.AreEqual ("Unknown Key Usage (1.2.3.4)", eku.Format (false), "Format(false)");
		}
Exemple #31
0
    private KeyInfo getKeyInfo()
    {
      X509Extension extension = this.settings.Certificate.Extensions[1];
      AsnEncodedData asndata = new AsnEncodedData(extension.Oid, extension.RawData);

      KeyInfoX509Data keyInfoData = new KeyInfoX509Data();
      keyInfoData.AddIssuerSerial(this.settings.Certificate.Issuer, this.settings.Certificate.SerialNumber);
      keyInfoData.AddSubjectName(this.settings.Certificate.SubjectName.Name);

      KeyInfo keyInfo = new KeyInfo();
      keyInfo.AddClause(keyInfoData);
      return keyInfo;
    }
Exemple #32
0
 public AsnEncodedData(AsnEncodedData asnEncodedData !!)
 {