init commit

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Ocsp/BasicOcspResponse.cs

@@ -0,0 +1,100 @@
+using System;
+using Org.BouncyCastle.Asn1.X509;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Ocsp;
+
+public class BasicOcspResponse : Asn1Encodable
+{
+	private readonly ResponseData tbsResponseData;
+
+	private readonly AlgorithmIdentifier signatureAlgorithm;
+
+	private readonly DerBitString signature;
+
+	private readonly Asn1Sequence certs;
+
+	public ResponseData TbsResponseData => tbsResponseData;
+
+	public AlgorithmIdentifier SignatureAlgorithm => signatureAlgorithm;
+
+	public DerBitString Signature => signature;
+
+	public Asn1Sequence Certs => certs;
+
+	public static BasicOcspResponse GetInstance(Asn1TaggedObject obj, bool explicitly)
+	{
+		return GetInstance(Asn1Sequence.GetInstance(obj, explicitly));
+	}
+
+	public static BasicOcspResponse GetInstance(object obj)
+	{
+		if (obj == null || obj is BasicOcspResponse)
+		{
+			return (BasicOcspResponse)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new BasicOcspResponse((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("unknown object in factory: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public BasicOcspResponse(ResponseData tbsResponseData, AlgorithmIdentifier signatureAlgorithm, DerBitString signature, Asn1Sequence certs)
+	{
+		this.tbsResponseData = tbsResponseData;
+		this.signatureAlgorithm = signatureAlgorithm;
+		this.signature = signature;
+		this.certs = certs;
+	}
+
+	private BasicOcspResponse(Asn1Sequence seq)
+	{
+		tbsResponseData = ResponseData.GetInstance(seq[0]);
+		signatureAlgorithm = AlgorithmIdentifier.GetInstance(seq[1]);
+		signature = (DerBitString)seq[2];
+		if (seq.Count > 3)
+		{
+			certs = Asn1Sequence.GetInstance((Asn1TaggedObject)seq[3], explicitly: true);
+		}
+	}
+
+	[Obsolete("Use TbsResponseData property instead")]
+	public ResponseData GetTbsResponseData()
+	{
+		return tbsResponseData;
+	}
+
+	[Obsolete("Use SignatureAlgorithm property instead")]
+	public AlgorithmIdentifier GetSignatureAlgorithm()
+	{
+		return signatureAlgorithm;
+	}
+
+	[Obsolete("Use Signature property instead")]
+	public DerBitString GetSignature()
+	{
+		return signature;
+	}
+
+	public byte[] GetSignatureOctets()
+	{
+		return signature.GetOctets();
+	}
+
+	[Obsolete("Use Certs property instead")]
+	public Asn1Sequence GetCerts()
+	{
+		return certs;
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector(tbsResponseData, signatureAlgorithm, signature);
+		if (certs != null)
+		{
+			asn1EncodableVector.Add(new DerTaggedObject(explicitly: true, 0, certs));
+		}
+		return new DerSequence(asn1EncodableVector);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Ocsp/CertID.cs

@@ -0,0 +1,67 @@
+using System;
+using Org.BouncyCastle.Asn1.X509;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Ocsp;
+
+public class CertID : Asn1Encodable
+{
+	private readonly AlgorithmIdentifier hashAlgorithm;
+
+	private readonly Asn1OctetString issuerNameHash;
+
+	private readonly Asn1OctetString issuerKeyHash;
+
+	private readonly DerInteger serialNumber;
+
+	public AlgorithmIdentifier HashAlgorithm => hashAlgorithm;
+
+	public Asn1OctetString IssuerNameHash => issuerNameHash;
+
+	public Asn1OctetString IssuerKeyHash => issuerKeyHash;
+
+	public DerInteger SerialNumber => serialNumber;
+
+	public static CertID GetInstance(Asn1TaggedObject obj, bool explicitly)
+	{
+		return GetInstance(Asn1Sequence.GetInstance(obj, explicitly));
+	}
+
+	public static CertID GetInstance(object obj)
+	{
+		if (obj == null || obj is CertID)
+		{
+			return (CertID)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new CertID((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("unknown object in factory: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public CertID(AlgorithmIdentifier hashAlgorithm, Asn1OctetString issuerNameHash, Asn1OctetString issuerKeyHash, DerInteger serialNumber)
+	{
+		this.hashAlgorithm = hashAlgorithm;
+		this.issuerNameHash = issuerNameHash;
+		this.issuerKeyHash = issuerKeyHash;
+		this.serialNumber = serialNumber;
+	}
+
+	private CertID(Asn1Sequence seq)
+	{
+		if (seq.Count != 4)
+		{
+			throw new ArgumentException("Wrong number of elements in sequence", "seq");
+		}
+		hashAlgorithm = AlgorithmIdentifier.GetInstance(seq[0]);
+		issuerNameHash = Asn1OctetString.GetInstance(seq[1]);
+		issuerKeyHash = Asn1OctetString.GetInstance(seq[2]);
+		serialNumber = DerInteger.GetInstance(seq[3]);
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		return new DerSequence(hashAlgorithm, issuerNameHash, issuerKeyHash, serialNumber);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Ocsp/CertStatus.cs

@@ -0,0 +1,68 @@
+using System;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Ocsp;
+
+public class CertStatus : Asn1Encodable, IAsn1Choice
+{
+	private readonly int tagNo;
+
+	private readonly Asn1Encodable value;
+
+	public int TagNo => tagNo;
+
+	public Asn1Encodable Status => value;
+
+	public CertStatus()
+	{
+		tagNo = 0;
+		value = DerNull.Instance;
+	}
+
+	public CertStatus(RevokedInfo info)
+	{
+		tagNo = 1;
+		value = info;
+	}
+
+	public CertStatus(int tagNo, Asn1Encodable value)
+	{
+		this.tagNo = tagNo;
+		this.value = value;
+	}
+
+	public CertStatus(Asn1TaggedObject choice)
+	{
+		tagNo = choice.TagNo;
+		switch (choice.TagNo)
+		{
+		case 1:
+			value = RevokedInfo.GetInstance(choice, explicitly: false);
+			break;
+		case 0:
+		case 2:
+			value = DerNull.Instance;
+			break;
+		default:
+			throw new ArgumentException("Unknown tag encountered: " + choice.TagNo);
+		}
+	}
+
+	public static CertStatus GetInstance(object obj)
+	{
+		if (obj == null || obj is CertStatus)
+		{
+			return (CertStatus)obj;
+		}
+		if (obj is Asn1TaggedObject)
+		{
+			return new CertStatus((Asn1TaggedObject)obj);
+		}
+		throw new ArgumentException("unknown object in factory: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		return new DerTaggedObject(explicitly: false, tagNo, value);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Ocsp/CrlID.cs

@@ -0,0 +1,57 @@
+using System;
+
+namespace Org.BouncyCastle.Asn1.Ocsp;
+
+public class CrlID : Asn1Encodable
+{
+	private readonly DerIA5String crlUrl;
+
+	private readonly DerInteger crlNum;
+
+	private readonly DerGeneralizedTime crlTime;
+
+	public DerIA5String CrlUrl => crlUrl;
+
+	public DerInteger CrlNum => crlNum;
+
+	public DerGeneralizedTime CrlTime => crlTime;
+
+	public CrlID(Asn1Sequence seq)
+	{
+		foreach (Asn1TaggedObject item in seq)
+		{
+			switch (item.TagNo)
+			{
+			case 0:
+				crlUrl = DerIA5String.GetInstance(item, isExplicit: true);
+				break;
+			case 1:
+				crlNum = DerInteger.GetInstance(item, isExplicit: true);
+				break;
+			case 2:
+				crlTime = DerGeneralizedTime.GetInstance(item, isExplicit: true);
+				break;
+			default:
+				throw new ArgumentException("unknown tag number: " + item.TagNo);
+			}
+		}
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector();
+		if (crlUrl != null)
+		{
+			asn1EncodableVector.Add(new DerTaggedObject(explicitly: true, 0, crlUrl));
+		}
+		if (crlNum != null)
+		{
+			asn1EncodableVector.Add(new DerTaggedObject(explicitly: true, 1, crlNum));
+		}
+		if (crlTime != null)
+		{
+			asn1EncodableVector.Add(new DerTaggedObject(explicitly: true, 2, crlTime));
+		}
+		return new DerSequence(asn1EncodableVector);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Ocsp/OcspObjectIdentifiers.cs

@@ -0,0 +1,22 @@
+namespace Org.BouncyCastle.Asn1.Ocsp;
+
+public abstract class OcspObjectIdentifiers
+{
+	internal const string PkixOcspId = "1.3.6.1.5.5.7.48.1";
+
+	public static readonly DerObjectIdentifier PkixOcsp = new DerObjectIdentifier("1.3.6.1.5.5.7.48.1");
+
+	public static readonly DerObjectIdentifier PkixOcspBasic = new DerObjectIdentifier("1.3.6.1.5.5.7.48.1.1");
+
+	public static readonly DerObjectIdentifier PkixOcspNonce = new DerObjectIdentifier(string.Concat(PkixOcsp, ".2"));
+
+	public static readonly DerObjectIdentifier PkixOcspCrl = new DerObjectIdentifier(string.Concat(PkixOcsp, ".3"));
+
+	public static readonly DerObjectIdentifier PkixOcspResponse = new DerObjectIdentifier(string.Concat(PkixOcsp, ".4"));
+
+	public static readonly DerObjectIdentifier PkixOcspNocheck = new DerObjectIdentifier(string.Concat(PkixOcsp, ".5"));
+
+	public static readonly DerObjectIdentifier PkixOcspArchiveCutoff = new DerObjectIdentifier(string.Concat(PkixOcsp, ".6"));
+
+	public static readonly DerObjectIdentifier PkixOcspServiceLocator = new DerObjectIdentifier(string.Concat(PkixOcsp, ".7"));
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Ocsp/OcspRequest.cs

@@ -0,0 +1,62 @@
+using System;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Ocsp;
+
+public class OcspRequest : Asn1Encodable
+{
+	private readonly TbsRequest tbsRequest;
+
+	private readonly Signature optionalSignature;
+
+	public TbsRequest TbsRequest => tbsRequest;
+
+	public Signature OptionalSignature => optionalSignature;
+
+	public static OcspRequest GetInstance(Asn1TaggedObject obj, bool explicitly)
+	{
+		return GetInstance(Asn1Sequence.GetInstance(obj, explicitly));
+	}
+
+	public static OcspRequest GetInstance(object obj)
+	{
+		if (obj == null || obj is OcspRequest)
+		{
+			return (OcspRequest)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new OcspRequest((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("unknown object in factory: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public OcspRequest(TbsRequest tbsRequest, Signature optionalSignature)
+	{
+		if (tbsRequest == null)
+		{
+			throw new ArgumentNullException("tbsRequest");
+		}
+		this.tbsRequest = tbsRequest;
+		this.optionalSignature = optionalSignature;
+	}
+
+	private OcspRequest(Asn1Sequence seq)
+	{
+		tbsRequest = TbsRequest.GetInstance(seq[0]);
+		if (seq.Count == 2)
+		{
+			optionalSignature = Signature.GetInstance((Asn1TaggedObject)seq[1], explicitly: true);
+		}
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector(tbsRequest);
+		if (optionalSignature != null)
+		{
+			asn1EncodableVector.Add(new DerTaggedObject(explicitly: true, 0, optionalSignature));
+		}
+		return new DerSequence(asn1EncodableVector);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Ocsp/OcspResponse.cs

@@ -0,0 +1,62 @@
+using System;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Ocsp;
+
+public class OcspResponse : Asn1Encodable
+{
+	private readonly OcspResponseStatus responseStatus;
+
+	private readonly ResponseBytes responseBytes;
+
+	public OcspResponseStatus ResponseStatus => responseStatus;
+
+	public ResponseBytes ResponseBytes => responseBytes;
+
+	public static OcspResponse GetInstance(Asn1TaggedObject obj, bool explicitly)
+	{
+		return GetInstance(Asn1Sequence.GetInstance(obj, explicitly));
+	}
+
+	public static OcspResponse GetInstance(object obj)
+	{
+		if (obj == null || obj is OcspResponse)
+		{
+			return (OcspResponse)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new OcspResponse((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("unknown object in factory: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public OcspResponse(OcspResponseStatus responseStatus, ResponseBytes responseBytes)
+	{
+		if (responseStatus == null)
+		{
+			throw new ArgumentNullException("responseStatus");
+		}
+		this.responseStatus = responseStatus;
+		this.responseBytes = responseBytes;
+	}
+
+	private OcspResponse(Asn1Sequence seq)
+	{
+		responseStatus = new OcspResponseStatus(DerEnumerated.GetInstance(seq[0]));
+		if (seq.Count == 2)
+		{
+			responseBytes = ResponseBytes.GetInstance((Asn1TaggedObject)seq[1], explicitly: true);
+		}
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector(responseStatus);
+		if (responseBytes != null)
+		{
+			asn1EncodableVector.Add(new DerTaggedObject(explicitly: true, 0, responseBytes));
+		}
+		return new DerSequence(asn1EncodableVector);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Ocsp/OcspResponseStatus.cs

@@ -0,0 +1,26 @@
+namespace Org.BouncyCastle.Asn1.Ocsp;
+
+public class OcspResponseStatus : DerEnumerated
+{
+	public const int Successful = 0;
+
+	public const int MalformedRequest = 1;
+
+	public const int InternalError = 2;
+
+	public const int TryLater = 3;
+
+	public const int SignatureRequired = 5;
+
+	public const int Unauthorized = 6;
+
+	public OcspResponseStatus(int value)
+		: base(value)
+	{
+	}
+
+	public OcspResponseStatus(DerEnumerated value)
+		: base(value.Value.IntValue)
+	{
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Ocsp/Request.cs

@@ -0,0 +1,63 @@
+using System;
+using Org.BouncyCastle.Asn1.X509;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Ocsp;
+
+public class Request : Asn1Encodable
+{
+	private readonly CertID reqCert;
+
+	private readonly X509Extensions singleRequestExtensions;
+
+	public CertID ReqCert => reqCert;
+
+	public X509Extensions SingleRequestExtensions => singleRequestExtensions;
+
+	public static Request GetInstance(Asn1TaggedObject obj, bool explicitly)
+	{
+		return GetInstance(Asn1Sequence.GetInstance(obj, explicitly));
+	}
+
+	public static Request GetInstance(object obj)
+	{
+		if (obj == null || obj is Request)
+		{
+			return (Request)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new Request((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("unknown object in factory: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public Request(CertID reqCert, X509Extensions singleRequestExtensions)
+	{
+		if (reqCert == null)
+		{
+			throw new ArgumentNullException("reqCert");
+		}
+		this.reqCert = reqCert;
+		this.singleRequestExtensions = singleRequestExtensions;
+	}
+
+	private Request(Asn1Sequence seq)
+	{
+		reqCert = CertID.GetInstance(seq[0]);
+		if (seq.Count == 2)
+		{
+			singleRequestExtensions = X509Extensions.GetInstance((Asn1TaggedObject)seq[1], explicitly: true);
+		}
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector(reqCert);
+		if (singleRequestExtensions != null)
+		{
+			asn1EncodableVector.Add(new DerTaggedObject(explicitly: true, 0, singleRequestExtensions));
+		}
+		return new DerSequence(asn1EncodableVector);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Ocsp/ResponderID.cs

@@ -0,0 +1,84 @@
+using System;
+using Org.BouncyCastle.Asn1.X509;
+
+namespace Org.BouncyCastle.Asn1.Ocsp;
+
+public class ResponderID : Asn1Encodable, IAsn1Choice
+{
+	private readonly Asn1Encodable id;
+
+	public virtual X509Name Name
+	{
+		get
+		{
+			if (id is Asn1OctetString)
+			{
+				return null;
+			}
+			return X509Name.GetInstance(id);
+		}
+	}
+
+	public static ResponderID GetInstance(object obj)
+	{
+		if (obj == null || obj is ResponderID)
+		{
+			return (ResponderID)obj;
+		}
+		if (obj is DerOctetString)
+		{
+			return new ResponderID((DerOctetString)obj);
+		}
+		if (obj is Asn1TaggedObject)
+		{
+			Asn1TaggedObject asn1TaggedObject = (Asn1TaggedObject)obj;
+			if (asn1TaggedObject.TagNo == 1)
+			{
+				return new ResponderID(X509Name.GetInstance(asn1TaggedObject, explicitly: true));
+			}
+			return new ResponderID(Asn1OctetString.GetInstance(asn1TaggedObject, isExplicit: true));
+		}
+		return new ResponderID(X509Name.GetInstance(obj));
+	}
+
+	public ResponderID(Asn1OctetString id)
+	{
+		if (id == null)
+		{
+			throw new ArgumentNullException("id");
+		}
+		this.id = id;
+	}
+
+	public ResponderID(X509Name id)
+	{
+		if (id == null)
+		{
+			throw new ArgumentNullException("id");
+		}
+		this.id = id;
+	}
+
+	public static ResponderID GetInstance(Asn1TaggedObject obj, bool isExplicit)
+	{
+		return GetInstance(obj.GetObject());
+	}
+
+	public virtual byte[] GetKeyHash()
+	{
+		if (id is Asn1OctetString)
+		{
+			return ((Asn1OctetString)id).GetOctets();
+		}
+		return null;
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		if (id is Asn1OctetString)
+		{
+			return new DerTaggedObject(explicitly: true, 2, id);
+		}
+		return new DerTaggedObject(explicitly: true, 1, id);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Ocsp/ResponseBytes.cs

@@ -0,0 +1,62 @@
+using System;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Ocsp;
+
+public class ResponseBytes : Asn1Encodable
+{
+	private readonly DerObjectIdentifier responseType;
+
+	private readonly Asn1OctetString response;
+
+	public DerObjectIdentifier ResponseType => responseType;
+
+	public Asn1OctetString Response => response;
+
+	public static ResponseBytes GetInstance(Asn1TaggedObject obj, bool explicitly)
+	{
+		return GetInstance(Asn1Sequence.GetInstance(obj, explicitly));
+	}
+
+	public static ResponseBytes GetInstance(object obj)
+	{
+		if (obj == null || obj is ResponseBytes)
+		{
+			return (ResponseBytes)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new ResponseBytes((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("unknown object in factory: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public ResponseBytes(DerObjectIdentifier responseType, Asn1OctetString response)
+	{
+		if (responseType == null)
+		{
+			throw new ArgumentNullException("responseType");
+		}
+		if (response == null)
+		{
+			throw new ArgumentNullException("response");
+		}
+		this.responseType = responseType;
+		this.response = response;
+	}
+
+	private ResponseBytes(Asn1Sequence seq)
+	{
+		if (seq.Count != 2)
+		{
+			throw new ArgumentException("Wrong number of elements in sequence", "seq");
+		}
+		responseType = DerObjectIdentifier.GetInstance(seq[0]);
+		response = Asn1OctetString.GetInstance(seq[1]);
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		return new DerSequence(responseType, response);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Ocsp/ResponseData.cs

@@ -0,0 +1,110 @@
+using System;
+using Org.BouncyCastle.Asn1.X509;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Ocsp;
+
+public class ResponseData : Asn1Encodable
+{
+	private static readonly DerInteger V1 = new DerInteger(0);
+
+	private readonly bool versionPresent;
+
+	private readonly DerInteger version;
+
+	private readonly ResponderID responderID;
+
+	private readonly DerGeneralizedTime producedAt;
+
+	private readonly Asn1Sequence responses;
+
+	private readonly X509Extensions responseExtensions;
+
+	public DerInteger Version => version;
+
+	public ResponderID ResponderID => responderID;
+
+	public DerGeneralizedTime ProducedAt => producedAt;
+
+	public Asn1Sequence Responses => responses;
+
+	public X509Extensions ResponseExtensions => responseExtensions;
+
+	public static ResponseData GetInstance(Asn1TaggedObject obj, bool explicitly)
+	{
+		return GetInstance(Asn1Sequence.GetInstance(obj, explicitly));
+	}
+
+	public static ResponseData GetInstance(object obj)
+	{
+		if (obj == null || obj is ResponseData)
+		{
+			return (ResponseData)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new ResponseData((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("unknown object in factory: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public ResponseData(DerInteger version, ResponderID responderID, DerGeneralizedTime producedAt, Asn1Sequence responses, X509Extensions responseExtensions)
+	{
+		this.version = version;
+		this.responderID = responderID;
+		this.producedAt = producedAt;
+		this.responses = responses;
+		this.responseExtensions = responseExtensions;
+	}
+
+	public ResponseData(ResponderID responderID, DerGeneralizedTime producedAt, Asn1Sequence responses, X509Extensions responseExtensions)
+		: this(V1, responderID, producedAt, responses, responseExtensions)
+	{
+	}
+
+	private ResponseData(Asn1Sequence seq)
+	{
+		int num = 0;
+		Asn1Encodable asn1Encodable = seq[0];
+		if (asn1Encodable is Asn1TaggedObject)
+		{
+			Asn1TaggedObject asn1TaggedObject = (Asn1TaggedObject)asn1Encodable;
+			if (asn1TaggedObject.TagNo == 0)
+			{
+				versionPresent = true;
+				version = DerInteger.GetInstance(asn1TaggedObject, isExplicit: true);
+				num++;
+			}
+			else
+			{
+				version = V1;
+			}
+		}
+		else
+		{
+			version = V1;
+		}
+		responderID = ResponderID.GetInstance(seq[num++]);
+		producedAt = (DerGeneralizedTime)seq[num++];
+		responses = (Asn1Sequence)seq[num++];
+		if (seq.Count > num)
+		{
+			responseExtensions = X509Extensions.GetInstance((Asn1TaggedObject)seq[num], explicitly: true);
+		}
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector();
+		if (versionPresent || !version.Equals(V1))
+		{
+			asn1EncodableVector.Add(new DerTaggedObject(explicitly: true, 0, version));
+		}
+		asn1EncodableVector.Add(responderID, producedAt, responses);
+		if (responseExtensions != null)
+		{
+			asn1EncodableVector.Add(new DerTaggedObject(explicitly: true, 1, responseExtensions));
+		}
+		return new DerSequence(asn1EncodableVector);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Ocsp/RevokedInfo.cs

@@ -0,0 +1,68 @@
+using System;
+using Org.BouncyCastle.Asn1.X509;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Ocsp;
+
+public class RevokedInfo : Asn1Encodable
+{
+	private readonly DerGeneralizedTime revocationTime;
+
+	private readonly CrlReason revocationReason;
+
+	public DerGeneralizedTime RevocationTime => revocationTime;
+
+	public CrlReason RevocationReason => revocationReason;
+
+	public static RevokedInfo GetInstance(Asn1TaggedObject obj, bool explicitly)
+	{
+		return GetInstance(Asn1Sequence.GetInstance(obj, explicitly));
+	}
+
+	public static RevokedInfo GetInstance(object obj)
+	{
+		if (obj == null || obj is RevokedInfo)
+		{
+			return (RevokedInfo)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new RevokedInfo((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("unknown object in factory: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public RevokedInfo(DerGeneralizedTime revocationTime)
+		: this(revocationTime, null)
+	{
+	}
+
+	public RevokedInfo(DerGeneralizedTime revocationTime, CrlReason revocationReason)
+	{
+		if (revocationTime == null)
+		{
+			throw new ArgumentNullException("revocationTime");
+		}
+		this.revocationTime = revocationTime;
+		this.revocationReason = revocationReason;
+	}
+
+	private RevokedInfo(Asn1Sequence seq)
+	{
+		revocationTime = (DerGeneralizedTime)seq[0];
+		if (seq.Count > 1)
+		{
+			revocationReason = new CrlReason(DerEnumerated.GetInstance((Asn1TaggedObject)seq[1], isExplicit: true));
+		}
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector(revocationTime);
+		if (revocationReason != null)
+		{
+			asn1EncodableVector.Add(new DerTaggedObject(explicitly: true, 0, revocationReason));
+		}
+		return new DerSequence(asn1EncodableVector);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Ocsp/ServiceLocator.cs

@@ -0,0 +1,68 @@
+using System;
+using Org.BouncyCastle.Asn1.X509;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Ocsp;
+
+public class ServiceLocator : Asn1Encodable
+{
+	private readonly X509Name issuer;
+
+	private readonly Asn1Object locator;
+
+	public X509Name Issuer => issuer;
+
+	public Asn1Object Locator => locator;
+
+	public static ServiceLocator GetInstance(Asn1TaggedObject obj, bool explicitly)
+	{
+		return GetInstance(Asn1Sequence.GetInstance(obj, explicitly));
+	}
+
+	public static ServiceLocator GetInstance(object obj)
+	{
+		if (obj == null || obj is ServiceLocator)
+		{
+			return (ServiceLocator)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new ServiceLocator((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("unknown object in factory: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public ServiceLocator(X509Name issuer)
+		: this(issuer, null)
+	{
+	}
+
+	public ServiceLocator(X509Name issuer, Asn1Object locator)
+	{
+		if (issuer == null)
+		{
+			throw new ArgumentNullException("issuer");
+		}
+		this.issuer = issuer;
+		this.locator = locator;
+	}
+
+	private ServiceLocator(Asn1Sequence seq)
+	{
+		issuer = X509Name.GetInstance(seq[0]);
+		if (seq.Count > 1)
+		{
+			locator = seq[1].ToAsn1Object();
+		}
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector(issuer);
+		if (locator != null)
+		{
+			asn1EncodableVector.Add(locator);
+		}
+		return new DerSequence(asn1EncodableVector);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Ocsp/Signature.cs

@@ -0,0 +1,83 @@
+using System;
+using Org.BouncyCastle.Asn1.X509;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Ocsp;
+
+public class Signature : Asn1Encodable
+{
+	internal AlgorithmIdentifier signatureAlgorithm;
+
+	internal DerBitString signatureValue;
+
+	internal Asn1Sequence certs;
+
+	public AlgorithmIdentifier SignatureAlgorithm => signatureAlgorithm;
+
+	public DerBitString SignatureValue => signatureValue;
+
+	public Asn1Sequence Certs => certs;
+
+	public static Signature GetInstance(Asn1TaggedObject obj, bool explicitly)
+	{
+		return GetInstance(Asn1Sequence.GetInstance(obj, explicitly));
+	}
+
+	public static Signature GetInstance(object obj)
+	{
+		if (obj == null || obj is Signature)
+		{
+			return (Signature)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new Signature((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("unknown object in factory: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public Signature(AlgorithmIdentifier signatureAlgorithm, DerBitString signatureValue)
+		: this(signatureAlgorithm, signatureValue, null)
+	{
+	}
+
+	public Signature(AlgorithmIdentifier signatureAlgorithm, DerBitString signatureValue, Asn1Sequence certs)
+	{
+		if (signatureAlgorithm == null)
+		{
+			throw new ArgumentException("signatureAlgorithm");
+		}
+		if (signatureValue == null)
+		{
+			throw new ArgumentException("signatureValue");
+		}
+		this.signatureAlgorithm = signatureAlgorithm;
+		this.signatureValue = signatureValue;
+		this.certs = certs;
+	}
+
+	private Signature(Asn1Sequence seq)
+	{
+		signatureAlgorithm = AlgorithmIdentifier.GetInstance(seq[0]);
+		signatureValue = (DerBitString)seq[1];
+		if (seq.Count == 3)
+		{
+			certs = Asn1Sequence.GetInstance((Asn1TaggedObject)seq[2], explicitly: true);
+		}
+	}
+
+	public byte[] GetSignatureOctets()
+	{
+		return signatureValue.GetOctets();
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector(signatureAlgorithm, signatureValue);
+		if (certs != null)
+		{
+			asn1EncodableVector.Add(new DerTaggedObject(explicitly: true, 0, certs));
+		}
+		return new DerSequence(asn1EncodableVector);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Ocsp/SingleResponse.cs

@@ -0,0 +1,93 @@
+using System;
+using Org.BouncyCastle.Asn1.X509;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Ocsp;
+
+public class SingleResponse : Asn1Encodable
+{
+	private readonly CertID certID;
+
+	private readonly CertStatus certStatus;
+
+	private readonly DerGeneralizedTime thisUpdate;
+
+	private readonly DerGeneralizedTime nextUpdate;
+
+	private readonly X509Extensions singleExtensions;
+
+	public CertID CertId => certID;
+
+	public CertStatus CertStatus => certStatus;
+
+	public DerGeneralizedTime ThisUpdate => thisUpdate;
+
+	public DerGeneralizedTime NextUpdate => nextUpdate;
+
+	public X509Extensions SingleExtensions => singleExtensions;
+
+	public SingleResponse(CertID certID, CertStatus certStatus, DerGeneralizedTime thisUpdate, DerGeneralizedTime nextUpdate, X509Extensions singleExtensions)
+	{
+		this.certID = certID;
+		this.certStatus = certStatus;
+		this.thisUpdate = thisUpdate;
+		this.nextUpdate = nextUpdate;
+		this.singleExtensions = singleExtensions;
+	}
+
+	public SingleResponse(Asn1Sequence seq)
+	{
+		certID = CertID.GetInstance(seq[0]);
+		certStatus = CertStatus.GetInstance(seq[1]);
+		thisUpdate = (DerGeneralizedTime)seq[2];
+		if (seq.Count > 4)
+		{
+			nextUpdate = DerGeneralizedTime.GetInstance((Asn1TaggedObject)seq[3], isExplicit: true);
+			singleExtensions = X509Extensions.GetInstance((Asn1TaggedObject)seq[4], explicitly: true);
+		}
+		else if (seq.Count > 3)
+		{
+			Asn1TaggedObject asn1TaggedObject = (Asn1TaggedObject)seq[3];
+			if (asn1TaggedObject.TagNo == 0)
+			{
+				nextUpdate = DerGeneralizedTime.GetInstance(asn1TaggedObject, isExplicit: true);
+			}
+			else
+			{
+				singleExtensions = X509Extensions.GetInstance(asn1TaggedObject, explicitly: true);
+			}
+		}
+	}
+
+	public static SingleResponse GetInstance(Asn1TaggedObject obj, bool explicitly)
+	{
+		return GetInstance(Asn1Sequence.GetInstance(obj, explicitly));
+	}
+
+	public static SingleResponse GetInstance(object obj)
+	{
+		if (obj == null || obj is SingleResponse)
+		{
+			return (SingleResponse)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new SingleResponse((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("unknown object in factory: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector(certID, certStatus, thisUpdate);
+		if (nextUpdate != null)
+		{
+			asn1EncodableVector.Add(new DerTaggedObject(explicitly: true, 0, nextUpdate));
+		}
+		if (singleExtensions != null)
+		{
+			asn1EncodableVector.Add(new DerTaggedObject(explicitly: true, 1, singleExtensions));
+		}
+		return new DerSequence(asn1EncodableVector);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Ocsp/TbsRequest.cs

@@ -0,0 +1,106 @@
+using System;
+using Org.BouncyCastle.Asn1.X509;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Ocsp;
+
+public class TbsRequest : Asn1Encodable
+{
+	private static readonly DerInteger V1 = new DerInteger(0);
+
+	private readonly DerInteger version;
+
+	private readonly GeneralName requestorName;
+
+	private readonly Asn1Sequence requestList;
+
+	private readonly X509Extensions requestExtensions;
+
+	private bool versionSet;
+
+	public DerInteger Version => version;
+
+	public GeneralName RequestorName => requestorName;
+
+	public Asn1Sequence RequestList => requestList;
+
+	public X509Extensions RequestExtensions => requestExtensions;
+
+	public static TbsRequest GetInstance(Asn1TaggedObject obj, bool explicitly)
+	{
+		return GetInstance(Asn1Sequence.GetInstance(obj, explicitly));
+	}
+
+	public static TbsRequest GetInstance(object obj)
+	{
+		if (obj == null || obj is TbsRequest)
+		{
+			return (TbsRequest)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new TbsRequest((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("unknown object in factory: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public TbsRequest(GeneralName requestorName, Asn1Sequence requestList, X509Extensions requestExtensions)
+	{
+		version = V1;
+		this.requestorName = requestorName;
+		this.requestList = requestList;
+		this.requestExtensions = requestExtensions;
+	}
+
+	private TbsRequest(Asn1Sequence seq)
+	{
+		int num = 0;
+		Asn1Encodable asn1Encodable = seq[0];
+		if (asn1Encodable is Asn1TaggedObject)
+		{
+			Asn1TaggedObject asn1TaggedObject = (Asn1TaggedObject)asn1Encodable;
+			if (asn1TaggedObject.TagNo == 0)
+			{
+				versionSet = true;
+				version = DerInteger.GetInstance(asn1TaggedObject, isExplicit: true);
+				num++;
+			}
+			else
+			{
+				version = V1;
+			}
+		}
+		else
+		{
+			version = V1;
+		}
+		if (seq[num] is Asn1TaggedObject)
+		{
+			requestorName = GeneralName.GetInstance((Asn1TaggedObject)seq[num++], explicitly: true);
+		}
+		requestList = (Asn1Sequence)seq[num++];
+		if (seq.Count == num + 1)
+		{
+			requestExtensions = X509Extensions.GetInstance((Asn1TaggedObject)seq[num], explicitly: true);
+		}
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector();
+		if (!version.Equals(V1) || versionSet)
+		{
+			asn1EncodableVector.Add(new DerTaggedObject(explicitly: true, 0, version));
+		}
+		if (requestorName != null)
+		{
+			asn1EncodableVector.Add(new DerTaggedObject(explicitly: true, 1, requestorName));
+		}
+		asn1EncodableVector.Add(requestList);
+		if (requestExtensions != null)
+		{
+			asn1EncodableVector.Add(new DerTaggedObject(explicitly: true, 2, requestExtensions));
+		}
+		return new DerSequence(asn1EncodableVector);
+	}
+}