init commit

output/Libraries/BouncyCastle.Crypto/AssemblyInfo.cs

@@ -0,0 +1,22 @@
+using System.Reflection;
+
+internal class AssemblyInfo
+{
+	private static string version = null;
+
+	public static string Version
+	{
+		get
+		{
+			if (version == null)
+			{
+				version = Assembly.GetExecutingAssembly().GetName().Version.ToString();
+				if (version == null)
+				{
+					version = string.Empty;
+				}
+			}
+			return version;
+		}
+	}
+}

output/Libraries/BouncyCastle.Crypto/BouncyCastle.Crypto.csproj

@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <AssemblyName>BouncyCastle.Crypto</AssemblyName>
+    <GenerateAssemblyInfo>False</GenerateAssemblyInfo>
+    <TargetFramework>net10</TargetFramework>
+  </PropertyGroup>
+  <PropertyGroup>
+    <LangVersion>12.0</LangVersion>
+    <AllowUnsafeBlocks>True</AllowUnsafeBlocks>
+  </PropertyGroup>
+  <PropertyGroup />
+  <ItemGroup />
+  <ItemGroup />
+</Project>

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Apache/Bzip2/BZip2Constants.cs

@@ -0,0 +1,80 @@
+namespace Org.BouncyCastle.Apache.Bzip2;
+
+public class BZip2Constants
+{
+	public const int baseBlockSize = 100000;
+
+	public const int MAX_ALPHA_SIZE = 258;
+
+	public const int MAX_CODE_LEN = 23;
+
+	public const int RUNA = 0;
+
+	public const int RUNB = 1;
+
+	public const int N_GROUPS = 6;
+
+	public const int G_SIZE = 50;
+
+	public const int N_ITERS = 4;
+
+	public const int MAX_SELECTORS = 18002;
+
+	public const int NUM_OVERSHOOT_BYTES = 20;
+
+	public static readonly int[] rNums = new int[512]
+	{
+		619, 720, 127, 481, 931, 816, 813, 233, 566, 247,
+		985, 724, 205, 454, 863, 491, 741, 242, 949, 214,
+		733, 859, 335, 708, 621, 574, 73, 654, 730, 472,
+		419, 436, 278, 496, 867, 210, 399, 680, 480, 51,
+		878, 465, 811, 169, 869, 675, 611, 697, 867, 561,
+		862, 687, 507, 283, 482, 129, 807, 591, 733, 623,
+		150, 238, 59, 379, 684, 877, 625, 169, 643, 105,
+		170, 607, 520, 932, 727, 476, 693, 425, 174, 647,
+		73, 122, 335, 530, 442, 853, 695, 249, 445, 515,
+		909, 545, 703, 919, 874, 474, 882, 500, 594, 612,
+		641, 801, 220, 162, 819, 984, 589, 513, 495, 799,
+		161, 604, 958, 533, 221, 400, 386, 867, 600, 782,
+		382, 596, 414, 171, 516, 375, 682, 485, 911, 276,
+		98, 553, 163, 354, 666, 933, 424, 341, 533, 870,
+		227, 730, 475, 186, 263, 647, 537, 686, 600, 224,
+		469, 68, 770, 919, 190, 373, 294, 822, 808, 206,
+		184, 943, 795, 384, 383, 461, 404, 758, 839, 887,
+		715, 67, 618, 276, 204, 918, 873, 777, 604, 560,
+		951, 160, 578, 722, 79, 804, 96, 409, 713, 940,
+		652, 934, 970, 447, 318, 353, 859, 672, 112, 785,
+		645, 863, 803, 350, 139, 93, 354, 99, 820, 908,
+		609, 772, 154, 274, 580, 184, 79, 626, 630, 742,
+		653, 282, 762, 623, 680, 81, 927, 626, 789, 125,
+		411, 521, 938, 300, 821, 78, 343, 175, 128, 250,
+		170, 774, 972, 275, 999, 639, 495, 78, 352, 126,
+		857, 956, 358, 619, 580, 124, 737, 594, 701, 612,
+		669, 112, 134, 694, 363, 992, 809, 743, 168, 974,
+		944, 375, 748, 52, 600, 747, 642, 182, 862, 81,
+		344, 805, 988, 739, 511, 655, 814, 334, 249, 515,
+		897, 955, 664, 981, 649, 113, 974, 459, 893, 228,
+		433, 837, 553, 268, 926, 240, 102, 654, 459, 51,
+		686, 754, 806, 760, 493, 403, 415, 394, 687, 700,
+		946, 670, 656, 610, 738, 392, 760, 799, 887, 653,
+		978, 321, 576, 617, 626, 502, 894, 679, 243, 440,
+		680, 879, 194, 572, 640, 724, 926, 56, 204, 700,
+		707, 151, 457, 449, 797, 195, 791, 558, 945, 679,
+		297, 59, 87, 824, 713, 663, 412, 693, 342, 606,
+		134, 108, 571, 364, 631, 212, 174, 643, 304, 329,
+		343, 97, 430, 751, 497, 314, 983, 374, 822, 928,
+		140, 206, 73, 263, 980, 736, 876, 478, 430, 305,
+		170, 514, 364, 692, 829, 82, 855, 953, 676, 246,
+		369, 970, 294, 750, 807, 827, 150, 790, 288, 923,
+		804, 378, 215, 828, 592, 281, 565, 555, 710, 82,
+		896, 831, 547, 261, 524, 462, 293, 465, 502, 56,
+		661, 821, 976, 991, 658, 869, 905, 758, 745, 193,
+		768, 550, 608, 933, 378, 286, 215, 979, 792, 961,
+		61, 688, 793, 644, 986, 403, 106, 366, 905, 644,
+		372, 567, 466, 434, 645, 210, 389, 550, 919, 135,
+		780, 773, 635, 389, 707, 100, 626, 958, 165, 504,
+		920, 176, 193, 713, 857, 265, 203, 50, 668, 108,
+		645, 990, 626, 197, 510, 357, 358, 850, 858, 364,
+		936, 638
+	};
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Apache/Bzip2/CBZip2InputStream.cs

@@ -0,0 +1,930 @@
+using System.IO;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Apache.Bzip2;
+
+public class CBZip2InputStream : Stream
+{
+	private const int START_BLOCK_STATE = 1;
+
+	private const int RAND_PART_A_STATE = 2;
+
+	private const int RAND_PART_B_STATE = 3;
+
+	private const int RAND_PART_C_STATE = 4;
+
+	private const int NO_RAND_PART_A_STATE = 5;
+
+	private const int NO_RAND_PART_B_STATE = 6;
+
+	private const int NO_RAND_PART_C_STATE = 7;
+
+	private int last;
+
+	private int origPtr;
+
+	private int blockSize100k;
+
+	private bool blockRandomised;
+
+	private int bsBuff;
+
+	private int bsLive;
+
+	private CRC mCrc = new CRC();
+
+	private bool[] inUse = new bool[256];
+
+	private int nInUse;
+
+	private char[] seqToUnseq = new char[256];
+
+	private char[] unseqToSeq = new char[256];
+
+	private char[] selector = new char[18002];
+
+	private char[] selectorMtf = new char[18002];
+
+	private int[] tt;
+
+	private char[] ll8;
+
+	private int[] unzftab = new int[256];
+
+	private int[][] limit = InitIntArray(6, 258);
+
+	private int[][] basev = InitIntArray(6, 258);
+
+	private int[][] perm = InitIntArray(6, 258);
+
+	private int[] minLens = new int[6];
+
+	private Stream bsStream;
+
+	private bool streamEnd = false;
+
+	private int currentChar = -1;
+
+	private int currentState = 1;
+
+	private int storedBlockCRC;
+
+	private int storedCombinedCRC;
+
+	private int computedBlockCRC;
+
+	private int computedCombinedCRC;
+
+	private int i2;
+
+	private int count;
+
+	private int chPrev;
+
+	private int ch2;
+
+	private int i;
+
+	private int tPos;
+
+	private int rNToGo = 0;
+
+	private int rTPos = 0;
+
+	private int j2;
+
+	private char z;
+
+	public override bool CanRead => true;
+
+	public override bool CanSeek => false;
+
+	public override bool CanWrite => false;
+
+	public override long Length => 0L;
+
+	public override long Position
+	{
+		get
+		{
+			return 0L;
+		}
+		set
+		{
+		}
+	}
+
+	private static void Cadvise()
+	{
+	}
+
+	private static void CompressedStreamEOF()
+	{
+		Cadvise();
+	}
+
+	private void MakeMaps()
+	{
+		nInUse = 0;
+		for (int i = 0; i < 256; i++)
+		{
+			if (inUse[i])
+			{
+				seqToUnseq[nInUse] = (char)i;
+				unseqToSeq[i] = (char)nInUse;
+				nInUse++;
+			}
+		}
+	}
+
+	public CBZip2InputStream(Stream zStream)
+	{
+		ll8 = null;
+		tt = null;
+		BsSetStream(zStream);
+		Initialize();
+		InitBlock();
+		SetupBlock();
+	}
+
+	internal static int[][] InitIntArray(int n1, int n2)
+	{
+		int[][] array = new int[n1][];
+		for (int i = 0; i < n1; i++)
+		{
+			array[i] = new int[n2];
+		}
+		return array;
+	}
+
+	internal static char[][] InitCharArray(int n1, int n2)
+	{
+		char[][] array = new char[n1][];
+		for (int i = 0; i < n1; i++)
+		{
+			array[i] = new char[n2];
+		}
+		return array;
+	}
+
+	public override int ReadByte()
+	{
+		if (streamEnd)
+		{
+			return -1;
+		}
+		int result = currentChar;
+		switch (currentState)
+		{
+		case 3:
+			SetupRandPartB();
+			break;
+		case 4:
+			SetupRandPartC();
+			break;
+		case 6:
+			SetupNoRandPartB();
+			break;
+		case 7:
+			SetupNoRandPartC();
+			break;
+		}
+		return result;
+	}
+
+	private void Initialize()
+	{
+		char c = BsGetUChar();
+		char c2 = BsGetUChar();
+		if (c != 'B' && c2 != 'Z')
+		{
+			throw new IOException("Not a BZIP2 marked stream");
+		}
+		c = BsGetUChar();
+		c2 = BsGetUChar();
+		if (c != 'h' || c2 < '1' || c2 > '9')
+		{
+			BsFinishedWithStream();
+			streamEnd = true;
+		}
+		else
+		{
+			SetDecompressStructureSizes(c2 - 48);
+			computedCombinedCRC = 0;
+		}
+	}
+
+	private void InitBlock()
+	{
+		char c = BsGetUChar();
+		char c2 = BsGetUChar();
+		char c3 = BsGetUChar();
+		char c4 = BsGetUChar();
+		char c5 = BsGetUChar();
+		char c6 = BsGetUChar();
+		if (c == '\u0017' && c2 == 'r' && c3 == 'E' && c4 == '8' && c5 == 'P' && c6 == '\u0090')
+		{
+			Complete();
+			return;
+		}
+		if (c != '1' || c2 != 'A' || c3 != 'Y' || c4 != '&' || c5 != 'S' || c6 != 'Y')
+		{
+			BadBlockHeader();
+			streamEnd = true;
+			return;
+		}
+		storedBlockCRC = BsGetInt32();
+		if (BsR(1) == 1)
+		{
+			blockRandomised = true;
+		}
+		else
+		{
+			blockRandomised = false;
+		}
+		GetAndMoveToFrontDecode();
+		mCrc.InitialiseCRC();
+		currentState = 1;
+	}
+
+	private void EndBlock()
+	{
+		computedBlockCRC = mCrc.GetFinalCRC();
+		if (storedBlockCRC != computedBlockCRC)
+		{
+			CrcError();
+		}
+		computedCombinedCRC = (computedCombinedCRC << 1) | (computedCombinedCRC >>> 31);
+		computedCombinedCRC ^= computedBlockCRC;
+	}
+
+	private void Complete()
+	{
+		storedCombinedCRC = BsGetInt32();
+		if (storedCombinedCRC != computedCombinedCRC)
+		{
+			CrcError();
+		}
+		BsFinishedWithStream();
+		streamEnd = true;
+	}
+
+	private static void BlockOverrun()
+	{
+		Cadvise();
+	}
+
+	private static void BadBlockHeader()
+	{
+		Cadvise();
+	}
+
+	private static void CrcError()
+	{
+		Cadvise();
+	}
+
+	private void BsFinishedWithStream()
+	{
+		try
+		{
+			if (bsStream != null)
+			{
+				Platform.Dispose(bsStream);
+				bsStream = null;
+			}
+		}
+		catch
+		{
+		}
+	}
+
+	private void BsSetStream(Stream f)
+	{
+		bsStream = f;
+		bsLive = 0;
+		bsBuff = 0;
+	}
+
+	private int BsR(int n)
+	{
+		while (bsLive < n)
+		{
+			char c = '\0';
+			try
+			{
+				c = (char)bsStream.ReadByte();
+			}
+			catch (IOException)
+			{
+				CompressedStreamEOF();
+			}
+			if (c == '\uffff')
+			{
+				CompressedStreamEOF();
+			}
+			int num = c;
+			bsBuff = (bsBuff << 8) | (num & 0xFF);
+			bsLive += 8;
+		}
+		int result = (bsBuff >> bsLive - n) & ((1 << n) - 1);
+		bsLive -= n;
+		return result;
+	}
+
+	private char BsGetUChar()
+	{
+		return (char)BsR(8);
+	}
+
+	private int BsGetint()
+	{
+		int num = 0;
+		num = (num << 8) | BsR(8);
+		num = (num << 8) | BsR(8);
+		num = (num << 8) | BsR(8);
+		return (num << 8) | BsR(8);
+	}
+
+	private int BsGetIntVS(int numBits)
+	{
+		return BsR(numBits);
+	}
+
+	private int BsGetInt32()
+	{
+		return BsGetint();
+	}
+
+	private void HbCreateDecodeTables(int[] limit, int[] basev, int[] perm, char[] length, int minLen, int maxLen, int alphaSize)
+	{
+		int num = 0;
+		for (int i = minLen; i <= maxLen; i++)
+		{
+			for (int j = 0; j < alphaSize; j++)
+			{
+				if (length[j] == i)
+				{
+					perm[num] = j;
+					num++;
+				}
+			}
+		}
+		for (int i = 0; i < 23; i++)
+		{
+			basev[i] = 0;
+		}
+		for (int i = 0; i < alphaSize; i++)
+		{
+			int[] array2;
+			int[] array = (array2 = basev);
+			int num2 = length[i] + 1;
+			nint num3 = num2;
+			array[num2] = array2[num3] + 1;
+		}
+		for (int i = 1; i < 23; i++)
+		{
+			int[] array2;
+			int[] array3 = (array2 = basev);
+			int num4 = i;
+			nint num3 = num4;
+			array3[num4] = array2[num3] + basev[i - 1];
+		}
+		for (int i = 0; i < 23; i++)
+		{
+			limit[i] = 0;
+		}
+		int num5 = 0;
+		for (int i = minLen; i <= maxLen; i++)
+		{
+			num5 += basev[i + 1] - basev[i];
+			limit[i] = num5 - 1;
+			num5 <<= 1;
+		}
+		for (int i = minLen + 1; i <= maxLen; i++)
+		{
+			basev[i] = (limit[i - 1] + 1 << 1) - basev[i];
+		}
+	}
+
+	private void RecvDecodingTables()
+	{
+		char[][] array = InitCharArray(6, 258);
+		bool[] array2 = new bool[16];
+		for (int i = 0; i < 16; i++)
+		{
+			if (BsR(1) == 1)
+			{
+				array2[i] = true;
+			}
+			else
+			{
+				array2[i] = false;
+			}
+		}
+		for (int i = 0; i < 256; i++)
+		{
+			inUse[i] = false;
+		}
+		for (int i = 0; i < 16; i++)
+		{
+			if (!array2[i])
+			{
+				continue;
+			}
+			for (int j = 0; j < 16; j++)
+			{
+				if (BsR(1) == 1)
+				{
+					inUse[i * 16 + j] = true;
+				}
+			}
+		}
+		MakeMaps();
+		int num = nInUse + 2;
+		int num2 = BsR(3);
+		int num3 = BsR(15);
+		for (int i = 0; i < num3; i++)
+		{
+			int j = 0;
+			while (BsR(1) == 1)
+			{
+				j++;
+			}
+			selectorMtf[i] = (char)j;
+		}
+		char[] array3 = new char[6];
+		for (char c = '\0'; c < num2; c = (char)(c + 1))
+		{
+			array3[(uint)c] = c;
+		}
+		for (int i = 0; i < num3; i++)
+		{
+			char c = selectorMtf[i];
+			char c2 = array3[(uint)c];
+			while (c > '\0')
+			{
+				array3[(uint)c] = array3[c - 1];
+				c = (char)(c - 1);
+			}
+			array3[0] = c2;
+			selector[i] = c2;
+		}
+		for (int k = 0; k < num2; k++)
+		{
+			int num4 = BsR(5);
+			for (int i = 0; i < num; i++)
+			{
+				while (BsR(1) == 1)
+				{
+					num4 = ((BsR(1) != 0) ? (num4 - 1) : (num4 + 1));
+				}
+				array[k][i] = (char)num4;
+			}
+		}
+		for (int k = 0; k < num2; k++)
+		{
+			int num5 = 32;
+			int num6 = 0;
+			for (int i = 0; i < num; i++)
+			{
+				if (array[k][i] > num6)
+				{
+					num6 = array[k][i];
+				}
+				if (array[k][i] < num5)
+				{
+					num5 = array[k][i];
+				}
+			}
+			HbCreateDecodeTables(limit[k], basev[k], perm[k], array[k], num5, num6, num);
+			minLens[k] = num5;
+		}
+	}
+
+	private void GetAndMoveToFrontDecode()
+	{
+		char[] array = new char[256];
+		int num = 100000 * blockSize100k;
+		origPtr = BsGetIntVS(24);
+		RecvDecodingTables();
+		int num2 = nInUse + 1;
+		int num3 = -1;
+		int num4 = 0;
+		for (int i = 0; i <= 255; i++)
+		{
+			unzftab[i] = 0;
+		}
+		for (int i = 0; i <= 255; i++)
+		{
+			array[i] = (char)i;
+		}
+		last = -1;
+		if (num4 == 0)
+		{
+			num3++;
+			num4 = 50;
+		}
+		num4--;
+		int num5 = selector[num3];
+		int num6 = minLens[num5];
+		int num7 = BsR(num6);
+		while (num7 > limit[num5][num6])
+		{
+			num6++;
+			while (bsLive < 1)
+			{
+				char c = '\0';
+				try
+				{
+					c = (char)bsStream.ReadByte();
+				}
+				catch (IOException)
+				{
+					CompressedStreamEOF();
+				}
+				if (c == '\uffff')
+				{
+					CompressedStreamEOF();
+				}
+				int num8 = c;
+				bsBuff = (bsBuff << 8) | (num8 & 0xFF);
+				bsLive += 8;
+			}
+			int num9 = (bsBuff >> bsLive - 1) & 1;
+			bsLive--;
+			num7 = (num7 << 1) | num9;
+		}
+		int num10 = perm[num5][num7 - basev[num5][num6]];
+		while (num10 != num2)
+		{
+			int[] array3;
+			nint num18;
+			if (num10 == 0 || num10 == 1)
+			{
+				int num11 = -1;
+				int num12 = 1;
+				do
+				{
+					switch (num10)
+					{
+					case 0:
+						num11 += num12;
+						break;
+					case 1:
+						num11 += 2 * num12;
+						break;
+					}
+					num12 *= 2;
+					if (num4 == 0)
+					{
+						num3++;
+						num4 = 50;
+					}
+					num4--;
+					int num13 = selector[num3];
+					int num14 = minLens[num13];
+					int num15 = BsR(num14);
+					while (num15 > limit[num13][num14])
+					{
+						num14++;
+						while (bsLive < 1)
+						{
+							char c2 = '\0';
+							try
+							{
+								c2 = (char)bsStream.ReadByte();
+							}
+							catch (IOException)
+							{
+								CompressedStreamEOF();
+							}
+							if (c2 == '\uffff')
+							{
+								CompressedStreamEOF();
+							}
+							int num16 = c2;
+							bsBuff = (bsBuff << 8) | (num16 & 0xFF);
+							bsLive += 8;
+						}
+						int num17 = (bsBuff >> bsLive - 1) & 1;
+						bsLive--;
+						num15 = (num15 << 1) | num17;
+					}
+					num10 = perm[num13][num15 - basev[num13][num14]];
+				}
+				while (num10 == 0 || num10 == 1);
+				num11++;
+				char c3 = seqToUnseq[(uint)array[0]];
+				int[] array2 = (array3 = unzftab);
+				num18 = (int)c3;
+				array2[(uint)c3] = array3[num18] + num11;
+				while (num11 > 0)
+				{
+					last++;
+					ll8[last] = c3;
+					num11--;
+				}
+				if (last >= num)
+				{
+					BlockOverrun();
+				}
+				continue;
+			}
+			last++;
+			if (last >= num)
+			{
+				BlockOverrun();
+			}
+			char c4 = array[num10 - 1];
+			int[] array4 = (array3 = unzftab);
+			char num19 = seqToUnseq[(uint)c4];
+			num18 = (int)num19;
+			array4[(uint)num19] = array3[num18] + 1;
+			ll8[last] = seqToUnseq[(uint)c4];
+			int num20;
+			for (num20 = num10 - 1; num20 > 3; num20 -= 4)
+			{
+				array[num20] = array[num20 - 1];
+				array[num20 - 1] = array[num20 - 2];
+				array[num20 - 2] = array[num20 - 3];
+				array[num20 - 3] = array[num20 - 4];
+			}
+			while (num20 > 0)
+			{
+				array[num20] = array[num20 - 1];
+				num20--;
+			}
+			array[0] = c4;
+			if (num4 == 0)
+			{
+				num3++;
+				num4 = 50;
+			}
+			num4--;
+			int num21 = selector[num3];
+			int num22 = minLens[num21];
+			int num23 = BsR(num22);
+			while (num23 > limit[num21][num22])
+			{
+				num22++;
+				while (bsLive < 1)
+				{
+					char c5 = '\0';
+					try
+					{
+						c5 = (char)bsStream.ReadByte();
+					}
+					catch (IOException)
+					{
+						CompressedStreamEOF();
+					}
+					int num24 = c5;
+					bsBuff = (bsBuff << 8) | (num24 & 0xFF);
+					bsLive += 8;
+				}
+				int num25 = (bsBuff >> bsLive - 1) & 1;
+				bsLive--;
+				num23 = (num23 << 1) | num25;
+			}
+			num10 = perm[num21][num23 - basev[num21][num22]];
+		}
+	}
+
+	private void SetupBlock()
+	{
+		int[] array = new int[257];
+		array[0] = 0;
+		for (i = 1; i <= 256; i++)
+		{
+			array[i] = unzftab[i - 1];
+		}
+		for (i = 1; i <= 256; i++)
+		{
+			int[] array3;
+			int[] array2 = (array3 = array);
+			int num = i;
+			nint num2 = num;
+			array2[num] = array3[num2] + array[i - 1];
+		}
+		for (i = 0; i <= last; i++)
+		{
+			char c = ll8[i];
+			tt[array[(uint)c]] = i;
+			int[] array3;
+			int[] array4 = (array3 = array);
+			nint num2 = (int)c;
+			array4[(uint)c] = array3[num2] + 1;
+		}
+		array = null;
+		tPos = tt[origPtr];
+		count = 0;
+		i2 = 0;
+		ch2 = 256;
+		if (blockRandomised)
+		{
+			rNToGo = 0;
+			rTPos = 0;
+			SetupRandPartA();
+		}
+		else
+		{
+			SetupNoRandPartA();
+		}
+	}
+
+	private void SetupRandPartA()
+	{
+		if (i2 <= last)
+		{
+			chPrev = ch2;
+			ch2 = ll8[tPos];
+			tPos = tt[tPos];
+			if (rNToGo == 0)
+			{
+				rNToGo = BZip2Constants.rNums[rTPos];
+				rTPos++;
+				if (rTPos == 512)
+				{
+					rTPos = 0;
+				}
+			}
+			rNToGo--;
+			ch2 ^= ((rNToGo == 1) ? 1 : 0);
+			i2++;
+			currentChar = ch2;
+			currentState = 3;
+			mCrc.UpdateCRC(ch2);
+		}
+		else
+		{
+			EndBlock();
+			InitBlock();
+			SetupBlock();
+		}
+	}
+
+	private void SetupNoRandPartA()
+	{
+		if (i2 <= last)
+		{
+			chPrev = ch2;
+			ch2 = ll8[tPos];
+			tPos = tt[tPos];
+			i2++;
+			currentChar = ch2;
+			currentState = 6;
+			mCrc.UpdateCRC(ch2);
+		}
+		else
+		{
+			EndBlock();
+			InitBlock();
+			SetupBlock();
+		}
+	}
+
+	private void SetupRandPartB()
+	{
+		if (ch2 != chPrev)
+		{
+			currentState = 2;
+			count = 1;
+			SetupRandPartA();
+			return;
+		}
+		count++;
+		if (count >= 4)
+		{
+			z = ll8[tPos];
+			tPos = tt[tPos];
+			if (rNToGo == 0)
+			{
+				rNToGo = BZip2Constants.rNums[rTPos];
+				rTPos++;
+				if (rTPos == 512)
+				{
+					rTPos = 0;
+				}
+			}
+			rNToGo--;
+			z ^= ((rNToGo == 1) ? '\u0001' : '\0');
+			j2 = 0;
+			currentState = 4;
+			SetupRandPartC();
+		}
+		else
+		{
+			currentState = 2;
+			SetupRandPartA();
+		}
+	}
+
+	private void SetupRandPartC()
+	{
+		if (j2 < z)
+		{
+			currentChar = ch2;
+			mCrc.UpdateCRC(ch2);
+			j2++;
+		}
+		else
+		{
+			currentState = 2;
+			i2++;
+			count = 0;
+			SetupRandPartA();
+		}
+	}
+
+	private void SetupNoRandPartB()
+	{
+		if (ch2 != chPrev)
+		{
+			currentState = 5;
+			count = 1;
+			SetupNoRandPartA();
+			return;
+		}
+		count++;
+		if (count >= 4)
+		{
+			z = ll8[tPos];
+			tPos = tt[tPos];
+			currentState = 7;
+			j2 = 0;
+			SetupNoRandPartC();
+		}
+		else
+		{
+			currentState = 5;
+			SetupNoRandPartA();
+		}
+	}
+
+	private void SetupNoRandPartC()
+	{
+		if (j2 < z)
+		{
+			currentChar = ch2;
+			mCrc.UpdateCRC(ch2);
+			j2++;
+		}
+		else
+		{
+			currentState = 5;
+			i2++;
+			count = 0;
+			SetupNoRandPartA();
+		}
+	}
+
+	private void SetDecompressStructureSizes(int newSize100k)
+	{
+		if (0 <= newSize100k && newSize100k <= 9 && 0 <= blockSize100k)
+		{
+			_ = blockSize100k;
+			_ = 9;
+		}
+		blockSize100k = newSize100k;
+		if (newSize100k != 0)
+		{
+			int num = 100000 * newSize100k;
+			ll8 = new char[num];
+			tt = new int[num];
+		}
+	}
+
+	public override void Flush()
+	{
+	}
+
+	public override int Read(byte[] buffer, int offset, int count)
+	{
+		int num = -1;
+		int i;
+		for (i = 0; i < count; i++)
+		{
+			num = ReadByte();
+			if (num == -1)
+			{
+				break;
+			}
+			buffer[i + offset] = (byte)num;
+		}
+		return i;
+	}
+
+	public override long Seek(long offset, SeekOrigin origin)
+	{
+		return 0L;
+	}
+
+	public override void SetLength(long value)
+	{
+	}
+
+	public override void Write(byte[] buffer, int offset, int count)
+	{
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Apache/Bzip2/CRC.cs

@@ -0,0 +1,71 @@
+namespace Org.BouncyCastle.Apache.Bzip2;
+
+internal class CRC
+{
+	public static readonly int[] crc32Table = new int[256]
+	{
+		0, 79764919, 159529838, 222504665, 319059676, 398814059, 445009330, 507990021, 638119352, 583659535,
+		797628118, 726387553, 890018660, 835552979, 1015980042, 944750013, 1276238704, 1221641927, 1167319070, 1095957929,
+		1595256236, 1540665371, 1452775106, 1381403509, 1780037320, 1859660671, 1671105958, 1733955601, 2031960084, 2111593891,
+		1889500026, 1952343757, -1742489888, -1662866601, -1851683442, -1788833735, -1960329156, -1880695413, -2103051438, -2040207643,
+		-1104454824, -1159051537, -1213636554, -1284997759, -1389417084, -1444007885, -1532160278, -1603531939, -734892656, -789352409,
+		-575645954, -646886583, -952755380, -1007220997, -827056094, -898286187, -231047128, -151282273, -71779514, -8804623,
+		-515967244, -436212925, -390279782, -327299027, 881225847, 809987520, 1023691545, 969234094, 662832811, 591600412,
+		771767749, 717299826, 311336399, 374308984, 453813921, 533576470, 25881363, 88864420, 134795389, 214552010,
+		2023205639, 2086057648, 1897238633, 1976864222, 1804852699, 1867694188, 1645340341, 1724971778, 1587496639, 1516133128,
+		1461550545, 1406951526, 1302016099, 1230646740, 1142491917, 1087903418, -1398421865, -1469785312, -1524105735, -1578704818,
+		-1079922613, -1151291908, -1239184603, -1293773166, -1968362705, -1905510760, -2094067647, -2014441994, -1716953613, -1654112188,
+		-1876203875, -1796572374, -525066777, -462094256, -382327159, -302564546, -206542021, -143559028, -97365931, -17609246,
+		-960696225, -1031934488, -817968335, -872425850, -709327229, -780559564, -600130067, -654598054, 1762451694, 1842216281,
+		1619975040, 1682949687, 2047383090, 2127137669, 1938468188, 2001449195, 1325665622, 1271206113, 1183200824, 1111960463,
+		1543535498, 1489069629, 1434599652, 1363369299, 622672798, 568075817, 748617968, 677256519, 907627842, 853037301,
+		1067152940, 995781531, 51762726, 131386257, 177728840, 240578815, 269590778, 349224269, 429104020, 491947555,
+		-248556018, -168932423, -122852000, -60002089, -500490030, -420856475, -341238852, -278395381, -685261898, -739858943,
+		-559578920, -630940305, -1004286614, -1058877219, -845023740, -916395085, -1119974018, -1174433591, -1262701040, -1333941337,
+		-1371866206, -1426332139, -1481064244, -1552294533, -1690935098, -1611170447, -1833673816, -1770699233, -2009983462, -1930228819,
+		-2119160460, -2056179517, 1569362073, 1498123566, 1409854455, 1355396672, 1317987909, 1246755826, 1192025387, 1137557660,
+		2072149281, 2135122070, 1912620623, 1992383480, 1753615357, 1816598090, 1627664531, 1707420964, 295390185, 358241886,
+		404320391, 483945776, 43990325, 106832002, 186451547, 266083308, 932423249, 861060070, 1041341759, 986742920,
+		613929101, 542559546, 756411363, 701822548, -978770311, -1050133554, -869589737, -924188512, -693284699, -764654318,
+		-550540341, -605129092, -475935807, -413084042, -366743377, -287118056, -257573603, -194731862, -114850189, -35218492,
+		-1984365303, -1921392450, -2143631769, -2063868976, -1698919467, -1635936670, -1824608069, -1744851700, -1347415887, -1418654458,
+		-1506661409, -1561119128, -1129027987, -1200260134, -1254728445, -1309196108
+	};
+
+	internal int globalCrc;
+
+	public CRC()
+	{
+		InitialiseCRC();
+	}
+
+	internal void InitialiseCRC()
+	{
+		globalCrc = -1;
+	}
+
+	internal int GetFinalCRC()
+	{
+		return ~globalCrc;
+	}
+
+	internal int GetGlobalCRC()
+	{
+		return globalCrc;
+	}
+
+	internal void SetGlobalCRC(int newCrc)
+	{
+		globalCrc = newCrc;
+	}
+
+	internal void UpdateCRC(int inCh)
+	{
+		int num = (globalCrc >> 24) ^ inCh;
+		if (num < 0)
+		{
+			num = 256 + num;
+		}
+		globalCrc = (globalCrc << 8) ^ crc32Table[num];
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Anssi/AnssiNamedCurves.cs

@@ -0,0 +1,92 @@
+using System.Collections;
+using Org.BouncyCastle.Asn1.X9;
+using Org.BouncyCastle.Math;
+using Org.BouncyCastle.Math.EC;
+using Org.BouncyCastle.Utilities;
+using Org.BouncyCastle.Utilities.Collections;
+using Org.BouncyCastle.Utilities.Encoders;
+
+namespace Org.BouncyCastle.Asn1.Anssi;
+
+public class AnssiNamedCurves
+{
+	internal class Frp256v1Holder : X9ECParametersHolder
+	{
+		internal static readonly X9ECParametersHolder Instance = new Frp256v1Holder();
+
+		private Frp256v1Holder()
+		{
+		}
+
+		protected override X9ECParameters CreateParameters()
+		{
+			BigInteger q = FromHex("F1FD178C0B3AD58F10126DE8CE42435B3961ADBCABC8CA6DE8FCF353D86E9C03");
+			BigInteger a = FromHex("F1FD178C0B3AD58F10126DE8CE42435B3961ADBCABC8CA6DE8FCF353D86E9C00");
+			BigInteger b = FromHex("EE353FCA5428A9300D4ABA754A44C00FDFEC0C9AE4B1A1803075ED967B7BB73F");
+			byte[] seed = null;
+			BigInteger bigInteger = FromHex("F1FD178C0B3AD58F10126DE8CE42435B53DC67E140D2BF941FFDD459C6D655E1");
+			BigInteger one = BigInteger.One;
+			ECCurve eCCurve = ConfigureCurve(new FpCurve(q, a, b, bigInteger, one));
+			X9ECPoint g = new X9ECPoint(eCCurve, Hex.Decode("04B6B3D4C356C139EB31183D4749D423958C27D2DCAF98B70164C97A2DD98F5CFF6142E0F7C8B204911F9271F0F3ECEF8C2701C307E8E4C9E183115A1554062CFB"));
+			return new X9ECParameters(eCCurve, g, bigInteger, one, seed);
+		}
+	}
+
+	private static readonly IDictionary objIds;
+
+	private static readonly IDictionary curves;
+
+	private static readonly IDictionary names;
+
+	public static IEnumerable Names => new EnumerableProxy(names.Values);
+
+	private static ECCurve ConfigureCurve(ECCurve curve)
+	{
+		return curve;
+	}
+
+	private static BigInteger FromHex(string hex)
+	{
+		return new BigInteger(1, Hex.Decode(hex));
+	}
+
+	private static void DefineCurve(string name, DerObjectIdentifier oid, X9ECParametersHolder holder)
+	{
+		objIds.Add(Platform.ToUpperInvariant(name), oid);
+		names.Add(oid, name);
+		curves.Add(oid, holder);
+	}
+
+	static AnssiNamedCurves()
+	{
+		objIds = Platform.CreateHashtable();
+		curves = Platform.CreateHashtable();
+		names = Platform.CreateHashtable();
+		DefineCurve("FRP256v1", AnssiObjectIdentifiers.FRP256v1, Frp256v1Holder.Instance);
+	}
+
+	public static X9ECParameters GetByName(string name)
+	{
+		DerObjectIdentifier oid = GetOid(name);
+		if (oid != null)
+		{
+			return GetByOid(oid);
+		}
+		return null;
+	}
+
+	public static X9ECParameters GetByOid(DerObjectIdentifier oid)
+	{
+		return ((X9ECParametersHolder)curves[oid])?.Parameters;
+	}
+
+	public static DerObjectIdentifier GetOid(string name)
+	{
+		return (DerObjectIdentifier)objIds[Platform.ToUpperInvariant(name)];
+	}
+
+	public static string GetName(DerObjectIdentifier oid)
+	{
+		return (string)names[oid];
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Anssi/AnssiObjectIdentifiers.cs

@@ -0,0 +1,10 @@
+namespace Org.BouncyCastle.Asn1.Anssi;
+
+public sealed class AnssiObjectIdentifiers
+{
+	public static readonly DerObjectIdentifier FRP256v1 = new DerObjectIdentifier("1.2.250.1.223.101.256.1");
+
+	private AnssiObjectIdentifiers()
+	{
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Asn1Encodable.cs

@@ -0,0 +1,68 @@
+using System.IO;
+
+namespace Org.BouncyCastle.Asn1;
+
+public abstract class Asn1Encodable : IAsn1Convertible
+{
+	public const string Der = "DER";
+
+	public const string Ber = "BER";
+
+	public byte[] GetEncoded()
+	{
+		MemoryStream memoryStream = new MemoryStream();
+		Asn1OutputStream asn1OutputStream = new Asn1OutputStream(memoryStream);
+		asn1OutputStream.WriteObject(this);
+		return memoryStream.ToArray();
+	}
+
+	public byte[] GetEncoded(string encoding)
+	{
+		if (encoding.Equals("DER"))
+		{
+			MemoryStream memoryStream = new MemoryStream();
+			DerOutputStream derOutputStream = new DerOutputStream(memoryStream);
+			derOutputStream.WriteObject(this);
+			return memoryStream.ToArray();
+		}
+		return GetEncoded();
+	}
+
+	public byte[] GetDerEncoded()
+	{
+		try
+		{
+			return GetEncoded("DER");
+		}
+		catch (IOException)
+		{
+			return null;
+		}
+	}
+
+	public sealed override int GetHashCode()
+	{
+		return ToAsn1Object().CallAsn1GetHashCode();
+	}
+
+	public sealed override bool Equals(object obj)
+	{
+		if (obj == this)
+		{
+			return true;
+		}
+		if (!(obj is IAsn1Convertible asn1Convertible))
+		{
+			return false;
+		}
+		Asn1Object asn1Object = ToAsn1Object();
+		Asn1Object asn1Object2 = asn1Convertible.ToAsn1Object();
+		if (asn1Object != asn1Object2)
+		{
+			return asn1Object.CallAsn1Equals(asn1Object2);
+		}
+		return true;
+	}
+
+	public abstract Asn1Object ToAsn1Object();
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Asn1EncodableVector.cs

@@ -0,0 +1,66 @@
+using System;
+using System.Collections;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1;
+
+public class Asn1EncodableVector : IEnumerable
+{
+	private IList v = Platform.CreateArrayList();
+
+	public Asn1Encodable this[int index] => (Asn1Encodable)v[index];
+
+	[Obsolete("Use 'Count' property instead")]
+	public int Size => v.Count;
+
+	public int Count => v.Count;
+
+	public static Asn1EncodableVector FromEnumerable(IEnumerable e)
+	{
+		Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector();
+		foreach (Asn1Encodable item in e)
+		{
+			asn1EncodableVector.Add(item);
+		}
+		return asn1EncodableVector;
+	}
+
+	public Asn1EncodableVector(params Asn1Encodable[] v)
+	{
+		Add(v);
+	}
+
+	public void Add(params Asn1Encodable[] objs)
+	{
+		foreach (Asn1Encodable value in objs)
+		{
+			v.Add(value);
+		}
+	}
+
+	public void AddOptional(params Asn1Encodable[] objs)
+	{
+		if (objs == null)
+		{
+			return;
+		}
+		foreach (Asn1Encodable asn1Encodable in objs)
+		{
+			if (asn1Encodable != null)
+			{
+				v.Add(asn1Encodable);
+			}
+		}
+	}
+
+	[Obsolete("Use 'object[index]' syntax instead")]
+	public Asn1Encodable Get(int index)
+	{
+		return this[index];
+	}
+
+	public IEnumerator GetEnumerator()
+	{
+		return v.GetEnumerator();
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Asn1Exception.cs

@@ -0,0 +1,22 @@
+using System;
+using System.IO;
+
+namespace Org.BouncyCastle.Asn1;
+
+[Serializable]
+public class Asn1Exception : IOException
+{
+	public Asn1Exception()
+	{
+	}
+
+	public Asn1Exception(string message)
+		: base(message)
+	{
+	}
+
+	public Asn1Exception(string message, Exception exception)
+		: base(message, exception)
+	{
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Asn1Generator.cs

@@ -0,0 +1,21 @@
+using System.IO;
+
+namespace Org.BouncyCastle.Asn1;
+
+public abstract class Asn1Generator
+{
+	private Stream _out;
+
+	protected Stream Out => _out;
+
+	protected Asn1Generator(Stream outStream)
+	{
+		_out = outStream;
+	}
+
+	public abstract void AddObject(Asn1Encodable obj);
+
+	public abstract Stream GetRawOutputStream();
+
+	public abstract void Close();
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Asn1InputStream.cs

@@ -0,0 +1,264 @@
+using System;
+using System.IO;
+using Org.BouncyCastle.Utilities.IO;
+
+namespace Org.BouncyCastle.Asn1;
+
+public class Asn1InputStream : FilterStream
+{
+	private readonly int limit;
+
+	private readonly byte[][] tmpBuffers;
+
+	internal static int FindLimit(Stream input)
+	{
+		if (input is LimitedInputStream)
+		{
+			return ((LimitedInputStream)input).GetRemaining();
+		}
+		if (input is MemoryStream)
+		{
+			MemoryStream memoryStream = (MemoryStream)input;
+			return (int)(memoryStream.Length - memoryStream.Position);
+		}
+		return int.MaxValue;
+	}
+
+	public Asn1InputStream(Stream inputStream)
+		: this(inputStream, FindLimit(inputStream))
+	{
+	}
+
+	public Asn1InputStream(Stream inputStream, int limit)
+		: base(inputStream)
+	{
+		this.limit = limit;
+		tmpBuffers = new byte[16][];
+	}
+
+	public Asn1InputStream(byte[] input)
+		: this(new MemoryStream(input, writable: false), input.Length)
+	{
+	}
+
+	private Asn1Object BuildObject(int tag, int tagNo, int length)
+	{
+		bool flag = (tag & 0x20) != 0;
+		DefiniteLengthInputStream definiteLengthInputStream = new DefiniteLengthInputStream(s, length);
+		if ((tag & 0x40) != 0)
+		{
+			return new DerApplicationSpecific(flag, tagNo, definiteLengthInputStream.ToArray());
+		}
+		if ((tag & 0x80) != 0)
+		{
+			return new Asn1StreamParser(definiteLengthInputStream).ReadTaggedObject(flag, tagNo);
+		}
+		if (flag)
+		{
+			return tagNo switch
+			{
+				4 => new BerOctetString(BuildDerEncodableVector(definiteLengthInputStream)), 
+				16 => CreateDerSequence(definiteLengthInputStream), 
+				17 => CreateDerSet(definiteLengthInputStream), 
+				8 => new DerExternal(BuildDerEncodableVector(definiteLengthInputStream)), 
+				_ => throw new IOException("unknown tag " + tagNo + " encountered"), 
+			};
+		}
+		return CreatePrimitiveDerObject(tagNo, definiteLengthInputStream, tmpBuffers);
+	}
+
+	internal Asn1EncodableVector BuildEncodableVector()
+	{
+		Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector();
+		Asn1Object asn1Object;
+		while ((asn1Object = ReadObject()) != null)
+		{
+			asn1EncodableVector.Add(asn1Object);
+		}
+		return asn1EncodableVector;
+	}
+
+	internal virtual Asn1EncodableVector BuildDerEncodableVector(DefiniteLengthInputStream dIn)
+	{
+		return new Asn1InputStream(dIn).BuildEncodableVector();
+	}
+
+	internal virtual DerSequence CreateDerSequence(DefiniteLengthInputStream dIn)
+	{
+		return DerSequence.FromVector(BuildDerEncodableVector(dIn));
+	}
+
+	internal virtual DerSet CreateDerSet(DefiniteLengthInputStream dIn)
+	{
+		return DerSet.FromVector(BuildDerEncodableVector(dIn), needsSorting: false);
+	}
+
+	public Asn1Object ReadObject()
+	{
+		int num = ReadByte();
+		if (num <= 0)
+		{
+			if (num == 0)
+			{
+				throw new IOException("unexpected end-of-contents marker");
+			}
+			return null;
+		}
+		int num2 = ReadTagNumber(s, num);
+		bool flag = (num & 0x20) != 0;
+		int num3 = ReadLength(s, limit);
+		if (num3 < 0)
+		{
+			if (!flag)
+			{
+				throw new IOException("indefinite length primitive encoding encountered");
+			}
+			IndefiniteLengthInputStream inStream = new IndefiniteLengthInputStream(s, limit);
+			Asn1StreamParser parser = new Asn1StreamParser(inStream, limit);
+			if ((num & 0x40) != 0)
+			{
+				return new BerApplicationSpecificParser(num2, parser).ToAsn1Object();
+			}
+			if ((num & 0x80) != 0)
+			{
+				return new BerTaggedObjectParser(constructed: true, num2, parser).ToAsn1Object();
+			}
+			return num2 switch
+			{
+				4 => new BerOctetStringParser(parser).ToAsn1Object(), 
+				16 => new BerSequenceParser(parser).ToAsn1Object(), 
+				17 => new BerSetParser(parser).ToAsn1Object(), 
+				8 => new DerExternalParser(parser).ToAsn1Object(), 
+				_ => throw new IOException("unknown BER object encountered"), 
+			};
+		}
+		try
+		{
+			return BuildObject(num, num2, num3);
+		}
+		catch (ArgumentException exception)
+		{
+			throw new Asn1Exception("corrupted stream detected", exception);
+		}
+	}
+
+	internal static int ReadTagNumber(Stream s, int tag)
+	{
+		int num = tag & 0x1F;
+		if (num == 31)
+		{
+			num = 0;
+			int num2 = s.ReadByte();
+			if ((num2 & 0x7F) == 0)
+			{
+				throw new IOException("Corrupted stream - invalid high tag number found");
+			}
+			while (num2 >= 0 && (num2 & 0x80) != 0)
+			{
+				num |= num2 & 0x7F;
+				num <<= 7;
+				num2 = s.ReadByte();
+			}
+			if (num2 < 0)
+			{
+				throw new EndOfStreamException("EOF found inside tag value.");
+			}
+			num |= num2 & 0x7F;
+		}
+		return num;
+	}
+
+	internal static int ReadLength(Stream s, int limit)
+	{
+		int num = s.ReadByte();
+		if (num < 0)
+		{
+			throw new EndOfStreamException("EOF found when length expected");
+		}
+		if (num == 128)
+		{
+			return -1;
+		}
+		if (num > 127)
+		{
+			int num2 = num & 0x7F;
+			if (num2 > 4)
+			{
+				throw new IOException("DER length more than 4 bytes: " + num2);
+			}
+			num = 0;
+			for (int i = 0; i < num2; i++)
+			{
+				int num3 = s.ReadByte();
+				if (num3 < 0)
+				{
+					throw new EndOfStreamException("EOF found reading length");
+				}
+				num = (num << 8) + num3;
+			}
+			if (num < 0)
+			{
+				throw new IOException("Corrupted stream - negative length found");
+			}
+			if (num >= limit)
+			{
+				throw new IOException("Corrupted stream - out of bounds length found");
+			}
+		}
+		return num;
+	}
+
+	internal static byte[] GetBuffer(DefiniteLengthInputStream defIn, byte[][] tmpBuffers)
+	{
+		int remaining = defIn.GetRemaining();
+		if (remaining >= tmpBuffers.Length)
+		{
+			return defIn.ToArray();
+		}
+		byte[] array = tmpBuffers[remaining];
+		if (array == null)
+		{
+			array = (tmpBuffers[remaining] = new byte[remaining]);
+		}
+		defIn.ReadAllIntoByteArray(array);
+		return array;
+	}
+
+	internal static Asn1Object CreatePrimitiveDerObject(int tagNo, DefiniteLengthInputStream defIn, byte[][] tmpBuffers)
+	{
+		switch (tagNo)
+		{
+		case 1:
+			return DerBoolean.FromOctetString(GetBuffer(defIn, tmpBuffers));
+		case 10:
+			return DerEnumerated.FromOctetString(GetBuffer(defIn, tmpBuffers));
+		case 6:
+			return DerObjectIdentifier.FromOctetString(GetBuffer(defIn, tmpBuffers));
+		default:
+		{
+			byte[] array = defIn.ToArray();
+			return tagNo switch
+			{
+				3 => DerBitString.FromAsn1Octets(array), 
+				30 => new DerBmpString(array), 
+				24 => new DerGeneralizedTime(array), 
+				27 => new DerGeneralString(array), 
+				25 => new DerGraphicString(array), 
+				22 => new DerIA5String(array), 
+				2 => new DerInteger(array), 
+				5 => DerNull.Instance, 
+				18 => new DerNumericString(array), 
+				4 => new DerOctetString(array), 
+				19 => new DerPrintableString(array), 
+				20 => new DerT61String(array), 
+				28 => new DerUniversalString(array), 
+				23 => new DerUtcTime(array), 
+				12 => new DerUtf8String(array), 
+				21 => new DerVideotexString(array), 
+				26 => new DerVisibleString(array), 
+				_ => throw new IOException("unknown tag " + tagNo + " encountered"), 
+			};
+		}
+		}
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Asn1Null.cs

@@ -0,0 +1,13 @@
+namespace Org.BouncyCastle.Asn1;
+
+public abstract class Asn1Null : Asn1Object
+{
+	internal Asn1Null()
+	{
+	}
+
+	public override string ToString()
+	{
+		return "NULL";
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Asn1Object.cs

@@ -0,0 +1,59 @@
+using System;
+using System.IO;
+
+namespace Org.BouncyCastle.Asn1;
+
+public abstract class Asn1Object : Asn1Encodable
+{
+	public static Asn1Object FromByteArray(byte[] data)
+	{
+		try
+		{
+			MemoryStream memoryStream = new MemoryStream(data, writable: false);
+			Asn1InputStream asn1InputStream = new Asn1InputStream(memoryStream, data.Length);
+			Asn1Object result = asn1InputStream.ReadObject();
+			if (memoryStream.Position != memoryStream.Length)
+			{
+				throw new IOException("extra data found after object");
+			}
+			return result;
+		}
+		catch (InvalidCastException)
+		{
+			throw new IOException("cannot recognise object in byte array");
+		}
+	}
+
+	public static Asn1Object FromStream(Stream inStr)
+	{
+		try
+		{
+			return new Asn1InputStream(inStr).ReadObject();
+		}
+		catch (InvalidCastException)
+		{
+			throw new IOException("cannot recognise object in stream");
+		}
+	}
+
+	public sealed override Asn1Object ToAsn1Object()
+	{
+		return this;
+	}
+
+	internal abstract void Encode(DerOutputStream derOut);
+
+	protected abstract bool Asn1Equals(Asn1Object asn1Object);
+
+	protected abstract int Asn1GetHashCode();
+
+	internal bool CallAsn1Equals(Asn1Object obj)
+	{
+		return Asn1Equals(obj);
+	}
+
+	internal int CallAsn1GetHashCode()
+	{
+		return Asn1GetHashCode();
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Asn1OctetString.cs

@@ -0,0 +1,86 @@
+using System;
+using System.IO;
+using Org.BouncyCastle.Utilities;
+using Org.BouncyCastle.Utilities.Encoders;
+
+namespace Org.BouncyCastle.Asn1;
+
+public abstract class Asn1OctetString : Asn1Object, Asn1OctetStringParser, IAsn1Convertible
+{
+	internal byte[] str;
+
+	public Asn1OctetStringParser Parser => this;
+
+	public static Asn1OctetString GetInstance(Asn1TaggedObject obj, bool isExplicit)
+	{
+		Asn1Object asn1Object = obj.GetObject();
+		if (isExplicit || asn1Object is Asn1OctetString)
+		{
+			return GetInstance(asn1Object);
+		}
+		return BerOctetString.FromSequence(Asn1Sequence.GetInstance(asn1Object));
+	}
+
+	public static Asn1OctetString GetInstance(object obj)
+	{
+		if (obj == null || obj is Asn1OctetString)
+		{
+			return (Asn1OctetString)obj;
+		}
+		if (obj is Asn1TaggedObject)
+		{
+			return GetInstance(((Asn1TaggedObject)obj).GetObject());
+		}
+		throw new ArgumentException("illegal object in GetInstance: " + Platform.GetTypeName(obj));
+	}
+
+	internal Asn1OctetString(byte[] str)
+	{
+		if (str == null)
+		{
+			throw new ArgumentNullException("str");
+		}
+		this.str = str;
+	}
+
+	internal Asn1OctetString(Asn1Encodable obj)
+	{
+		try
+		{
+			str = obj.GetEncoded("DER");
+		}
+		catch (IOException ex)
+		{
+			throw new ArgumentException("Error processing object : " + ex.ToString());
+		}
+	}
+
+	public Stream GetOctetStream()
+	{
+		return new MemoryStream(str, writable: false);
+	}
+
+	public virtual byte[] GetOctets()
+	{
+		return str;
+	}
+
+	protected override int Asn1GetHashCode()
+	{
+		return Arrays.GetHashCode(GetOctets());
+	}
+
+	protected override bool Asn1Equals(Asn1Object asn1Object)
+	{
+		if (!(asn1Object is DerOctetString derOctetString))
+		{
+			return false;
+		}
+		return Arrays.AreEqual(GetOctets(), derOctetString.GetOctets());
+	}
+
+	public override string ToString()
+	{
+		return "#" + Hex.ToHexString(str);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Asn1OctetStringParser.cs

@@ -0,0 +1,8 @@
+using System.IO;
+
+namespace Org.BouncyCastle.Asn1;
+
+public interface Asn1OctetStringParser : IAsn1Convertible
+{
+	Stream GetOctetStream();
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Asn1OutputStream.cs

@@ -0,0 +1,33 @@
+using System;
+using System.IO;
+
+namespace Org.BouncyCastle.Asn1;
+
+public class Asn1OutputStream : DerOutputStream
+{
+	public Asn1OutputStream(Stream os)
+		: base(os)
+	{
+	}
+
+	[Obsolete("Use version taking an Asn1Encodable arg instead")]
+	public override void WriteObject(object obj)
+	{
+		if (obj == null)
+		{
+			WriteNull();
+			return;
+		}
+		if (obj is Asn1Object)
+		{
+			((Asn1Object)obj).Encode(this);
+			return;
+		}
+		if (obj is Asn1Encodable)
+		{
+			((Asn1Encodable)obj).ToAsn1Object().Encode(this);
+			return;
+		}
+		throw new IOException("object not Asn1Encodable");
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Asn1ParsingException.cs

@@ -0,0 +1,21 @@
+using System;
+
+namespace Org.BouncyCastle.Asn1;
+
+[Serializable]
+public class Asn1ParsingException : InvalidOperationException
+{
+	public Asn1ParsingException()
+	{
+	}
+
+	public Asn1ParsingException(string message)
+		: base(message)
+	{
+	}
+
+	public Asn1ParsingException(string message, Exception exception)
+		: base(message, exception)
+	{
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Asn1Sequence.cs

@@ -0,0 +1,207 @@
+using System;
+using System.Collections;
+using System.IO;
+using Org.BouncyCastle.Utilities;
+using Org.BouncyCastle.Utilities.Collections;
+
+namespace Org.BouncyCastle.Asn1;
+
+public abstract class Asn1Sequence : Asn1Object, IEnumerable
+{
+	private class Asn1SequenceParserImpl : Asn1SequenceParser, IAsn1Convertible
+	{
+		private readonly Asn1Sequence outer;
+
+		private readonly int max;
+
+		private int index;
+
+		public Asn1SequenceParserImpl(Asn1Sequence outer)
+		{
+			this.outer = outer;
+			max = outer.Count;
+		}
+
+		public IAsn1Convertible ReadObject()
+		{
+			if (index == max)
+			{
+				return null;
+			}
+			Asn1Encodable asn1Encodable = outer[index++];
+			if (asn1Encodable is Asn1Sequence)
+			{
+				return ((Asn1Sequence)asn1Encodable).Parser;
+			}
+			if (asn1Encodable is Asn1Set)
+			{
+				return ((Asn1Set)asn1Encodable).Parser;
+			}
+			return asn1Encodable;
+		}
+
+		public Asn1Object ToAsn1Object()
+		{
+			return outer;
+		}
+	}
+
+	private readonly IList seq;
+
+	public virtual Asn1SequenceParser Parser => new Asn1SequenceParserImpl(this);
+
+	public virtual Asn1Encodable this[int index] => (Asn1Encodable)seq[index];
+
+	[Obsolete("Use 'Count' property instead")]
+	public int Size => Count;
+
+	public virtual int Count => seq.Count;
+
+	public static Asn1Sequence GetInstance(object obj)
+	{
+		if (obj == null || obj is Asn1Sequence)
+		{
+			return (Asn1Sequence)obj;
+		}
+		if (obj is Asn1SequenceParser)
+		{
+			return GetInstance(((Asn1SequenceParser)obj).ToAsn1Object());
+		}
+		if (obj is byte[])
+		{
+			try
+			{
+				return GetInstance(Asn1Object.FromByteArray((byte[])obj));
+			}
+			catch (IOException ex)
+			{
+				throw new ArgumentException("failed to construct sequence from byte[]: " + ex.Message);
+			}
+		}
+		if (obj is Asn1Encodable)
+		{
+			Asn1Object asn1Object = ((Asn1Encodable)obj).ToAsn1Object();
+			if (asn1Object is Asn1Sequence)
+			{
+				return (Asn1Sequence)asn1Object;
+			}
+		}
+		throw new ArgumentException("Unknown object in GetInstance: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public static Asn1Sequence GetInstance(Asn1TaggedObject obj, bool explicitly)
+	{
+		Asn1Object asn1Object = obj.GetObject();
+		if (explicitly)
+		{
+			if (!obj.IsExplicit())
+			{
+				throw new ArgumentException("object implicit - explicit expected.");
+			}
+			return (Asn1Sequence)asn1Object;
+		}
+		if (obj.IsExplicit())
+		{
+			if (obj is BerTaggedObject)
+			{
+				return new BerSequence(asn1Object);
+			}
+			return new DerSequence(asn1Object);
+		}
+		if (asn1Object is Asn1Sequence)
+		{
+			return (Asn1Sequence)asn1Object;
+		}
+		throw new ArgumentException("Unknown object in GetInstance: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	protected internal Asn1Sequence(int capacity)
+	{
+		seq = Platform.CreateArrayList(capacity);
+	}
+
+	public virtual IEnumerator GetEnumerator()
+	{
+		return seq.GetEnumerator();
+	}
+
+	[Obsolete("Use GetEnumerator() instead")]
+	public IEnumerator GetObjects()
+	{
+		return GetEnumerator();
+	}
+
+	[Obsolete("Use 'object[index]' syntax instead")]
+	public Asn1Encodable GetObjectAt(int index)
+	{
+		return this[index];
+	}
+
+	protected override int Asn1GetHashCode()
+	{
+		int num = Count;
+		IEnumerator enumerator = GetEnumerator();
+		try
+		{
+			while (enumerator.MoveNext())
+			{
+				object current = enumerator.Current;
+				num *= 17;
+				num = ((current != null) ? (num ^ current.GetHashCode()) : (num ^ DerNull.Instance.GetHashCode()));
+			}
+			return num;
+		}
+		finally
+		{
+			IDisposable disposable = enumerator as IDisposable;
+			if (disposable != null)
+			{
+				disposable.Dispose();
+			}
+		}
+	}
+
+	protected override bool Asn1Equals(Asn1Object asn1Object)
+	{
+		if (!(asn1Object is Asn1Sequence asn1Sequence))
+		{
+			return false;
+		}
+		if (Count != asn1Sequence.Count)
+		{
+			return false;
+		}
+		IEnumerator enumerator = GetEnumerator();
+		IEnumerator enumerator2 = asn1Sequence.GetEnumerator();
+		while (enumerator.MoveNext() && enumerator2.MoveNext())
+		{
+			Asn1Object asn1Object2 = GetCurrent(enumerator).ToAsn1Object();
+			Asn1Object obj = GetCurrent(enumerator2).ToAsn1Object();
+			if (!asn1Object2.Equals(obj))
+			{
+				return false;
+			}
+		}
+		return true;
+	}
+
+	private Asn1Encodable GetCurrent(IEnumerator e)
+	{
+		Asn1Encodable asn1Encodable = (Asn1Encodable)e.Current;
+		if (asn1Encodable == null)
+		{
+			return DerNull.Instance;
+		}
+		return asn1Encodable;
+	}
+
+	protected internal void AddObject(Asn1Encodable obj)
+	{
+		seq.Add(obj);
+	}
+
+	public override string ToString()
+	{
+		return CollectionUtilities.ToString(seq);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Asn1SequenceParser.cs

@@ -0,0 +1,6 @@
+namespace Org.BouncyCastle.Asn1;
+
+public interface Asn1SequenceParser : IAsn1Convertible
+{
+	IAsn1Convertible ReadObject();
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Asn1Set.cs

@@ -0,0 +1,293 @@
+using System;
+using System.Collections;
+using System.IO;
+using Org.BouncyCastle.Utilities;
+using Org.BouncyCastle.Utilities.Collections;
+
+namespace Org.BouncyCastle.Asn1;
+
+public abstract class Asn1Set : Asn1Object, IEnumerable
+{
+	private class Asn1SetParserImpl : Asn1SetParser, IAsn1Convertible
+	{
+		private readonly Asn1Set outer;
+
+		private readonly int max;
+
+		private int index;
+
+		public Asn1SetParserImpl(Asn1Set outer)
+		{
+			this.outer = outer;
+			max = outer.Count;
+		}
+
+		public IAsn1Convertible ReadObject()
+		{
+			if (index == max)
+			{
+				return null;
+			}
+			Asn1Encodable asn1Encodable = outer[index++];
+			if (asn1Encodable is Asn1Sequence)
+			{
+				return ((Asn1Sequence)asn1Encodable).Parser;
+			}
+			if (asn1Encodable is Asn1Set)
+			{
+				return ((Asn1Set)asn1Encodable).Parser;
+			}
+			return asn1Encodable;
+		}
+
+		public virtual Asn1Object ToAsn1Object()
+		{
+			return outer;
+		}
+	}
+
+	private class DerComparer : IComparer
+	{
+		public int Compare(object x, object y)
+		{
+			byte[] array = (byte[])x;
+			byte[] array2 = (byte[])y;
+			int num = System.Math.Min(array.Length, array2.Length);
+			for (int i = 0; i != num; i++)
+			{
+				byte b = array[i];
+				byte b2 = array2[i];
+				if (b != b2)
+				{
+					if (b >= b2)
+					{
+						return 1;
+					}
+					return -1;
+				}
+			}
+			if (array.Length > array2.Length)
+			{
+				if (!AllZeroesFrom(array, num))
+				{
+					return 1;
+				}
+				return 0;
+			}
+			if (array.Length < array2.Length)
+			{
+				if (!AllZeroesFrom(array2, num))
+				{
+					return -1;
+				}
+				return 0;
+			}
+			return 0;
+		}
+
+		private bool AllZeroesFrom(byte[] bs, int pos)
+		{
+			while (pos < bs.Length)
+			{
+				if (bs[pos++] != 0)
+				{
+					return false;
+				}
+			}
+			return true;
+		}
+	}
+
+	private readonly IList _set;
+
+	public virtual Asn1Encodable this[int index] => (Asn1Encodable)_set[index];
+
+	[Obsolete("Use 'Count' property instead")]
+	public int Size => Count;
+
+	public virtual int Count => _set.Count;
+
+	public Asn1SetParser Parser => new Asn1SetParserImpl(this);
+
+	public static Asn1Set GetInstance(object obj)
+	{
+		if (obj == null || obj is Asn1Set)
+		{
+			return (Asn1Set)obj;
+		}
+		if (obj is Asn1SetParser)
+		{
+			return GetInstance(((Asn1SetParser)obj).ToAsn1Object());
+		}
+		if (obj is byte[])
+		{
+			try
+			{
+				return GetInstance(Asn1Object.FromByteArray((byte[])obj));
+			}
+			catch (IOException ex)
+			{
+				throw new ArgumentException("failed to construct set from byte[]: " + ex.Message);
+			}
+		}
+		if (obj is Asn1Encodable)
+		{
+			Asn1Object asn1Object = ((Asn1Encodable)obj).ToAsn1Object();
+			if (asn1Object is Asn1Set)
+			{
+				return (Asn1Set)asn1Object;
+			}
+		}
+		throw new ArgumentException("Unknown object in GetInstance: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public static Asn1Set GetInstance(Asn1TaggedObject obj, bool explicitly)
+	{
+		Asn1Object asn1Object = obj.GetObject();
+		if (explicitly)
+		{
+			if (!obj.IsExplicit())
+			{
+				throw new ArgumentException("object implicit - explicit expected.");
+			}
+			return (Asn1Set)asn1Object;
+		}
+		if (obj.IsExplicit())
+		{
+			return new DerSet(asn1Object);
+		}
+		if (asn1Object is Asn1Set)
+		{
+			return (Asn1Set)asn1Object;
+		}
+		if (asn1Object is Asn1Sequence)
+		{
+			Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector();
+			Asn1Sequence asn1Sequence = (Asn1Sequence)asn1Object;
+			foreach (Asn1Encodable item in asn1Sequence)
+			{
+				asn1EncodableVector.Add(item);
+			}
+			return new DerSet(asn1EncodableVector, needsSorting: false);
+		}
+		throw new ArgumentException("Unknown object in GetInstance: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	protected internal Asn1Set(int capacity)
+	{
+		_set = Platform.CreateArrayList(capacity);
+	}
+
+	public virtual IEnumerator GetEnumerator()
+	{
+		return _set.GetEnumerator();
+	}
+
+	[Obsolete("Use GetEnumerator() instead")]
+	public IEnumerator GetObjects()
+	{
+		return GetEnumerator();
+	}
+
+	[Obsolete("Use 'object[index]' syntax instead")]
+	public Asn1Encodable GetObjectAt(int index)
+	{
+		return this[index];
+	}
+
+	public virtual Asn1Encodable[] ToArray()
+	{
+		Asn1Encodable[] array = new Asn1Encodable[Count];
+		for (int i = 0; i < Count; i++)
+		{
+			array[i] = this[i];
+		}
+		return array;
+	}
+
+	protected override int Asn1GetHashCode()
+	{
+		int num = Count;
+		IEnumerator enumerator = GetEnumerator();
+		try
+		{
+			while (enumerator.MoveNext())
+			{
+				object current = enumerator.Current;
+				num *= 17;
+				num = ((current != null) ? (num ^ current.GetHashCode()) : (num ^ DerNull.Instance.GetHashCode()));
+			}
+			return num;
+		}
+		finally
+		{
+			IDisposable disposable = enumerator as IDisposable;
+			if (disposable != null)
+			{
+				disposable.Dispose();
+			}
+		}
+	}
+
+	protected override bool Asn1Equals(Asn1Object asn1Object)
+	{
+		if (!(asn1Object is Asn1Set asn1Set))
+		{
+			return false;
+		}
+		if (Count != asn1Set.Count)
+		{
+			return false;
+		}
+		IEnumerator enumerator = GetEnumerator();
+		IEnumerator enumerator2 = asn1Set.GetEnumerator();
+		while (enumerator.MoveNext() && enumerator2.MoveNext())
+		{
+			Asn1Object asn1Object2 = GetCurrent(enumerator).ToAsn1Object();
+			Asn1Object obj = GetCurrent(enumerator2).ToAsn1Object();
+			if (!asn1Object2.Equals(obj))
+			{
+				return false;
+			}
+		}
+		return true;
+	}
+
+	private Asn1Encodable GetCurrent(IEnumerator e)
+	{
+		Asn1Encodable asn1Encodable = (Asn1Encodable)e.Current;
+		if (asn1Encodable == null)
+		{
+			return DerNull.Instance;
+		}
+		return asn1Encodable;
+	}
+
+	protected internal void Sort()
+	{
+		if (_set.Count >= 2)
+		{
+			Asn1Encodable[] array = new Asn1Encodable[_set.Count];
+			byte[][] array2 = new byte[_set.Count][];
+			for (int i = 0; i < _set.Count; i++)
+			{
+				array2[i] = (array[i] = (Asn1Encodable)_set[i]).GetEncoded("DER");
+			}
+			Array.Sort(array2, array, new DerComparer());
+			for (int j = 0; j < _set.Count; j++)
+			{
+				_set[j] = array[j];
+			}
+		}
+	}
+
+	protected internal void AddObject(Asn1Encodable obj)
+	{
+		_set.Add(obj);
+	}
+
+	public override string ToString()
+	{
+		return CollectionUtilities.ToString(_set);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Asn1SetParser.cs

@@ -0,0 +1,6 @@
+namespace Org.BouncyCastle.Asn1;
+
+public interface Asn1SetParser : IAsn1Convertible
+{
+	IAsn1Convertible ReadObject();
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Asn1StreamParser.cs

@@ -0,0 +1,189 @@
+using System;
+using System.IO;
+
+namespace Org.BouncyCastle.Asn1;
+
+public class Asn1StreamParser
+{
+	private readonly Stream _in;
+
+	private readonly int _limit;
+
+	private readonly byte[][] tmpBuffers;
+
+	public Asn1StreamParser(Stream inStream)
+		: this(inStream, Asn1InputStream.FindLimit(inStream))
+	{
+	}
+
+	public Asn1StreamParser(Stream inStream, int limit)
+	{
+		if (!inStream.CanRead)
+		{
+			throw new ArgumentException("Expected stream to be readable", "inStream");
+		}
+		_in = inStream;
+		_limit = limit;
+		tmpBuffers = new byte[16][];
+	}
+
+	public Asn1StreamParser(byte[] encoding)
+		: this(new MemoryStream(encoding, writable: false), encoding.Length)
+	{
+	}
+
+	internal IAsn1Convertible ReadIndef(int tagValue)
+	{
+		return tagValue switch
+		{
+			8 => new DerExternalParser(this), 
+			4 => new BerOctetStringParser(this), 
+			16 => new BerSequenceParser(this), 
+			17 => new BerSetParser(this), 
+			_ => throw new Asn1Exception("unknown BER object encountered: 0x" + tagValue.ToString("X")), 
+		};
+	}
+
+	internal IAsn1Convertible ReadImplicit(bool constructed, int tag)
+	{
+		if (_in is IndefiniteLengthInputStream)
+		{
+			if (!constructed)
+			{
+				throw new IOException("indefinite length primitive encoding encountered");
+			}
+			return ReadIndef(tag);
+		}
+		if (constructed)
+		{
+			switch (tag)
+			{
+			case 17:
+				return new DerSetParser(this);
+			case 16:
+				return new DerSequenceParser(this);
+			case 4:
+				return new BerOctetStringParser(this);
+			}
+		}
+		else
+		{
+			switch (tag)
+			{
+			case 17:
+				throw new Asn1Exception("sequences must use constructed encoding (see X.690 8.9.1/8.10.1)");
+			case 16:
+				throw new Asn1Exception("sets must use constructed encoding (see X.690 8.11.1/8.12.1)");
+			case 4:
+				return new DerOctetStringParser((DefiniteLengthInputStream)_in);
+			}
+		}
+		throw new Asn1Exception("implicit tagging not implemented");
+	}
+
+	internal Asn1Object ReadTaggedObject(bool constructed, int tag)
+	{
+		if (!constructed)
+		{
+			DefiniteLengthInputStream definiteLengthInputStream = (DefiniteLengthInputStream)_in;
+			return new DerTaggedObject(explicitly: false, tag, new DerOctetString(definiteLengthInputStream.ToArray()));
+		}
+		Asn1EncodableVector asn1EncodableVector = ReadVector();
+		if (_in is IndefiniteLengthInputStream)
+		{
+			if (asn1EncodableVector.Count != 1)
+			{
+				return new BerTaggedObject(explicitly: false, tag, BerSequence.FromVector(asn1EncodableVector));
+			}
+			return new BerTaggedObject(explicitly: true, tag, asn1EncodableVector[0]);
+		}
+		if (asn1EncodableVector.Count != 1)
+		{
+			return new DerTaggedObject(explicitly: false, tag, DerSequence.FromVector(asn1EncodableVector));
+		}
+		return new DerTaggedObject(explicitly: true, tag, asn1EncodableVector[0]);
+	}
+
+	public virtual IAsn1Convertible ReadObject()
+	{
+		int num = _in.ReadByte();
+		if (num == -1)
+		{
+			return null;
+		}
+		Set00Check(enabled: false);
+		int num2 = Asn1InputStream.ReadTagNumber(_in, num);
+		bool flag = (num & 0x20) != 0;
+		int num3 = Asn1InputStream.ReadLength(_in, _limit);
+		if (num3 < 0)
+		{
+			if (!flag)
+			{
+				throw new IOException("indefinite length primitive encoding encountered");
+			}
+			IndefiniteLengthInputStream inStream = new IndefiniteLengthInputStream(_in, _limit);
+			Asn1StreamParser asn1StreamParser = new Asn1StreamParser(inStream, _limit);
+			if ((num & 0x40) != 0)
+			{
+				return new BerApplicationSpecificParser(num2, asn1StreamParser);
+			}
+			if ((num & 0x80) != 0)
+			{
+				return new BerTaggedObjectParser(constructed: true, num2, asn1StreamParser);
+			}
+			return asn1StreamParser.ReadIndef(num2);
+		}
+		DefiniteLengthInputStream definiteLengthInputStream = new DefiniteLengthInputStream(_in, num3);
+		if ((num & 0x40) != 0)
+		{
+			return new DerApplicationSpecific(flag, num2, definiteLengthInputStream.ToArray());
+		}
+		if ((num & 0x80) != 0)
+		{
+			return new BerTaggedObjectParser(flag, num2, new Asn1StreamParser(definiteLengthInputStream));
+		}
+		if (flag)
+		{
+			return num2 switch
+			{
+				4 => new BerOctetStringParser(new Asn1StreamParser(definiteLengthInputStream)), 
+				16 => new DerSequenceParser(new Asn1StreamParser(definiteLengthInputStream)), 
+				17 => new DerSetParser(new Asn1StreamParser(definiteLengthInputStream)), 
+				8 => new DerExternalParser(new Asn1StreamParser(definiteLengthInputStream)), 
+				_ => throw new IOException("unknown tag " + num2 + " encountered"), 
+			};
+		}
+		int num4 = num2;
+		if (num4 == 4)
+		{
+			return new DerOctetStringParser(definiteLengthInputStream);
+		}
+		try
+		{
+			return Asn1InputStream.CreatePrimitiveDerObject(num2, definiteLengthInputStream, tmpBuffers);
+		}
+		catch (ArgumentException exception)
+		{
+			throw new Asn1Exception("corrupted stream detected", exception);
+		}
+	}
+
+	private void Set00Check(bool enabled)
+	{
+		if (_in is IndefiniteLengthInputStream)
+		{
+			((IndefiniteLengthInputStream)_in).SetEofOn00(enabled);
+		}
+	}
+
+	internal Asn1EncodableVector ReadVector()
+	{
+		Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector();
+		IAsn1Convertible asn1Convertible;
+		while ((asn1Convertible = ReadObject()) != null)
+		{
+			asn1EncodableVector.Add(asn1Convertible.ToAsn1Object());
+		}
+		return asn1EncodableVector;
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Asn1TaggedObject.cs

@@ -0,0 +1,126 @@
+using System;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1;
+
+public abstract class Asn1TaggedObject : Asn1Object, Asn1TaggedObjectParser, IAsn1Convertible
+{
+	internal int tagNo;
+
+	internal bool explicitly = true;
+
+	internal Asn1Encodable obj;
+
+	public int TagNo => tagNo;
+
+	internal static bool IsConstructed(bool isExplicit, Asn1Object obj)
+	{
+		if (isExplicit || obj is Asn1Sequence || obj is Asn1Set)
+		{
+			return true;
+		}
+		if (!(obj is Asn1TaggedObject asn1TaggedObject))
+		{
+			return false;
+		}
+		return IsConstructed(asn1TaggedObject.IsExplicit(), asn1TaggedObject.GetObject());
+	}
+
+	public static Asn1TaggedObject GetInstance(Asn1TaggedObject obj, bool explicitly)
+	{
+		if (explicitly)
+		{
+			return (Asn1TaggedObject)obj.GetObject();
+		}
+		throw new ArgumentException("implicitly tagged tagged object");
+	}
+
+	public static Asn1TaggedObject GetInstance(object obj)
+	{
+		if (obj == null || obj is Asn1TaggedObject)
+		{
+			return (Asn1TaggedObject)obj;
+		}
+		throw new ArgumentException("Unknown object in GetInstance: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	protected Asn1TaggedObject(int tagNo, Asn1Encodable obj)
+	{
+		explicitly = true;
+		this.tagNo = tagNo;
+		this.obj = obj;
+	}
+
+	protected Asn1TaggedObject(bool explicitly, int tagNo, Asn1Encodable obj)
+	{
+		this.explicitly = explicitly || obj is IAsn1Choice;
+		this.tagNo = tagNo;
+		this.obj = obj;
+	}
+
+	protected override bool Asn1Equals(Asn1Object asn1Object)
+	{
+		if (!(asn1Object is Asn1TaggedObject asn1TaggedObject))
+		{
+			return false;
+		}
+		if (tagNo == asn1TaggedObject.tagNo && explicitly == asn1TaggedObject.explicitly)
+		{
+			return object.Equals(GetObject(), asn1TaggedObject.GetObject());
+		}
+		return false;
+	}
+
+	protected override int Asn1GetHashCode()
+	{
+		int num = tagNo.GetHashCode();
+		if (obj != null)
+		{
+			num ^= obj.GetHashCode();
+		}
+		return num;
+	}
+
+	public bool IsExplicit()
+	{
+		return explicitly;
+	}
+
+	public bool IsEmpty()
+	{
+		return false;
+	}
+
+	public Asn1Object GetObject()
+	{
+		if (obj != null)
+		{
+			return obj.ToAsn1Object();
+		}
+		return null;
+	}
+
+	public IAsn1Convertible GetObjectParser(int tag, bool isExplicit)
+	{
+		switch (tag)
+		{
+		case 17:
+			return Asn1Set.GetInstance(this, isExplicit).Parser;
+		case 16:
+			return Asn1Sequence.GetInstance(this, isExplicit).Parser;
+		case 4:
+			return Asn1OctetString.GetInstance(this, isExplicit).Parser;
+		default:
+			if (isExplicit)
+			{
+				return GetObject();
+			}
+			throw Platform.CreateNotImplementedException("implicit tagging for tag: " + tag);
+		}
+	}
+
+	public override string ToString()
+	{
+		return "[" + tagNo + "]" + obj;
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Asn1TaggedObjectParser.cs

@@ -0,0 +1,8 @@
+namespace Org.BouncyCastle.Asn1;
+
+public interface Asn1TaggedObjectParser : IAsn1Convertible
+{
+	int TagNo { get; }
+
+	IAsn1Convertible GetObjectParser(int tag, bool isExplicit);
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Asn1Tags.cs

@@ -0,0 +1,60 @@
+namespace Org.BouncyCastle.Asn1;
+
+public class Asn1Tags
+{
+	public const int Boolean = 1;
+
+	public const int Integer = 2;
+
+	public const int BitString = 3;
+
+	public const int OctetString = 4;
+
+	public const int Null = 5;
+
+	public const int ObjectIdentifier = 6;
+
+	public const int External = 8;
+
+	public const int Enumerated = 10;
+
+	public const int Sequence = 16;
+
+	public const int SequenceOf = 16;
+
+	public const int Set = 17;
+
+	public const int SetOf = 17;
+
+	public const int NumericString = 18;
+
+	public const int PrintableString = 19;
+
+	public const int T61String = 20;
+
+	public const int VideotexString = 21;
+
+	public const int IA5String = 22;
+
+	public const int UtcTime = 23;
+
+	public const int GeneralizedTime = 24;
+
+	public const int GraphicString = 25;
+
+	public const int VisibleString = 26;
+
+	public const int GeneralString = 27;
+
+	public const int UniversalString = 28;
+
+	public const int BmpString = 30;
+
+	public const int Utf8String = 12;
+
+	public const int Constructed = 32;
+
+	public const int Application = 64;
+
+	public const int Tagged = 128;
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/BC/BCObjectIdentifiers.cs

@@ -0,0 +1,72 @@
+namespace Org.BouncyCastle.Asn1.BC;
+
+public abstract class BCObjectIdentifiers
+{
+	public static readonly DerObjectIdentifier bc = new DerObjectIdentifier("1.3.6.1.4.1.22554");
+
+	public static readonly DerObjectIdentifier bc_pbe = bc.Branch("1");
+
+	public static readonly DerObjectIdentifier bc_pbe_sha1 = bc_pbe.Branch("1");
+
+	public static readonly DerObjectIdentifier bc_pbe_sha256 = bc_pbe.Branch("2.1");
+
+	public static readonly DerObjectIdentifier bc_pbe_sha384 = bc_pbe.Branch("2.2");
+
+	public static readonly DerObjectIdentifier bc_pbe_sha512 = bc_pbe.Branch("2.3");
+
+	public static readonly DerObjectIdentifier bc_pbe_sha224 = bc_pbe.Branch("2.4");
+
+	public static readonly DerObjectIdentifier bc_pbe_sha1_pkcs5 = bc_pbe_sha1.Branch("1");
+
+	public static readonly DerObjectIdentifier bc_pbe_sha1_pkcs12 = bc_pbe_sha1.Branch("2");
+
+	public static readonly DerObjectIdentifier bc_pbe_sha256_pkcs5 = bc_pbe_sha256.Branch("1");
+
+	public static readonly DerObjectIdentifier bc_pbe_sha256_pkcs12 = bc_pbe_sha256.Branch("2");
+
+	public static readonly DerObjectIdentifier bc_pbe_sha1_pkcs12_aes128_cbc = bc_pbe_sha1_pkcs12.Branch("1.2");
+
+	public static readonly DerObjectIdentifier bc_pbe_sha1_pkcs12_aes192_cbc = bc_pbe_sha1_pkcs12.Branch("1.22");
+
+	public static readonly DerObjectIdentifier bc_pbe_sha1_pkcs12_aes256_cbc = bc_pbe_sha1_pkcs12.Branch("1.42");
+
+	public static readonly DerObjectIdentifier bc_pbe_sha256_pkcs12_aes128_cbc = bc_pbe_sha256_pkcs12.Branch("1.2");
+
+	public static readonly DerObjectIdentifier bc_pbe_sha256_pkcs12_aes192_cbc = bc_pbe_sha256_pkcs12.Branch("1.22");
+
+	public static readonly DerObjectIdentifier bc_pbe_sha256_pkcs12_aes256_cbc = bc_pbe_sha256_pkcs12.Branch("1.42");
+
+	public static readonly DerObjectIdentifier bc_sig = bc.Branch("2");
+
+	public static readonly DerObjectIdentifier sphincs256 = bc_sig.Branch("1");
+
+	public static readonly DerObjectIdentifier sphincs256_with_BLAKE512 = sphincs256.Branch("1");
+
+	public static readonly DerObjectIdentifier sphincs256_with_SHA512 = sphincs256.Branch("2");
+
+	public static readonly DerObjectIdentifier sphincs256_with_SHA3_512 = sphincs256.Branch("3");
+
+	public static readonly DerObjectIdentifier xmss = bc_sig.Branch("2");
+
+	public static readonly DerObjectIdentifier xmss_with_SHA256 = xmss.Branch("1");
+
+	public static readonly DerObjectIdentifier xmss_with_SHA512 = xmss.Branch("2");
+
+	public static readonly DerObjectIdentifier xmss_with_SHAKE128 = xmss.Branch("3");
+
+	public static readonly DerObjectIdentifier xmss_with_SHAKE256 = xmss.Branch("4");
+
+	public static readonly DerObjectIdentifier xmss_mt = bc_sig.Branch("3");
+
+	public static readonly DerObjectIdentifier xmss_mt_with_SHA256 = xmss_mt.Branch("1");
+
+	public static readonly DerObjectIdentifier xmss_mt_with_SHA512 = xmss_mt.Branch("2");
+
+	public static readonly DerObjectIdentifier xmss_mt_with_SHAKE128 = xmss_mt.Branch("3");
+
+	public static readonly DerObjectIdentifier xmss_mt_with_SHAKE256 = xmss_mt.Branch("4");
+
+	public static readonly DerObjectIdentifier bc_exch = bc.Branch("3");
+
+	public static readonly DerObjectIdentifier newHope = bc_exch.Branch("1");
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/BerApplicationSpecific.cs

@@ -0,0 +1,9 @@
+namespace Org.BouncyCastle.Asn1;
+
+public class BerApplicationSpecific : DerApplicationSpecific
+{
+	public BerApplicationSpecific(int tagNo, Asn1EncodableVector vec)
+		: base(tagNo, vec)
+	{
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/BerApplicationSpecificParser.cs

@@ -0,0 +1,24 @@
+namespace Org.BouncyCastle.Asn1;
+
+public class BerApplicationSpecificParser : IAsn1ApplicationSpecificParser, IAsn1Convertible
+{
+	private readonly int tag;
+
+	private readonly Asn1StreamParser parser;
+
+	internal BerApplicationSpecificParser(int tag, Asn1StreamParser parser)
+	{
+		this.tag = tag;
+		this.parser = parser;
+	}
+
+	public IAsn1Convertible ReadObject()
+	{
+		return parser.ReadObject();
+	}
+
+	public Asn1Object ToAsn1Object()
+	{
+		return new BerApplicationSpecific(tag, parser.ReadVector());
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/BerBitString.cs

@@ -0,0 +1,36 @@
+namespace Org.BouncyCastle.Asn1;
+
+public class BerBitString : DerBitString
+{
+	public BerBitString(byte[] data, int padBits)
+		: base(data, padBits)
+	{
+	}
+
+	public BerBitString(byte[] data)
+		: base(data)
+	{
+	}
+
+	public BerBitString(int namedBits)
+		: base(namedBits)
+	{
+	}
+
+	public BerBitString(Asn1Encodable obj)
+		: base(obj)
+	{
+	}
+
+	internal override void Encode(DerOutputStream derOut)
+	{
+		if (derOut is Asn1OutputStream || derOut is BerOutputStream)
+		{
+			derOut.WriteEncoded(3, (byte)mPadBits, mData);
+		}
+		else
+		{
+			base.Encode(derOut);
+		}
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/BerGenerator.cs

@@ -0,0 +1,88 @@
+using System.IO;
+using Org.BouncyCastle.Utilities.IO;
+
+namespace Org.BouncyCastle.Asn1;
+
+public class BerGenerator : Asn1Generator
+{
+	private bool _tagged = false;
+
+	private bool _isExplicit;
+
+	private int _tagNo;
+
+	protected BerGenerator(Stream outStream)
+		: base(outStream)
+	{
+	}
+
+	public BerGenerator(Stream outStream, int tagNo, bool isExplicit)
+		: base(outStream)
+	{
+		_tagged = true;
+		_isExplicit = isExplicit;
+		_tagNo = tagNo;
+	}
+
+	public override void AddObject(Asn1Encodable obj)
+	{
+		new BerOutputStream(base.Out).WriteObject(obj);
+	}
+
+	public override Stream GetRawOutputStream()
+	{
+		return base.Out;
+	}
+
+	public override void Close()
+	{
+		WriteBerEnd();
+	}
+
+	private void WriteHdr(int tag)
+	{
+		base.Out.WriteByte((byte)tag);
+		base.Out.WriteByte(128);
+	}
+
+	protected void WriteBerHeader(int tag)
+	{
+		if (_tagged)
+		{
+			int num = _tagNo | 0x80;
+			if (_isExplicit)
+			{
+				WriteHdr(num | 0x20);
+				WriteHdr(tag);
+			}
+			else if ((tag & 0x20) != 0)
+			{
+				WriteHdr(num | 0x20);
+			}
+			else
+			{
+				WriteHdr(num);
+			}
+		}
+		else
+		{
+			WriteHdr(tag);
+		}
+	}
+
+	protected void WriteBerBody(Stream contentStream)
+	{
+		Streams.PipeAll(contentStream, base.Out);
+	}
+
+	protected void WriteBerEnd()
+	{
+		base.Out.WriteByte(0);
+		base.Out.WriteByte(0);
+		if (_tagged && _isExplicit)
+		{
+			base.Out.WriteByte(0);
+			base.Out.WriteByte(0);
+		}
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/BerNull.cs

@@ -0,0 +1,30 @@
+using System;
+
+namespace Org.BouncyCastle.Asn1;
+
+public class BerNull : DerNull
+{
+	public new static readonly BerNull Instance = new BerNull(0);
+
+	[Obsolete("Use static Instance object")]
+	public BerNull()
+	{
+	}
+
+	private BerNull(int dummy)
+		: base(dummy)
+	{
+	}
+
+	internal override void Encode(DerOutputStream derOut)
+	{
+		if (derOut is Asn1OutputStream || derOut is BerOutputStream)
+		{
+			derOut.WriteByte(5);
+		}
+		else
+		{
+			base.Encode(derOut);
+		}
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/BerOctetString.cs

@@ -0,0 +1,122 @@
+using System;
+using System.Collections;
+using System.IO;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1;
+
+public class BerOctetString : DerOctetString, IEnumerable
+{
+	private const int MaxLength = 1000;
+
+	private readonly IEnumerable octs;
+
+	public static BerOctetString FromSequence(Asn1Sequence seq)
+	{
+		IList list = Platform.CreateArrayList();
+		foreach (Asn1Encodable item in seq)
+		{
+			list.Add(item);
+		}
+		return new BerOctetString(list);
+	}
+
+	private static byte[] ToBytes(IEnumerable octs)
+	{
+		MemoryStream memoryStream = new MemoryStream();
+		foreach (DerOctetString oct in octs)
+		{
+			byte[] octets = oct.GetOctets();
+			memoryStream.Write(octets, 0, octets.Length);
+		}
+		return memoryStream.ToArray();
+	}
+
+	public BerOctetString(byte[] str)
+		: base(str)
+	{
+	}
+
+	public BerOctetString(IEnumerable octets)
+		: base(ToBytes(octets))
+	{
+		octs = octets;
+	}
+
+	public BerOctetString(Asn1Object obj)
+		: base(obj)
+	{
+	}
+
+	public BerOctetString(Asn1Encodable obj)
+		: base(obj.ToAsn1Object())
+	{
+	}
+
+	public override byte[] GetOctets()
+	{
+		return str;
+	}
+
+	public IEnumerator GetEnumerator()
+	{
+		if (octs == null)
+		{
+			return GenerateOcts().GetEnumerator();
+		}
+		return octs.GetEnumerator();
+	}
+
+	[Obsolete("Use GetEnumerator() instead")]
+	public IEnumerator GetObjects()
+	{
+		return GetEnumerator();
+	}
+
+	private IList GenerateOcts()
+	{
+		IList list = Platform.CreateArrayList();
+		for (int i = 0; i < str.Length; i += 1000)
+		{
+			int num = System.Math.Min(str.Length, i + 1000);
+			byte[] array = new byte[num - i];
+			Array.Copy(str, i, array, 0, array.Length);
+			list.Add(new DerOctetString(array));
+		}
+		return list;
+	}
+
+	internal override void Encode(DerOutputStream derOut)
+	{
+		if (derOut is Asn1OutputStream || derOut is BerOutputStream)
+		{
+			derOut.WriteByte(36);
+			derOut.WriteByte(128);
+			{
+				IEnumerator enumerator = GetEnumerator();
+				try
+				{
+					while (enumerator.MoveNext())
+					{
+						DerOctetString obj = (DerOctetString)enumerator.Current;
+						derOut.WriteObject(obj);
+					}
+				}
+				finally
+				{
+					IDisposable disposable = enumerator as IDisposable;
+					if (disposable != null)
+					{
+						disposable.Dispose();
+					}
+				}
+			}
+			derOut.WriteByte(0);
+			derOut.WriteByte(0);
+		}
+		else
+		{
+			base.Encode(derOut);
+		}
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/BerOctetStringGenerator.cs

@@ -0,0 +1,103 @@
+using System;
+using System.IO;
+using Org.BouncyCastle.Utilities.IO;
+
+namespace Org.BouncyCastle.Asn1;
+
+public class BerOctetStringGenerator : BerGenerator
+{
+	private class BufferedBerOctetStream : BaseOutputStream
+	{
+		private byte[] _buf;
+
+		private int _off;
+
+		private readonly BerOctetStringGenerator _gen;
+
+		private readonly DerOutputStream _derOut;
+
+		internal BufferedBerOctetStream(BerOctetStringGenerator gen, byte[] buf)
+		{
+			_gen = gen;
+			_buf = buf;
+			_off = 0;
+			_derOut = new DerOutputStream(_gen.Out);
+		}
+
+		public override void WriteByte(byte b)
+		{
+			_buf[_off++] = b;
+			if (_off == _buf.Length)
+			{
+				DerOctetString.Encode(_derOut, _buf, 0, _off);
+				_off = 0;
+			}
+		}
+
+		public override void Write(byte[] buf, int offset, int len)
+		{
+			while (len > 0)
+			{
+				int num = System.Math.Min(len, _buf.Length - _off);
+				if (num == _buf.Length)
+				{
+					DerOctetString.Encode(_derOut, buf, offset, num);
+				}
+				else
+				{
+					Array.Copy(buf, offset, _buf, _off, num);
+					_off += num;
+					if (_off < _buf.Length)
+					{
+						break;
+					}
+					DerOctetString.Encode(_derOut, _buf, 0, _off);
+					_off = 0;
+				}
+				offset += num;
+				len -= num;
+			}
+		}
+
+		public override void Close()
+		{
+			if (_off != 0)
+			{
+				DerOctetString.Encode(_derOut, _buf, 0, _off);
+			}
+			_gen.WriteBerEnd();
+			base.Close();
+		}
+	}
+
+	public BerOctetStringGenerator(Stream outStream)
+		: base(outStream)
+	{
+		WriteBerHeader(36);
+	}
+
+	public BerOctetStringGenerator(Stream outStream, int tagNo, bool isExplicit)
+		: base(outStream, tagNo, isExplicit)
+	{
+		WriteBerHeader(36);
+	}
+
+	public Stream GetOctetOutputStream()
+	{
+		return GetOctetOutputStream(new byte[1000]);
+	}
+
+	public Stream GetOctetOutputStream(int bufSize)
+	{
+		if (bufSize >= 1)
+		{
+			return GetOctetOutputStream(new byte[bufSize]);
+		}
+		return GetOctetOutputStream();
+	}
+
+	public Stream GetOctetOutputStream(byte[] buf)
+	{
+		return new BufferedBerOctetStream(this, buf);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/BerOctetStringParser.cs

@@ -0,0 +1,31 @@
+using System.IO;
+using Org.BouncyCastle.Utilities.IO;
+
+namespace Org.BouncyCastle.Asn1;
+
+public class BerOctetStringParser : Asn1OctetStringParser, IAsn1Convertible
+{
+	private readonly Asn1StreamParser _parser;
+
+	internal BerOctetStringParser(Asn1StreamParser parser)
+	{
+		_parser = parser;
+	}
+
+	public Stream GetOctetStream()
+	{
+		return new ConstructedOctetStream(_parser);
+	}
+
+	public Asn1Object ToAsn1Object()
+	{
+		try
+		{
+			return new BerOctetString(Streams.ReadAll(GetOctetStream()));
+		}
+		catch (IOException ex)
+		{
+			throw new Asn1ParsingException("IOException converting stream to byte array: " + ex.Message, ex);
+		}
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/BerOutputStream.cs

@@ -0,0 +1,33 @@
+using System;
+using System.IO;
+
+namespace Org.BouncyCastle.Asn1;
+
+public class BerOutputStream : DerOutputStream
+{
+	public BerOutputStream(Stream os)
+		: base(os)
+	{
+	}
+
+	[Obsolete("Use version taking an Asn1Encodable arg instead")]
+	public override void WriteObject(object obj)
+	{
+		if (obj == null)
+		{
+			WriteNull();
+			return;
+		}
+		if (obj is Asn1Object)
+		{
+			((Asn1Object)obj).Encode(this);
+			return;
+		}
+		if (obj is Asn1Encodable)
+		{
+			((Asn1Encodable)obj).ToAsn1Object().Encode(this);
+			return;
+		}
+		throw new IOException("object not BerEncodable");
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/BerSequence.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Collections;
+
+namespace Org.BouncyCastle.Asn1;
+
+public class BerSequence : DerSequence
+{
+	public new static readonly BerSequence Empty = new BerSequence();
+
+	public new static BerSequence FromVector(Asn1EncodableVector v)
+	{
+		if (v.Count >= 1)
+		{
+			return new BerSequence(v);
+		}
+		return Empty;
+	}
+
+	public BerSequence()
+	{
+	}
+
+	public BerSequence(Asn1Encodable obj)
+		: base(obj)
+	{
+	}
+
+	public BerSequence(params Asn1Encodable[] v)
+		: base(v)
+	{
+	}
+
+	public BerSequence(Asn1EncodableVector v)
+		: base(v)
+	{
+	}
+
+	internal override void Encode(DerOutputStream derOut)
+	{
+		if (derOut is Asn1OutputStream || derOut is BerOutputStream)
+		{
+			derOut.WriteByte(48);
+			derOut.WriteByte(128);
+			{
+				IEnumerator enumerator = GetEnumerator();
+				try
+				{
+					while (enumerator.MoveNext())
+					{
+						Asn1Encodable obj = (Asn1Encodable)enumerator.Current;
+						derOut.WriteObject(obj);
+					}
+				}
+				finally
+				{
+					IDisposable disposable = enumerator as IDisposable;
+					if (disposable != null)
+					{
+						disposable.Dispose();
+					}
+				}
+			}
+			derOut.WriteByte(0);
+			derOut.WriteByte(0);
+		}
+		else
+		{
+			base.Encode(derOut);
+		}
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/BerSequenceGenerator.cs

@@ -0,0 +1,18 @@
+using System.IO;
+
+namespace Org.BouncyCastle.Asn1;
+
+public class BerSequenceGenerator : BerGenerator
+{
+	public BerSequenceGenerator(Stream outStream)
+		: base(outStream)
+	{
+		WriteBerHeader(48);
+	}
+
+	public BerSequenceGenerator(Stream outStream, int tagNo, bool isExplicit)
+		: base(outStream, tagNo, isExplicit)
+	{
+		WriteBerHeader(48);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/BerSequenceParser.cs

@@ -0,0 +1,21 @@
+namespace Org.BouncyCastle.Asn1;
+
+public class BerSequenceParser : Asn1SequenceParser, IAsn1Convertible
+{
+	private readonly Asn1StreamParser _parser;
+
+	internal BerSequenceParser(Asn1StreamParser parser)
+	{
+		_parser = parser;
+	}
+
+	public IAsn1Convertible ReadObject()
+	{
+		return _parser.ReadObject();
+	}
+
+	public Asn1Object ToAsn1Object()
+	{
+		return new BerSequence(_parser.ReadVector());
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/BerSet.cs

@@ -0,0 +1,80 @@
+using System;
+using System.Collections;
+
+namespace Org.BouncyCastle.Asn1;
+
+public class BerSet : DerSet
+{
+	public new static readonly BerSet Empty = new BerSet();
+
+	public new static BerSet FromVector(Asn1EncodableVector v)
+	{
+		if (v.Count >= 1)
+		{
+			return new BerSet(v);
+		}
+		return Empty;
+	}
+
+	internal new static BerSet FromVector(Asn1EncodableVector v, bool needsSorting)
+	{
+		if (v.Count >= 1)
+		{
+			return new BerSet(v, needsSorting);
+		}
+		return Empty;
+	}
+
+	public BerSet()
+	{
+	}
+
+	public BerSet(Asn1Encodable obj)
+		: base(obj)
+	{
+	}
+
+	public BerSet(Asn1EncodableVector v)
+		: base(v, needsSorting: false)
+	{
+	}
+
+	internal BerSet(Asn1EncodableVector v, bool needsSorting)
+		: base(v, needsSorting)
+	{
+	}
+
+	internal override void Encode(DerOutputStream derOut)
+	{
+		if (derOut is Asn1OutputStream || derOut is BerOutputStream)
+		{
+			derOut.WriteByte(49);
+			derOut.WriteByte(128);
+			{
+				IEnumerator enumerator = GetEnumerator();
+				try
+				{
+					while (enumerator.MoveNext())
+					{
+						Asn1Encodable obj = (Asn1Encodable)enumerator.Current;
+						derOut.WriteObject(obj);
+					}
+				}
+				finally
+				{
+					IDisposable disposable = enumerator as IDisposable;
+					if (disposable != null)
+					{
+						disposable.Dispose();
+					}
+				}
+			}
+			derOut.WriteByte(0);
+			derOut.WriteByte(0);
+		}
+		else
+		{
+			base.Encode(derOut);
+		}
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/BerSetGenerator.cs

@@ -0,0 +1,18 @@
+using System.IO;
+
+namespace Org.BouncyCastle.Asn1;
+
+public class BerSetGenerator : BerGenerator
+{
+	public BerSetGenerator(Stream outStream)
+		: base(outStream)
+	{
+		WriteBerHeader(49);
+	}
+
+	public BerSetGenerator(Stream outStream, int tagNo, bool isExplicit)
+		: base(outStream, tagNo, isExplicit)
+	{
+		WriteBerHeader(49);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/BerSetParser.cs

@@ -0,0 +1,21 @@
+namespace Org.BouncyCastle.Asn1;
+
+public class BerSetParser : Asn1SetParser, IAsn1Convertible
+{
+	private readonly Asn1StreamParser _parser;
+
+	internal BerSetParser(Asn1StreamParser parser)
+	{
+		_parser = parser;
+	}
+
+	public IAsn1Convertible ReadObject()
+	{
+		return _parser.ReadObject();
+	}
+
+	public Asn1Object ToAsn1Object()
+	{
+		return new BerSet(_parser.ReadVector(), needsSorting: false);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/BerTaggedObject.cs

@@ -0,0 +1,76 @@
+using System.Collections;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1;
+
+public class BerTaggedObject : DerTaggedObject
+{
+	public BerTaggedObject(int tagNo, Asn1Encodable obj)
+		: base(tagNo, obj)
+	{
+	}
+
+	public BerTaggedObject(bool explicitly, int tagNo, Asn1Encodable obj)
+		: base(explicitly, tagNo, obj)
+	{
+	}
+
+	public BerTaggedObject(int tagNo)
+		: base(explicitly: false, tagNo, BerSequence.Empty)
+	{
+	}
+
+	internal override void Encode(DerOutputStream derOut)
+	{
+		if (derOut is Asn1OutputStream || derOut is BerOutputStream)
+		{
+			derOut.WriteTag(160, tagNo);
+			derOut.WriteByte(128);
+			if (!IsEmpty())
+			{
+				if (!explicitly)
+				{
+					IEnumerable enumerable;
+					if (obj is Asn1OctetString)
+					{
+						if (obj is BerOctetString)
+						{
+							enumerable = (BerOctetString)obj;
+						}
+						else
+						{
+							Asn1OctetString asn1OctetString = (Asn1OctetString)obj;
+							enumerable = new BerOctetString(asn1OctetString.GetOctets());
+						}
+					}
+					else if (obj is Asn1Sequence)
+					{
+						enumerable = (Asn1Sequence)obj;
+					}
+					else
+					{
+						if (!(obj is Asn1Set))
+						{
+							throw Platform.CreateNotImplementedException(Platform.GetTypeName(obj));
+						}
+						enumerable = (Asn1Set)obj;
+					}
+					foreach (Asn1Encodable item in enumerable)
+					{
+						derOut.WriteObject(item);
+					}
+				}
+				else
+				{
+					derOut.WriteObject(obj);
+				}
+			}
+			derOut.WriteByte(0);
+			derOut.WriteByte(0);
+		}
+		else
+		{
+			base.Encode(derOut);
+		}
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/BerTaggedObjectParser.cs

@@ -0,0 +1,55 @@
+using System;
+using System.IO;
+
+namespace Org.BouncyCastle.Asn1;
+
+public class BerTaggedObjectParser : Asn1TaggedObjectParser, IAsn1Convertible
+{
+	private bool _constructed;
+
+	private int _tagNumber;
+
+	private Asn1StreamParser _parser;
+
+	public bool IsConstructed => _constructed;
+
+	public int TagNo => _tagNumber;
+
+	[Obsolete]
+	internal BerTaggedObjectParser(int baseTag, int tagNumber, Stream contentStream)
+		: this((baseTag & 0x20) != 0, tagNumber, new Asn1StreamParser(contentStream))
+	{
+	}
+
+	internal BerTaggedObjectParser(bool constructed, int tagNumber, Asn1StreamParser parser)
+	{
+		_constructed = constructed;
+		_tagNumber = tagNumber;
+		_parser = parser;
+	}
+
+	public IAsn1Convertible GetObjectParser(int tag, bool isExplicit)
+	{
+		if (isExplicit)
+		{
+			if (!_constructed)
+			{
+				throw new IOException("Explicit tags must be constructed (see X.690 8.14.2)");
+			}
+			return _parser.ReadObject();
+		}
+		return _parser.ReadImplicit(_constructed, tag);
+	}
+
+	public Asn1Object ToAsn1Object()
+	{
+		try
+		{
+			return _parser.ReadTaggedObject(_constructed, _tagNumber);
+		}
+		catch (IOException ex)
+		{
+			throw new Asn1ParsingException(ex.Message);
+		}
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Bsi/BsiObjectIdentifiers.cs

@@ -0,0 +1,50 @@
+namespace Org.BouncyCastle.Asn1.Bsi;
+
+public abstract class BsiObjectIdentifiers
+{
+	public static readonly DerObjectIdentifier bsi_de = new DerObjectIdentifier("0.4.0.127.0.7");
+
+	public static readonly DerObjectIdentifier id_ecc = bsi_de.Branch("1.1");
+
+	public static readonly DerObjectIdentifier ecdsa_plain_signatures = id_ecc.Branch("4.1");
+
+	public static readonly DerObjectIdentifier ecdsa_plain_SHA1 = ecdsa_plain_signatures.Branch("1");
+
+	public static readonly DerObjectIdentifier ecdsa_plain_SHA224 = ecdsa_plain_signatures.Branch("2");
+
+	public static readonly DerObjectIdentifier ecdsa_plain_SHA256 = ecdsa_plain_signatures.Branch("3");
+
+	public static readonly DerObjectIdentifier ecdsa_plain_SHA384 = ecdsa_plain_signatures.Branch("4");
+
+	public static readonly DerObjectIdentifier ecdsa_plain_SHA512 = ecdsa_plain_signatures.Branch("5");
+
+	public static readonly DerObjectIdentifier ecdsa_plain_RIPEMD160 = ecdsa_plain_signatures.Branch("6");
+
+	public static readonly DerObjectIdentifier algorithm = bsi_de.Branch("1");
+
+	public static readonly DerObjectIdentifier ecka_eg = id_ecc.Branch("5.1");
+
+	public static readonly DerObjectIdentifier ecka_eg_X963kdf = ecka_eg.Branch("1");
+
+	public static readonly DerObjectIdentifier ecka_eg_X963kdf_SHA1 = ecka_eg_X963kdf.Branch("1");
+
+	public static readonly DerObjectIdentifier ecka_eg_X963kdf_SHA224 = ecka_eg_X963kdf.Branch("2");
+
+	public static readonly DerObjectIdentifier ecka_eg_X963kdf_SHA256 = ecka_eg_X963kdf.Branch("3");
+
+	public static readonly DerObjectIdentifier ecka_eg_X963kdf_SHA384 = ecka_eg_X963kdf.Branch("4");
+
+	public static readonly DerObjectIdentifier ecka_eg_X963kdf_SHA512 = ecka_eg_X963kdf.Branch("5");
+
+	public static readonly DerObjectIdentifier ecka_eg_X963kdf_RIPEMD160 = ecka_eg_X963kdf.Branch("6");
+
+	public static readonly DerObjectIdentifier ecka_eg_SessionKDF = ecka_eg.Branch("2");
+
+	public static readonly DerObjectIdentifier ecka_eg_SessionKDF_3DES = ecka_eg_SessionKDF.Branch("1");
+
+	public static readonly DerObjectIdentifier ecka_eg_SessionKDF_AES128 = ecka_eg_SessionKDF.Branch("2");
+
+	public static readonly DerObjectIdentifier ecka_eg_SessionKDF_AES192 = ecka_eg_SessionKDF.Branch("3");
+
+	public static readonly DerObjectIdentifier ecka_eg_SessionKDF_AES256 = ecka_eg_SessionKDF.Branch("4");
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cmp/CAKeyUpdAnnContent.cs

@@ -0,0 +1,44 @@
+using System;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cmp;
+
+public class CAKeyUpdAnnContent : Asn1Encodable
+{
+	private readonly CmpCertificate oldWithNew;
+
+	private readonly CmpCertificate newWithOld;
+
+	private readonly CmpCertificate newWithNew;
+
+	public virtual CmpCertificate OldWithNew => oldWithNew;
+
+	public virtual CmpCertificate NewWithOld => newWithOld;
+
+	public virtual CmpCertificate NewWithNew => newWithNew;
+
+	private CAKeyUpdAnnContent(Asn1Sequence seq)
+	{
+		oldWithNew = CmpCertificate.GetInstance(seq[0]);
+		newWithOld = CmpCertificate.GetInstance(seq[1]);
+		newWithNew = CmpCertificate.GetInstance(seq[2]);
+	}
+
+	public static CAKeyUpdAnnContent GetInstance(object obj)
+	{
+		if (obj is CAKeyUpdAnnContent)
+		{
+			return (CAKeyUpdAnnContent)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new CAKeyUpdAnnContent((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("Invalid object: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		return new DerSequence(oldWithNew, newWithOld, newWithNew);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cmp/CertConfirmContent.cs

@@ -0,0 +1,42 @@
+using System;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cmp;
+
+public class CertConfirmContent : Asn1Encodable
+{
+	private readonly Asn1Sequence content;
+
+	private CertConfirmContent(Asn1Sequence seq)
+	{
+		content = seq;
+	}
+
+	public static CertConfirmContent GetInstance(object obj)
+	{
+		if (obj is CertConfirmContent)
+		{
+			return (CertConfirmContent)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new CertConfirmContent((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("Invalid object: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public virtual CertStatus[] ToCertStatusArray()
+	{
+		CertStatus[] array = new CertStatus[content.Count];
+		for (int i = 0; i != array.Length; i++)
+		{
+			array[i] = CertStatus.GetInstance(content[i]);
+		}
+		return array;
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		return content;
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cmp/CertOrEncCert.cs

@@ -0,0 +1,71 @@
+using System;
+using Org.BouncyCastle.Asn1.Crmf;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cmp;
+
+public class CertOrEncCert : Asn1Encodable, IAsn1Choice
+{
+	private readonly CmpCertificate certificate;
+
+	private readonly EncryptedValue encryptedCert;
+
+	public virtual CmpCertificate Certificate => certificate;
+
+	public virtual EncryptedValue EncryptedCert => encryptedCert;
+
+	private CertOrEncCert(Asn1TaggedObject tagged)
+	{
+		if (tagged.TagNo == 0)
+		{
+			certificate = CmpCertificate.GetInstance(tagged.GetObject());
+			return;
+		}
+		if (tagged.TagNo == 1)
+		{
+			encryptedCert = EncryptedValue.GetInstance(tagged.GetObject());
+			return;
+		}
+		throw new ArgumentException("unknown tag: " + tagged.TagNo, "tagged");
+	}
+
+	public static CertOrEncCert GetInstance(object obj)
+	{
+		if (obj is CertOrEncCert)
+		{
+			return (CertOrEncCert)obj;
+		}
+		if (obj is Asn1TaggedObject)
+		{
+			return new CertOrEncCert((Asn1TaggedObject)obj);
+		}
+		throw new ArgumentException("Invalid object: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public CertOrEncCert(CmpCertificate certificate)
+	{
+		if (certificate == null)
+		{
+			throw new ArgumentNullException("certificate");
+		}
+		this.certificate = certificate;
+	}
+
+	public CertOrEncCert(EncryptedValue encryptedCert)
+	{
+		if (encryptedCert == null)
+		{
+			throw new ArgumentNullException("encryptedCert");
+		}
+		this.encryptedCert = encryptedCert;
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		if (certificate != null)
+		{
+			return new DerTaggedObject(explicitly: true, 0, certificate);
+		}
+		return new DerTaggedObject(explicitly: true, 1, encryptedCert);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cmp/CertRepMessage.cs

@@ -0,0 +1,82 @@
+using System;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cmp;
+
+public class CertRepMessage : Asn1Encodable
+{
+	private readonly Asn1Sequence caPubs;
+
+	private readonly Asn1Sequence response;
+
+	private CertRepMessage(Asn1Sequence seq)
+	{
+		int index = 0;
+		if (seq.Count > 1)
+		{
+			caPubs = Asn1Sequence.GetInstance((Asn1TaggedObject)seq[index++], explicitly: true);
+		}
+		response = Asn1Sequence.GetInstance(seq[index]);
+	}
+
+	public static CertRepMessage GetInstance(object obj)
+	{
+		if (obj is CertRepMessage)
+		{
+			return (CertRepMessage)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new CertRepMessage((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("Invalid object: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public CertRepMessage(CmpCertificate[] caPubs, CertResponse[] response)
+	{
+		if (response == null)
+		{
+			throw new ArgumentNullException("response");
+		}
+		if (caPubs != null)
+		{
+			this.caPubs = new DerSequence(caPubs);
+		}
+		this.response = new DerSequence(response);
+	}
+
+	public virtual CmpCertificate[] GetCAPubs()
+	{
+		if (caPubs == null)
+		{
+			return null;
+		}
+		CmpCertificate[] array = new CmpCertificate[caPubs.Count];
+		for (int i = 0; i != array.Length; i++)
+		{
+			array[i] = CmpCertificate.GetInstance(caPubs[i]);
+		}
+		return array;
+	}
+
+	public virtual CertResponse[] GetResponse()
+	{
+		CertResponse[] array = new CertResponse[response.Count];
+		for (int i = 0; i != array.Length; i++)
+		{
+			array[i] = CertResponse.GetInstance(response[i]);
+		}
+		return array;
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector();
+		if (caPubs != null)
+		{
+			asn1EncodableVector.Add(new DerTaggedObject(explicitly: true, 1, caPubs));
+		}
+		asn1EncodableVector.Add(response);
+		return new DerSequence(asn1EncodableVector);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cmp/CertResponse.cs

@@ -0,0 +1,89 @@
+using System;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cmp;
+
+public class CertResponse : Asn1Encodable
+{
+	private readonly DerInteger certReqId;
+
+	private readonly PkiStatusInfo status;
+
+	private readonly CertifiedKeyPair certifiedKeyPair;
+
+	private readonly Asn1OctetString rspInfo;
+
+	public virtual DerInteger CertReqID => certReqId;
+
+	public virtual PkiStatusInfo Status => status;
+
+	public virtual CertifiedKeyPair CertifiedKeyPair => certifiedKeyPair;
+
+	private CertResponse(Asn1Sequence seq)
+	{
+		certReqId = DerInteger.GetInstance(seq[0]);
+		status = PkiStatusInfo.GetInstance(seq[1]);
+		if (seq.Count < 3)
+		{
+			return;
+		}
+		if (seq.Count == 3)
+		{
+			Asn1Encodable asn1Encodable = seq[2];
+			if (asn1Encodable is Asn1OctetString)
+			{
+				rspInfo = Asn1OctetString.GetInstance(asn1Encodable);
+			}
+			else
+			{
+				certifiedKeyPair = CertifiedKeyPair.GetInstance(asn1Encodable);
+			}
+		}
+		else
+		{
+			certifiedKeyPair = CertifiedKeyPair.GetInstance(seq[2]);
+			rspInfo = Asn1OctetString.GetInstance(seq[3]);
+		}
+	}
+
+	public static CertResponse GetInstance(object obj)
+	{
+		if (obj is CertResponse)
+		{
+			return (CertResponse)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new CertResponse((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("Invalid object: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public CertResponse(DerInteger certReqId, PkiStatusInfo status)
+		: this(certReqId, status, null, null)
+	{
+	}
+
+	public CertResponse(DerInteger certReqId, PkiStatusInfo status, CertifiedKeyPair certifiedKeyPair, Asn1OctetString rspInfo)
+	{
+		if (certReqId == null)
+		{
+			throw new ArgumentNullException("certReqId");
+		}
+		if (status == null)
+		{
+			throw new ArgumentNullException("status");
+		}
+		this.certReqId = certReqId;
+		this.status = status;
+		this.certifiedKeyPair = certifiedKeyPair;
+		this.rspInfo = rspInfo;
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector(certReqId, status);
+		asn1EncodableVector.AddOptional(certifiedKeyPair, rspInfo);
+		return new DerSequence(asn1EncodableVector);
+	}
+}

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

@@ -0,0 +1,63 @@
+using System;
+using Org.BouncyCastle.Math;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cmp;
+
+public class CertStatus : Asn1Encodable
+{
+	private readonly Asn1OctetString certHash;
+
+	private readonly DerInteger certReqId;
+
+	private readonly PkiStatusInfo statusInfo;
+
+	public virtual Asn1OctetString CertHash => certHash;
+
+	public virtual DerInteger CertReqID => certReqId;
+
+	public virtual PkiStatusInfo StatusInfo => statusInfo;
+
+	private CertStatus(Asn1Sequence seq)
+	{
+		certHash = Asn1OctetString.GetInstance(seq[0]);
+		certReqId = DerInteger.GetInstance(seq[1]);
+		if (seq.Count > 2)
+		{
+			statusInfo = PkiStatusInfo.GetInstance(seq[2]);
+		}
+	}
+
+	public CertStatus(byte[] certHash, BigInteger certReqId)
+	{
+		this.certHash = new DerOctetString(certHash);
+		this.certReqId = new DerInteger(certReqId);
+	}
+
+	public CertStatus(byte[] certHash, BigInteger certReqId, PkiStatusInfo statusInfo)
+	{
+		this.certHash = new DerOctetString(certHash);
+		this.certReqId = new DerInteger(certReqId);
+		this.statusInfo = statusInfo;
+	}
+
+	public static CertStatus GetInstance(object obj)
+	{
+		if (obj is CertStatus)
+		{
+			return (CertStatus)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new CertStatus((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("Invalid object: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector(certHash, certReqId);
+		asn1EncodableVector.AddOptional(statusInfo);
+		return new DerSequence(asn1EncodableVector);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cmp/CertifiedKeyPair.cs

@@ -0,0 +1,89 @@
+using System;
+using Org.BouncyCastle.Asn1.Crmf;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cmp;
+
+public class CertifiedKeyPair : Asn1Encodable
+{
+	private readonly CertOrEncCert certOrEncCert;
+
+	private readonly EncryptedValue privateKey;
+
+	private readonly PkiPublicationInfo publicationInfo;
+
+	public virtual CertOrEncCert CertOrEncCert => certOrEncCert;
+
+	public virtual EncryptedValue PrivateKey => privateKey;
+
+	public virtual PkiPublicationInfo PublicationInfo => publicationInfo;
+
+	private CertifiedKeyPair(Asn1Sequence seq)
+	{
+		certOrEncCert = CertOrEncCert.GetInstance(seq[0]);
+		if (seq.Count < 2)
+		{
+			return;
+		}
+		if (seq.Count == 2)
+		{
+			Asn1TaggedObject instance = Asn1TaggedObject.GetInstance(seq[1]);
+			if (instance.TagNo == 0)
+			{
+				privateKey = EncryptedValue.GetInstance(instance.GetObject());
+			}
+			else
+			{
+				publicationInfo = PkiPublicationInfo.GetInstance(instance.GetObject());
+			}
+		}
+		else
+		{
+			privateKey = EncryptedValue.GetInstance(Asn1TaggedObject.GetInstance(seq[1]));
+			publicationInfo = PkiPublicationInfo.GetInstance(Asn1TaggedObject.GetInstance(seq[2]));
+		}
+	}
+
+	public static CertifiedKeyPair GetInstance(object obj)
+	{
+		if (obj is CertifiedKeyPair)
+		{
+			return (CertifiedKeyPair)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new CertifiedKeyPair((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("Invalid object: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public CertifiedKeyPair(CertOrEncCert certOrEncCert)
+		: this(certOrEncCert, null, null)
+	{
+	}
+
+	public CertifiedKeyPair(CertOrEncCert certOrEncCert, EncryptedValue privateKey, PkiPublicationInfo publicationInfo)
+	{
+		if (certOrEncCert == null)
+		{
+			throw new ArgumentNullException("certOrEncCert");
+		}
+		this.certOrEncCert = certOrEncCert;
+		this.privateKey = privateKey;
+		this.publicationInfo = publicationInfo;
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector(certOrEncCert);
+		if (privateKey != null)
+		{
+			asn1EncodableVector.Add(new DerTaggedObject(explicitly: true, 0, privateKey));
+		}
+		if (publicationInfo != null)
+		{
+			asn1EncodableVector.Add(new DerTaggedObject(explicitly: true, 1, publicationInfo));
+		}
+		return new DerSequence(asn1EncodableVector);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cmp/Challenge.cs

@@ -0,0 +1,49 @@
+using System;
+using Org.BouncyCastle.Asn1.X509;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cmp;
+
+public class Challenge : Asn1Encodable
+{
+	private readonly AlgorithmIdentifier owf;
+
+	private readonly Asn1OctetString witness;
+
+	private readonly Asn1OctetString challenge;
+
+	public virtual AlgorithmIdentifier Owf => owf;
+
+	private Challenge(Asn1Sequence seq)
+	{
+		int index = 0;
+		if (seq.Count == 3)
+		{
+			owf = AlgorithmIdentifier.GetInstance(seq[index++]);
+		}
+		witness = Asn1OctetString.GetInstance(seq[index++]);
+		challenge = Asn1OctetString.GetInstance(seq[index]);
+	}
+
+	public static Challenge GetInstance(object obj)
+	{
+		if (obj is Challenge)
+		{
+			return (Challenge)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new Challenge((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("Invalid object: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector();
+		asn1EncodableVector.AddOptional(owf);
+		asn1EncodableVector.Add(witness);
+		asn1EncodableVector.Add(challenge);
+		return new DerSequence(asn1EncodableVector);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cmp/CmpCertificate.cs

@@ -0,0 +1,58 @@
+using System;
+using Org.BouncyCastle.Asn1.X509;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cmp;
+
+public class CmpCertificate : Asn1Encodable, IAsn1Choice
+{
+	private readonly X509CertificateStructure x509v3PKCert;
+
+	private readonly AttributeCertificate x509v2AttrCert;
+
+	public virtual bool IsX509v3PKCert => x509v3PKCert != null;
+
+	public virtual X509CertificateStructure X509v3PKCert => x509v3PKCert;
+
+	public virtual AttributeCertificate X509v2AttrCert => x509v2AttrCert;
+
+	public CmpCertificate(AttributeCertificate x509v2AttrCert)
+	{
+		this.x509v2AttrCert = x509v2AttrCert;
+	}
+
+	public CmpCertificate(X509CertificateStructure x509v3PKCert)
+	{
+		if (x509v3PKCert.Version != 3)
+		{
+			throw new ArgumentException("only version 3 certificates allowed", "x509v3PKCert");
+		}
+		this.x509v3PKCert = x509v3PKCert;
+	}
+
+	public static CmpCertificate GetInstance(object obj)
+	{
+		if (obj is CmpCertificate)
+		{
+			return (CmpCertificate)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new CmpCertificate(X509CertificateStructure.GetInstance(obj));
+		}
+		if (obj is Asn1TaggedObject)
+		{
+			return new CmpCertificate(AttributeCertificate.GetInstance(((Asn1TaggedObject)obj).GetObject()));
+		}
+		throw new ArgumentException("Invalid object: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		if (x509v2AttrCert != null)
+		{
+			return new DerTaggedObject(explicitly: true, 1, x509v2AttrCert);
+		}
+		return x509v3PKCert.ToAsn1Object();
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cmp/CmpObjectIdentifiers.cs

@@ -0,0 +1,56 @@
+namespace Org.BouncyCastle.Asn1.Cmp;
+
+public abstract class CmpObjectIdentifiers
+{
+	public static readonly DerObjectIdentifier passwordBasedMac = new DerObjectIdentifier("1.2.840.113533.7.66.13");
+
+	public static readonly DerObjectIdentifier dhBasedMac = new DerObjectIdentifier("1.2.840.113533.7.66.30");
+
+	public static readonly DerObjectIdentifier it_caProtEncCert = new DerObjectIdentifier("1.3.6.1.5.5.7.4.1");
+
+	public static readonly DerObjectIdentifier it_signKeyPairTypes = new DerObjectIdentifier("1.3.6.1.5.5.7.4.2");
+
+	public static readonly DerObjectIdentifier it_encKeyPairTypes = new DerObjectIdentifier("1.3.6.1.5.5.7.4.3");
+
+	public static readonly DerObjectIdentifier it_preferredSymAlg = new DerObjectIdentifier("1.3.6.1.5.5.7.4.4");
+
+	public static readonly DerObjectIdentifier it_caKeyUpdateInfo = new DerObjectIdentifier("1.3.6.1.5.5.7.4.5");
+
+	public static readonly DerObjectIdentifier it_currentCRL = new DerObjectIdentifier("1.3.6.1.5.5.7.4.6");
+
+	public static readonly DerObjectIdentifier it_unsupportedOIDs = new DerObjectIdentifier("1.3.6.1.5.5.7.4.7");
+
+	public static readonly DerObjectIdentifier it_keyPairParamReq = new DerObjectIdentifier("1.3.6.1.5.5.7.4.10");
+
+	public static readonly DerObjectIdentifier it_keyPairParamRep = new DerObjectIdentifier("1.3.6.1.5.5.7.4.11");
+
+	public static readonly DerObjectIdentifier it_revPassphrase = new DerObjectIdentifier("1.3.6.1.5.5.7.4.12");
+
+	public static readonly DerObjectIdentifier it_implicitConfirm = new DerObjectIdentifier("1.3.6.1.5.5.7.4.13");
+
+	public static readonly DerObjectIdentifier it_confirmWaitTime = new DerObjectIdentifier("1.3.6.1.5.5.7.4.14");
+
+	public static readonly DerObjectIdentifier it_origPKIMessage = new DerObjectIdentifier("1.3.6.1.5.5.7.4.15");
+
+	public static readonly DerObjectIdentifier it_suppLangTags = new DerObjectIdentifier("1.3.6.1.5.5.7.4.16");
+
+	public static readonly DerObjectIdentifier regCtrl_regToken = new DerObjectIdentifier("1.3.6.1.5.5.7.5.1.1");
+
+	public static readonly DerObjectIdentifier regCtrl_authenticator = new DerObjectIdentifier("1.3.6.1.5.5.7.5.1.2");
+
+	public static readonly DerObjectIdentifier regCtrl_pkiPublicationInfo = new DerObjectIdentifier("1.3.6.1.5.5.7.5.1.3");
+
+	public static readonly DerObjectIdentifier regCtrl_pkiArchiveOptions = new DerObjectIdentifier("1.3.6.1.5.5.7.5.1.4");
+
+	public static readonly DerObjectIdentifier regCtrl_oldCertID = new DerObjectIdentifier("1.3.6.1.5.5.7.5.1.5");
+
+	public static readonly DerObjectIdentifier regCtrl_protocolEncrKey = new DerObjectIdentifier("1.3.6.1.5.5.7.5.1.6");
+
+	public static readonly DerObjectIdentifier regCtrl_altCertTemplate = new DerObjectIdentifier("1.3.6.1.5.5.7.5.1.7");
+
+	public static readonly DerObjectIdentifier regInfo_utf8Pairs = new DerObjectIdentifier("1.3.6.1.5.5.7.5.2.1");
+
+	public static readonly DerObjectIdentifier regInfo_certReq = new DerObjectIdentifier("1.3.6.1.5.5.7.5.2.2");
+
+	public static readonly DerObjectIdentifier ct_encKeyWithID = new DerObjectIdentifier("1.2.840.113549.1.9.16.1.21");
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cmp/CrlAnnContent.cs

@@ -0,0 +1,43 @@
+using System;
+using Org.BouncyCastle.Asn1.X509;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cmp;
+
+public class CrlAnnContent : Asn1Encodable
+{
+	private readonly Asn1Sequence content;
+
+	private CrlAnnContent(Asn1Sequence seq)
+	{
+		content = seq;
+	}
+
+	public static CrlAnnContent GetInstance(object obj)
+	{
+		if (obj is CrlAnnContent)
+		{
+			return (CrlAnnContent)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new CrlAnnContent((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("Invalid object: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public virtual CertificateList[] ToCertificateListArray()
+	{
+		CertificateList[] array = new CertificateList[content.Count];
+		for (int i = 0; i != array.Length; i++)
+		{
+			array[i] = CertificateList.GetInstance(content[i]);
+		}
+		return array;
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		return content;
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cmp/ErrorMsgContent.cs

@@ -0,0 +1,72 @@
+using System;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cmp;
+
+public class ErrorMsgContent : Asn1Encodable
+{
+	private readonly PkiStatusInfo pkiStatusInfo;
+
+	private readonly DerInteger errorCode;
+
+	private readonly PkiFreeText errorDetails;
+
+	public virtual PkiStatusInfo PkiStatusInfo => pkiStatusInfo;
+
+	public virtual DerInteger ErrorCode => errorCode;
+
+	public virtual PkiFreeText ErrorDetails => errorDetails;
+
+	private ErrorMsgContent(Asn1Sequence seq)
+	{
+		pkiStatusInfo = PkiStatusInfo.GetInstance(seq[0]);
+		for (int i = 1; i < seq.Count; i++)
+		{
+			Asn1Encodable asn1Encodable = seq[i];
+			if (asn1Encodable is DerInteger)
+			{
+				errorCode = DerInteger.GetInstance(asn1Encodable);
+			}
+			else
+			{
+				errorDetails = PkiFreeText.GetInstance(asn1Encodable);
+			}
+		}
+	}
+
+	public static ErrorMsgContent GetInstance(object obj)
+	{
+		if (obj is ErrorMsgContent)
+		{
+			return (ErrorMsgContent)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new ErrorMsgContent((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("Invalid object: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public ErrorMsgContent(PkiStatusInfo pkiStatusInfo)
+		: this(pkiStatusInfo, null, null)
+	{
+	}
+
+	public ErrorMsgContent(PkiStatusInfo pkiStatusInfo, DerInteger errorCode, PkiFreeText errorDetails)
+	{
+		if (pkiStatusInfo == null)
+		{
+			throw new ArgumentNullException("pkiStatusInfo");
+		}
+		this.pkiStatusInfo = pkiStatusInfo;
+		this.errorCode = errorCode;
+		this.errorDetails = errorDetails;
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector(pkiStatusInfo);
+		asn1EncodableVector.AddOptional(errorCode, errorDetails);
+		return new DerSequence(asn1EncodableVector);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cmp/GenMsgContent.cs

@@ -0,0 +1,47 @@
+using System;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cmp;
+
+public class GenMsgContent : Asn1Encodable
+{
+	private readonly Asn1Sequence content;
+
+	private GenMsgContent(Asn1Sequence seq)
+	{
+		content = seq;
+	}
+
+	public static GenMsgContent GetInstance(object obj)
+	{
+		if (obj is GenMsgContent)
+		{
+			return (GenMsgContent)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new GenMsgContent((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("Invalid object: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public GenMsgContent(params InfoTypeAndValue[] itv)
+	{
+		content = new DerSequence(itv);
+	}
+
+	public virtual InfoTypeAndValue[] ToInfoTypeAndValueArray()
+	{
+		InfoTypeAndValue[] array = new InfoTypeAndValue[content.Count];
+		for (int i = 0; i != array.Length; i++)
+		{
+			array[i] = InfoTypeAndValue.GetInstance(content[i]);
+		}
+		return array;
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		return content;
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cmp/GenRepContent.cs

@@ -0,0 +1,47 @@
+using System;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cmp;
+
+public class GenRepContent : Asn1Encodable
+{
+	private readonly Asn1Sequence content;
+
+	private GenRepContent(Asn1Sequence seq)
+	{
+		content = seq;
+	}
+
+	public static GenRepContent GetInstance(object obj)
+	{
+		if (obj is GenRepContent)
+		{
+			return (GenRepContent)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new GenRepContent((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("Invalid object: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public GenRepContent(params InfoTypeAndValue[] itv)
+	{
+		content = new DerSequence(itv);
+	}
+
+	public virtual InfoTypeAndValue[] ToInfoTypeAndValueArray()
+	{
+		InfoTypeAndValue[] array = new InfoTypeAndValue[content.Count];
+		for (int i = 0; i != array.Length; i++)
+		{
+			array[i] = InfoTypeAndValue.GetInstance(content[i]);
+		}
+		return array;
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		return content;
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cmp/InfoTypeAndValue.cs

@@ -0,0 +1,59 @@
+using System;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cmp;
+
+public class InfoTypeAndValue : Asn1Encodable
+{
+	private readonly DerObjectIdentifier infoType;
+
+	private readonly Asn1Encodable infoValue;
+
+	public virtual DerObjectIdentifier InfoType => infoType;
+
+	public virtual Asn1Encodable InfoValue => infoValue;
+
+	private InfoTypeAndValue(Asn1Sequence seq)
+	{
+		infoType = DerObjectIdentifier.GetInstance(seq[0]);
+		if (seq.Count > 1)
+		{
+			infoValue = seq[1];
+		}
+	}
+
+	public static InfoTypeAndValue GetInstance(object obj)
+	{
+		if (obj is InfoTypeAndValue)
+		{
+			return (InfoTypeAndValue)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new InfoTypeAndValue((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("Invalid object: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public InfoTypeAndValue(DerObjectIdentifier infoType)
+	{
+		this.infoType = infoType;
+		infoValue = null;
+	}
+
+	public InfoTypeAndValue(DerObjectIdentifier infoType, Asn1Encodable optionalValue)
+	{
+		this.infoType = infoType;
+		infoValue = optionalValue;
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector(infoType);
+		if (infoValue != null)
+		{
+			asn1EncodableVector.Add(infoValue);
+		}
+		return new DerSequence(asn1EncodableVector);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cmp/KeyRecRepContent.cs

@@ -0,0 +1,100 @@
+using System;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cmp;
+
+public class KeyRecRepContent : Asn1Encodable
+{
+	private readonly PkiStatusInfo status;
+
+	private readonly CmpCertificate newSigCert;
+
+	private readonly Asn1Sequence caCerts;
+
+	private readonly Asn1Sequence keyPairHist;
+
+	public virtual PkiStatusInfo Status => status;
+
+	public virtual CmpCertificate NewSigCert => newSigCert;
+
+	private KeyRecRepContent(Asn1Sequence seq)
+	{
+		status = PkiStatusInfo.GetInstance(seq[0]);
+		for (int i = 1; i < seq.Count; i++)
+		{
+			Asn1TaggedObject instance = Asn1TaggedObject.GetInstance(seq[i]);
+			switch (instance.TagNo)
+			{
+			case 0:
+				newSigCert = CmpCertificate.GetInstance(instance.GetObject());
+				break;
+			case 1:
+				caCerts = Asn1Sequence.GetInstance(instance.GetObject());
+				break;
+			case 2:
+				keyPairHist = Asn1Sequence.GetInstance(instance.GetObject());
+				break;
+			default:
+				throw new ArgumentException("unknown tag number: " + instance.TagNo, "seq");
+			}
+		}
+	}
+
+	public static KeyRecRepContent GetInstance(object obj)
+	{
+		if (obj is KeyRecRepContent)
+		{
+			return (KeyRecRepContent)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new KeyRecRepContent((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("Invalid object: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public virtual CmpCertificate[] GetCACerts()
+	{
+		if (caCerts == null)
+		{
+			return null;
+		}
+		CmpCertificate[] array = new CmpCertificate[caCerts.Count];
+		for (int i = 0; i != array.Length; i++)
+		{
+			array[i] = CmpCertificate.GetInstance(caCerts[i]);
+		}
+		return array;
+	}
+
+	public virtual CertifiedKeyPair[] GetKeyPairHist()
+	{
+		if (keyPairHist == null)
+		{
+			return null;
+		}
+		CertifiedKeyPair[] array = new CertifiedKeyPair[keyPairHist.Count];
+		for (int i = 0; i != array.Length; i++)
+		{
+			array[i] = CertifiedKeyPair.GetInstance(keyPairHist[i]);
+		}
+		return array;
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		Asn1EncodableVector v = new Asn1EncodableVector(status);
+		AddOptional(v, 0, newSigCert);
+		AddOptional(v, 1, caCerts);
+		AddOptional(v, 2, keyPairHist);
+		return new DerSequence(v);
+	}
+
+	private void AddOptional(Asn1EncodableVector v, int tagNo, Asn1Encodable obj)
+	{
+		if (obj != null)
+		{
+			v.Add(new DerTaggedObject(explicitly: true, tagNo, obj));
+		}
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cmp/OobCertHash.cs

@@ -0,0 +1,67 @@
+using System;
+using Org.BouncyCastle.Asn1.Crmf;
+using Org.BouncyCastle.Asn1.X509;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cmp;
+
+public class OobCertHash : Asn1Encodable
+{
+	private readonly AlgorithmIdentifier hashAlg;
+
+	private readonly CertId certId;
+
+	private readonly DerBitString hashVal;
+
+	public virtual AlgorithmIdentifier HashAlg => hashAlg;
+
+	public virtual CertId CertID => certId;
+
+	private OobCertHash(Asn1Sequence seq)
+	{
+		int num = seq.Count - 1;
+		hashVal = DerBitString.GetInstance(seq[num--]);
+		for (int num2 = num; num2 >= 0; num2--)
+		{
+			Asn1TaggedObject asn1TaggedObject = (Asn1TaggedObject)seq[num2];
+			if (asn1TaggedObject.TagNo == 0)
+			{
+				hashAlg = AlgorithmIdentifier.GetInstance(asn1TaggedObject, explicitly: true);
+			}
+			else
+			{
+				certId = CertId.GetInstance(asn1TaggedObject, isExplicit: true);
+			}
+		}
+	}
+
+	public static OobCertHash GetInstance(object obj)
+	{
+		if (obj is OobCertHash)
+		{
+			return (OobCertHash)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new OobCertHash((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("Invalid object: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector();
+		AddOptional(asn1EncodableVector, 0, hashAlg);
+		AddOptional(asn1EncodableVector, 1, certId);
+		asn1EncodableVector.Add(hashVal);
+		return new DerSequence(asn1EncodableVector);
+	}
+
+	private void AddOptional(Asn1EncodableVector v, int tagNo, Asn1Encodable obj)
+	{
+		if (obj != null)
+		{
+			v.Add(new DerTaggedObject(explicitly: true, tagNo, obj));
+		}
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cmp/PbmParameter.cs

@@ -0,0 +1,63 @@
+using System;
+using Org.BouncyCastle.Asn1.X509;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cmp;
+
+public class PbmParameter : Asn1Encodable
+{
+	private Asn1OctetString salt;
+
+	private AlgorithmIdentifier owf;
+
+	private DerInteger iterationCount;
+
+	private AlgorithmIdentifier mac;
+
+	public virtual Asn1OctetString Salt => salt;
+
+	public virtual AlgorithmIdentifier Owf => owf;
+
+	public virtual DerInteger IterationCount => iterationCount;
+
+	public virtual AlgorithmIdentifier Mac => mac;
+
+	private PbmParameter(Asn1Sequence seq)
+	{
+		salt = Asn1OctetString.GetInstance(seq[0]);
+		owf = AlgorithmIdentifier.GetInstance(seq[1]);
+		iterationCount = DerInteger.GetInstance(seq[2]);
+		mac = AlgorithmIdentifier.GetInstance(seq[3]);
+	}
+
+	public static PbmParameter GetInstance(object obj)
+	{
+		if (obj is PbmParameter)
+		{
+			return (PbmParameter)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new PbmParameter((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("Invalid object: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public PbmParameter(byte[] salt, AlgorithmIdentifier owf, int iterationCount, AlgorithmIdentifier mac)
+		: this(new DerOctetString(salt), owf, new DerInteger(iterationCount), mac)
+	{
+	}
+
+	public PbmParameter(Asn1OctetString salt, AlgorithmIdentifier owf, DerInteger iterationCount, AlgorithmIdentifier mac)
+	{
+		this.salt = salt;
+		this.owf = owf;
+		this.iterationCount = iterationCount;
+		this.mac = mac;
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		return new DerSequence(salt, owf, iterationCount, mac);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cmp/PkiBody.cs

@@ -0,0 +1,136 @@
+using System;
+using Org.BouncyCastle.Asn1.Crmf;
+using Org.BouncyCastle.Asn1.Pkcs;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cmp;
+
+public class PkiBody : Asn1Encodable, IAsn1Choice
+{
+	public const int TYPE_INIT_REQ = 0;
+
+	public const int TYPE_INIT_REP = 1;
+
+	public const int TYPE_CERT_REQ = 2;
+
+	public const int TYPE_CERT_REP = 3;
+
+	public const int TYPE_P10_CERT_REQ = 4;
+
+	public const int TYPE_POPO_CHALL = 5;
+
+	public const int TYPE_POPO_REP = 6;
+
+	public const int TYPE_KEY_UPDATE_REQ = 7;
+
+	public const int TYPE_KEY_UPDATE_REP = 8;
+
+	public const int TYPE_KEY_RECOVERY_REQ = 9;
+
+	public const int TYPE_KEY_RECOVERY_REP = 10;
+
+	public const int TYPE_REVOCATION_REQ = 11;
+
+	public const int TYPE_REVOCATION_REP = 12;
+
+	public const int TYPE_CROSS_CERT_REQ = 13;
+
+	public const int TYPE_CROSS_CERT_REP = 14;
+
+	public const int TYPE_CA_KEY_UPDATE_ANN = 15;
+
+	public const int TYPE_CERT_ANN = 16;
+
+	public const int TYPE_REVOCATION_ANN = 17;
+
+	public const int TYPE_CRL_ANN = 18;
+
+	public const int TYPE_CONFIRM = 19;
+
+	public const int TYPE_NESTED = 20;
+
+	public const int TYPE_GEN_MSG = 21;
+
+	public const int TYPE_GEN_REP = 22;
+
+	public const int TYPE_ERROR = 23;
+
+	public const int TYPE_CERT_CONFIRM = 24;
+
+	public const int TYPE_POLL_REQ = 25;
+
+	public const int TYPE_POLL_REP = 26;
+
+	private int tagNo;
+
+	private Asn1Encodable body;
+
+	public virtual int Type => tagNo;
+
+	public virtual Asn1Encodable Content => body;
+
+	public static PkiBody GetInstance(object obj)
+	{
+		if (obj is PkiBody)
+		{
+			return (PkiBody)obj;
+		}
+		if (obj is Asn1TaggedObject)
+		{
+			return new PkiBody((Asn1TaggedObject)obj);
+		}
+		throw new ArgumentException("Invalid object: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	private PkiBody(Asn1TaggedObject tagged)
+	{
+		tagNo = tagged.TagNo;
+		body = GetBodyForType(tagNo, tagged.GetObject());
+	}
+
+	public PkiBody(int type, Asn1Encodable content)
+	{
+		tagNo = type;
+		body = GetBodyForType(type, content);
+	}
+
+	private static Asn1Encodable GetBodyForType(int type, Asn1Encodable o)
+	{
+		return type switch
+		{
+			0 => CertReqMessages.GetInstance(o), 
+			1 => CertRepMessage.GetInstance(o), 
+			2 => CertReqMessages.GetInstance(o), 
+			3 => CertRepMessage.GetInstance(o), 
+			4 => CertificationRequest.GetInstance(o), 
+			5 => PopoDecKeyChallContent.GetInstance(o), 
+			6 => PopoDecKeyRespContent.GetInstance(o), 
+			7 => CertReqMessages.GetInstance(o), 
+			8 => CertRepMessage.GetInstance(o), 
+			9 => CertReqMessages.GetInstance(o), 
+			10 => KeyRecRepContent.GetInstance(o), 
+			11 => RevReqContent.GetInstance(o), 
+			12 => RevRepContent.GetInstance(o), 
+			13 => CertReqMessages.GetInstance(o), 
+			14 => CertRepMessage.GetInstance(o), 
+			15 => CAKeyUpdAnnContent.GetInstance(o), 
+			16 => CmpCertificate.GetInstance(o), 
+			17 => RevAnnContent.GetInstance(o), 
+			18 => CrlAnnContent.GetInstance(o), 
+			19 => PkiConfirmContent.GetInstance(o), 
+			20 => PkiMessages.GetInstance(o), 
+			21 => GenMsgContent.GetInstance(o), 
+			22 => GenRepContent.GetInstance(o), 
+			23 => ErrorMsgContent.GetInstance(o), 
+			24 => CertConfirmContent.GetInstance(o), 
+			25 => PollReqContent.GetInstance(o), 
+			26 => PollRepContent.GetInstance(o), 
+			_ => throw new ArgumentException("unknown tag number: " + type, "type"), 
+		};
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		return new DerTaggedObject(explicitly: true, tagNo, body);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cmp/PkiConfirmContent.cs

@@ -0,0 +1,25 @@
+using System;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cmp;
+
+public class PkiConfirmContent : Asn1Encodable
+{
+	public static PkiConfirmContent GetInstance(object obj)
+	{
+		if (obj is PkiConfirmContent)
+		{
+			return (PkiConfirmContent)obj;
+		}
+		if (obj is Asn1Null)
+		{
+			return new PkiConfirmContent();
+		}
+		throw new ArgumentException("Invalid object: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		return DerNull.Instance;
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cmp/PkiFailureInfo.cs

@@ -0,0 +1,73 @@
+namespace Org.BouncyCastle.Asn1.Cmp;
+
+public class PkiFailureInfo : DerBitString
+{
+	public const int BadAlg = 128;
+
+	public const int BadMessageCheck = 64;
+
+	public const int BadRequest = 32;
+
+	public const int BadTime = 16;
+
+	public const int BadCertId = 8;
+
+	public const int BadDataFormat = 4;
+
+	public const int WrongAuthority = 2;
+
+	public const int IncorrectData = 1;
+
+	public const int MissingTimeStamp = 32768;
+
+	public const int BadPop = 16384;
+
+	public const int CertRevoked = 8192;
+
+	public const int CertConfirmed = 4096;
+
+	public const int WrongIntegrity = 2048;
+
+	public const int BadRecipientNonce = 1024;
+
+	public const int TimeNotAvailable = 512;
+
+	public const int UnacceptedPolicy = 256;
+
+	public const int UnacceptedExtension = 8388608;
+
+	public const int AddInfoNotAvailable = 4194304;
+
+	public const int BadSenderNonce = 2097152;
+
+	public const int BadCertTemplate = 1048576;
+
+	public const int SignerNotTrusted = 524288;
+
+	public const int TransactionIdInUse = 262144;
+
+	public const int UnsupportedVersion = 131072;
+
+	public const int NotAuthorized = 65536;
+
+	public const int SystemUnavail = int.MinValue;
+
+	public const int SystemFailure = 1073741824;
+
+	public const int DuplicateCertReq = 536870912;
+
+	public PkiFailureInfo(int info)
+		: base(info)
+	{
+	}
+
+	public PkiFailureInfo(DerBitString info)
+		: base(info.GetBytes(), info.PadBits)
+	{
+	}
+
+	public override string ToString()
+	{
+		return "PkiFailureInfo: 0x" + IntValue.ToString("X");
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cmp/PkiFreeText.cs

@@ -0,0 +1,62 @@
+using System;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cmp;
+
+public class PkiFreeText : Asn1Encodable
+{
+	internal Asn1Sequence strings;
+
+	[Obsolete("Use 'Count' property instead")]
+	public int Size => strings.Count;
+
+	public int Count => strings.Count;
+
+	public DerUtf8String this[int index] => (DerUtf8String)strings[index];
+
+	public static PkiFreeText GetInstance(Asn1TaggedObject obj, bool isExplicit)
+	{
+		return GetInstance(Asn1Sequence.GetInstance(obj, isExplicit));
+	}
+
+	public static PkiFreeText GetInstance(object obj)
+	{
+		if (obj is PkiFreeText)
+		{
+			return (PkiFreeText)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new PkiFreeText((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("Unknown object in factory: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public PkiFreeText(Asn1Sequence seq)
+	{
+		foreach (object item in seq)
+		{
+			if (!(item is DerUtf8String))
+			{
+				throw new ArgumentException("attempt to insert non UTF8 STRING into PkiFreeText");
+			}
+		}
+		strings = seq;
+	}
+
+	public PkiFreeText(DerUtf8String p)
+	{
+		strings = new DerSequence(p);
+	}
+
+	[Obsolete("Use 'object[index]' syntax instead")]
+	public DerUtf8String GetStringAt(int index)
+	{
+		return this[index];
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		return strings;
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cmp/PkiHeader.cs

@@ -0,0 +1,165 @@
+using System;
+using Org.BouncyCastle.Asn1.X509;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cmp;
+
+public class PkiHeader : Asn1Encodable
+{
+	public static readonly GeneralName NULL_NAME = new GeneralName(X509Name.GetInstance(new DerSequence()));
+
+	public static readonly int CMP_1999 = 1;
+
+	public static readonly int CMP_2000 = 2;
+
+	private readonly DerInteger pvno;
+
+	private readonly GeneralName sender;
+
+	private readonly GeneralName recipient;
+
+	private readonly DerGeneralizedTime messageTime;
+
+	private readonly AlgorithmIdentifier protectionAlg;
+
+	private readonly Asn1OctetString senderKID;
+
+	private readonly Asn1OctetString recipKID;
+
+	private readonly Asn1OctetString transactionID;
+
+	private readonly Asn1OctetString senderNonce;
+
+	private readonly Asn1OctetString recipNonce;
+
+	private readonly PkiFreeText freeText;
+
+	private readonly Asn1Sequence generalInfo;
+
+	public virtual DerInteger Pvno => pvno;
+
+	public virtual GeneralName Sender => sender;
+
+	public virtual GeneralName Recipient => recipient;
+
+	public virtual DerGeneralizedTime MessageTime => messageTime;
+
+	public virtual AlgorithmIdentifier ProtectionAlg => protectionAlg;
+
+	public virtual Asn1OctetString SenderKID => senderKID;
+
+	public virtual Asn1OctetString RecipKID => recipKID;
+
+	public virtual Asn1OctetString TransactionID => transactionID;
+
+	public virtual Asn1OctetString SenderNonce => senderNonce;
+
+	public virtual Asn1OctetString RecipNonce => recipNonce;
+
+	public virtual PkiFreeText FreeText => freeText;
+
+	private PkiHeader(Asn1Sequence seq)
+	{
+		pvno = DerInteger.GetInstance(seq[0]);
+		sender = GeneralName.GetInstance(seq[1]);
+		recipient = GeneralName.GetInstance(seq[2]);
+		for (int i = 3; i < seq.Count; i++)
+		{
+			Asn1TaggedObject asn1TaggedObject = (Asn1TaggedObject)seq[i];
+			switch (asn1TaggedObject.TagNo)
+			{
+			case 0:
+				messageTime = DerGeneralizedTime.GetInstance(asn1TaggedObject, isExplicit: true);
+				break;
+			case 1:
+				protectionAlg = AlgorithmIdentifier.GetInstance(asn1TaggedObject, explicitly: true);
+				break;
+			case 2:
+				senderKID = Asn1OctetString.GetInstance(asn1TaggedObject, isExplicit: true);
+				break;
+			case 3:
+				recipKID = Asn1OctetString.GetInstance(asn1TaggedObject, isExplicit: true);
+				break;
+			case 4:
+				transactionID = Asn1OctetString.GetInstance(asn1TaggedObject, isExplicit: true);
+				break;
+			case 5:
+				senderNonce = Asn1OctetString.GetInstance(asn1TaggedObject, isExplicit: true);
+				break;
+			case 6:
+				recipNonce = Asn1OctetString.GetInstance(asn1TaggedObject, isExplicit: true);
+				break;
+			case 7:
+				freeText = PkiFreeText.GetInstance(asn1TaggedObject, isExplicit: true);
+				break;
+			case 8:
+				generalInfo = Asn1Sequence.GetInstance(asn1TaggedObject, explicitly: true);
+				break;
+			default:
+				throw new ArgumentException("unknown tag number: " + asn1TaggedObject.TagNo, "seq");
+			}
+		}
+	}
+
+	public static PkiHeader GetInstance(object obj)
+	{
+		if (obj is PkiHeader)
+		{
+			return (PkiHeader)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new PkiHeader((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("Invalid object: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public PkiHeader(int pvno, GeneralName sender, GeneralName recipient)
+		: this(new DerInteger(pvno), sender, recipient)
+	{
+	}
+
+	private PkiHeader(DerInteger pvno, GeneralName sender, GeneralName recipient)
+	{
+		this.pvno = pvno;
+		this.sender = sender;
+		this.recipient = recipient;
+	}
+
+	public virtual InfoTypeAndValue[] GetGeneralInfo()
+	{
+		if (generalInfo == null)
+		{
+			return null;
+		}
+		InfoTypeAndValue[] array = new InfoTypeAndValue[generalInfo.Count];
+		for (int i = 0; i < array.Length; i++)
+		{
+			array[i] = InfoTypeAndValue.GetInstance(generalInfo[i]);
+		}
+		return array;
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		Asn1EncodableVector v = new Asn1EncodableVector(pvno, sender, recipient);
+		AddOptional(v, 0, messageTime);
+		AddOptional(v, 1, protectionAlg);
+		AddOptional(v, 2, senderKID);
+		AddOptional(v, 3, recipKID);
+		AddOptional(v, 4, transactionID);
+		AddOptional(v, 5, senderNonce);
+		AddOptional(v, 6, recipNonce);
+		AddOptional(v, 7, freeText);
+		AddOptional(v, 8, generalInfo);
+		return new DerSequence(v);
+	}
+
+	private static void AddOptional(Asn1EncodableVector v, int tagNo, Asn1Encodable obj)
+	{
+		if (obj != null)
+		{
+			v.Add(new DerTaggedObject(explicitly: true, tagNo, obj));
+		}
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cmp/PkiHeaderBuilder.cs

@@ -0,0 +1,183 @@
+using Org.BouncyCastle.Asn1.X509;
+
+namespace Org.BouncyCastle.Asn1.Cmp;
+
+public class PkiHeaderBuilder
+{
+	private DerInteger pvno;
+
+	private GeneralName sender;
+
+	private GeneralName recipient;
+
+	private DerGeneralizedTime messageTime;
+
+	private AlgorithmIdentifier protectionAlg;
+
+	private Asn1OctetString senderKID;
+
+	private Asn1OctetString recipKID;
+
+	private Asn1OctetString transactionID;
+
+	private Asn1OctetString senderNonce;
+
+	private Asn1OctetString recipNonce;
+
+	private PkiFreeText freeText;
+
+	private Asn1Sequence generalInfo;
+
+	public PkiHeaderBuilder(int pvno, GeneralName sender, GeneralName recipient)
+		: this(new DerInteger(pvno), sender, recipient)
+	{
+	}
+
+	private PkiHeaderBuilder(DerInteger pvno, GeneralName sender, GeneralName recipient)
+	{
+		this.pvno = pvno;
+		this.sender = sender;
+		this.recipient = recipient;
+	}
+
+	public virtual PkiHeaderBuilder SetMessageTime(DerGeneralizedTime time)
+	{
+		messageTime = time;
+		return this;
+	}
+
+	public virtual PkiHeaderBuilder SetProtectionAlg(AlgorithmIdentifier aid)
+	{
+		protectionAlg = aid;
+		return this;
+	}
+
+	public virtual PkiHeaderBuilder SetSenderKID(byte[] kid)
+	{
+		return SetSenderKID((kid == null) ? null : new DerOctetString(kid));
+	}
+
+	public virtual PkiHeaderBuilder SetSenderKID(Asn1OctetString kid)
+	{
+		senderKID = kid;
+		return this;
+	}
+
+	public virtual PkiHeaderBuilder SetRecipKID(byte[] kid)
+	{
+		return SetRecipKID((kid == null) ? null : new DerOctetString(kid));
+	}
+
+	public virtual PkiHeaderBuilder SetRecipKID(DerOctetString kid)
+	{
+		recipKID = kid;
+		return this;
+	}
+
+	public virtual PkiHeaderBuilder SetTransactionID(byte[] tid)
+	{
+		return SetTransactionID((tid == null) ? null : new DerOctetString(tid));
+	}
+
+	public virtual PkiHeaderBuilder SetTransactionID(Asn1OctetString tid)
+	{
+		transactionID = tid;
+		return this;
+	}
+
+	public virtual PkiHeaderBuilder SetSenderNonce(byte[] nonce)
+	{
+		return SetSenderNonce((nonce == null) ? null : new DerOctetString(nonce));
+	}
+
+	public virtual PkiHeaderBuilder SetSenderNonce(Asn1OctetString nonce)
+	{
+		senderNonce = nonce;
+		return this;
+	}
+
+	public virtual PkiHeaderBuilder SetRecipNonce(byte[] nonce)
+	{
+		return SetRecipNonce((nonce == null) ? null : new DerOctetString(nonce));
+	}
+
+	public virtual PkiHeaderBuilder SetRecipNonce(Asn1OctetString nonce)
+	{
+		recipNonce = nonce;
+		return this;
+	}
+
+	public virtual PkiHeaderBuilder SetFreeText(PkiFreeText text)
+	{
+		freeText = text;
+		return this;
+	}
+
+	public virtual PkiHeaderBuilder SetGeneralInfo(InfoTypeAndValue genInfo)
+	{
+		return SetGeneralInfo(MakeGeneralInfoSeq(genInfo));
+	}
+
+	public virtual PkiHeaderBuilder SetGeneralInfo(InfoTypeAndValue[] genInfos)
+	{
+		return SetGeneralInfo(MakeGeneralInfoSeq(genInfos));
+	}
+
+	public virtual PkiHeaderBuilder SetGeneralInfo(Asn1Sequence seqOfInfoTypeAndValue)
+	{
+		generalInfo = seqOfInfoTypeAndValue;
+		return this;
+	}
+
+	private static Asn1Sequence MakeGeneralInfoSeq(InfoTypeAndValue generalInfo)
+	{
+		return new DerSequence(generalInfo);
+	}
+
+	private static Asn1Sequence MakeGeneralInfoSeq(InfoTypeAndValue[] generalInfos)
+	{
+		Asn1Sequence result = null;
+		if (generalInfos != null)
+		{
+			Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector();
+			for (int i = 0; i < generalInfos.Length; i++)
+			{
+				asn1EncodableVector.Add(generalInfos[i]);
+			}
+			result = new DerSequence(asn1EncodableVector);
+		}
+		return result;
+	}
+
+	public virtual PkiHeader Build()
+	{
+		Asn1EncodableVector v = new Asn1EncodableVector(pvno, sender, recipient);
+		AddOptional(v, 0, messageTime);
+		AddOptional(v, 1, protectionAlg);
+		AddOptional(v, 2, senderKID);
+		AddOptional(v, 3, recipKID);
+		AddOptional(v, 4, transactionID);
+		AddOptional(v, 5, senderNonce);
+		AddOptional(v, 6, recipNonce);
+		AddOptional(v, 7, freeText);
+		AddOptional(v, 8, generalInfo);
+		messageTime = null;
+		protectionAlg = null;
+		senderKID = null;
+		recipKID = null;
+		transactionID = null;
+		senderNonce = null;
+		recipNonce = null;
+		freeText = null;
+		generalInfo = null;
+		return PkiHeader.GetInstance(new DerSequence(v));
+	}
+
+	private void AddOptional(Asn1EncodableVector v, int tagNo, Asn1Encodable obj)
+	{
+		if (obj != null)
+		{
+			v.Add(new DerTaggedObject(explicitly: true, tagNo, obj));
+		}
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cmp/PkiMessage.cs

@@ -0,0 +1,100 @@
+namespace Org.BouncyCastle.Asn1.Cmp;
+
+public class PkiMessage : Asn1Encodable
+{
+	private readonly PkiHeader header;
+
+	private readonly PkiBody body;
+
+	private readonly DerBitString protection;
+
+	private readonly Asn1Sequence extraCerts;
+
+	public virtual PkiHeader Header => header;
+
+	public virtual PkiBody Body => body;
+
+	public virtual DerBitString Protection => protection;
+
+	private PkiMessage(Asn1Sequence seq)
+	{
+		header = PkiHeader.GetInstance(seq[0]);
+		body = PkiBody.GetInstance(seq[1]);
+		for (int i = 2; i < seq.Count; i++)
+		{
+			Asn1TaggedObject asn1TaggedObject = (Asn1TaggedObject)seq[i].ToAsn1Object();
+			if (asn1TaggedObject.TagNo == 0)
+			{
+				protection = DerBitString.GetInstance(asn1TaggedObject, isExplicit: true);
+			}
+			else
+			{
+				extraCerts = Asn1Sequence.GetInstance(asn1TaggedObject, explicitly: true);
+			}
+		}
+	}
+
+	public static PkiMessage GetInstance(object obj)
+	{
+		if (obj is PkiMessage)
+		{
+			return (PkiMessage)obj;
+		}
+		if (obj != null)
+		{
+			return new PkiMessage(Asn1Sequence.GetInstance(obj));
+		}
+		return null;
+	}
+
+	public PkiMessage(PkiHeader header, PkiBody body, DerBitString protection, CmpCertificate[] extraCerts)
+	{
+		this.header = header;
+		this.body = body;
+		this.protection = protection;
+		if (extraCerts != null)
+		{
+			this.extraCerts = new DerSequence(extraCerts);
+		}
+	}
+
+	public PkiMessage(PkiHeader header, PkiBody body, DerBitString protection)
+		: this(header, body, protection, null)
+	{
+	}
+
+	public PkiMessage(PkiHeader header, PkiBody body)
+		: this(header, body, null, null)
+	{
+	}
+
+	public virtual CmpCertificate[] GetExtraCerts()
+	{
+		if (extraCerts == null)
+		{
+			return null;
+		}
+		CmpCertificate[] array = new CmpCertificate[extraCerts.Count];
+		for (int i = 0; i < array.Length; i++)
+		{
+			array[i] = CmpCertificate.GetInstance(extraCerts[i]);
+		}
+		return array;
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		Asn1EncodableVector v = new Asn1EncodableVector(header, body);
+		AddOptional(v, 0, protection);
+		AddOptional(v, 1, extraCerts);
+		return new DerSequence(v);
+	}
+
+	private static void AddOptional(Asn1EncodableVector v, int tagNo, Asn1Encodable obj)
+	{
+		if (obj != null)
+		{
+			v.Add(new DerTaggedObject(explicitly: true, tagNo, obj));
+		}
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cmp/PkiMessages.cs

@@ -0,0 +1,47 @@
+using System;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cmp;
+
+public class PkiMessages : Asn1Encodable
+{
+	private Asn1Sequence content;
+
+	private PkiMessages(Asn1Sequence seq)
+	{
+		content = seq;
+	}
+
+	public static PkiMessages GetInstance(object obj)
+	{
+		if (obj is PkiMessages)
+		{
+			return (PkiMessages)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new PkiMessages((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("Invalid object: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public PkiMessages(params PkiMessage[] msgs)
+	{
+		content = new DerSequence(msgs);
+	}
+
+	public virtual PkiMessage[] ToPkiMessageArray()
+	{
+		PkiMessage[] array = new PkiMessage[content.Count];
+		for (int i = 0; i != array.Length; i++)
+		{
+			array[i] = PkiMessage.GetInstance(content[i]);
+		}
+		return array;
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		return content;
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cmp/PkiStatus.cs

@@ -0,0 +1,12 @@
+namespace Org.BouncyCastle.Asn1.Cmp;
+
+public enum PkiStatus
+{
+	Granted,
+	GrantedWithMods,
+	Rejection,
+	Waiting,
+	RevocationWarning,
+	RevocationNotification,
+	KeyUpdateWarning
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cmp/PkiStatusEncodable.cs

@@ -0,0 +1,54 @@
+using System;
+using Org.BouncyCastle.Math;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cmp;
+
+public class PkiStatusEncodable : Asn1Encodable
+{
+	public static readonly PkiStatusEncodable granted = new PkiStatusEncodable(PkiStatus.Granted);
+
+	public static readonly PkiStatusEncodable grantedWithMods = new PkiStatusEncodable(PkiStatus.GrantedWithMods);
+
+	public static readonly PkiStatusEncodable rejection = new PkiStatusEncodable(PkiStatus.Rejection);
+
+	public static readonly PkiStatusEncodable waiting = new PkiStatusEncodable(PkiStatus.Waiting);
+
+	public static readonly PkiStatusEncodable revocationWarning = new PkiStatusEncodable(PkiStatus.RevocationWarning);
+
+	public static readonly PkiStatusEncodable revocationNotification = new PkiStatusEncodable(PkiStatus.RevocationNotification);
+
+	public static readonly PkiStatusEncodable keyUpdateWaiting = new PkiStatusEncodable(PkiStatus.KeyUpdateWarning);
+
+	private readonly DerInteger status;
+
+	public virtual BigInteger Value => status.Value;
+
+	private PkiStatusEncodable(PkiStatus status)
+		: this(new DerInteger((int)status))
+	{
+	}
+
+	private PkiStatusEncodable(DerInteger status)
+	{
+		this.status = status;
+	}
+
+	public static PkiStatusEncodable GetInstance(object obj)
+	{
+		if (obj is PkiStatusEncodable)
+		{
+			return (PkiStatusEncodable)obj;
+		}
+		if (obj is DerInteger)
+		{
+			return new PkiStatusEncodable((DerInteger)obj);
+		}
+		throw new ArgumentException("Invalid object: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		return status;
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cmp/PkiStatusInfo.cs

@@ -0,0 +1,94 @@
+using System;
+using Org.BouncyCastle.Math;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cmp;
+
+public class PkiStatusInfo : Asn1Encodable
+{
+	private DerInteger status;
+
+	private PkiFreeText statusString;
+
+	private DerBitString failInfo;
+
+	public BigInteger Status => status.Value;
+
+	public PkiFreeText StatusString => statusString;
+
+	public DerBitString FailInfo => failInfo;
+
+	public static PkiStatusInfo GetInstance(Asn1TaggedObject obj, bool isExplicit)
+	{
+		return GetInstance(Asn1Sequence.GetInstance(obj, isExplicit));
+	}
+
+	public static PkiStatusInfo GetInstance(object obj)
+	{
+		if (obj is PkiStatusInfo)
+		{
+			return (PkiStatusInfo)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new PkiStatusInfo((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("Unknown object in factory: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public PkiStatusInfo(Asn1Sequence seq)
+	{
+		status = DerInteger.GetInstance(seq[0]);
+		statusString = null;
+		failInfo = null;
+		if (seq.Count > 2)
+		{
+			statusString = PkiFreeText.GetInstance(seq[1]);
+			failInfo = DerBitString.GetInstance(seq[2]);
+		}
+		else if (seq.Count > 1)
+		{
+			object obj = seq[1];
+			if (obj is DerBitString)
+			{
+				failInfo = DerBitString.GetInstance(obj);
+			}
+			else
+			{
+				statusString = PkiFreeText.GetInstance(obj);
+			}
+		}
+	}
+
+	public PkiStatusInfo(int status)
+	{
+		this.status = new DerInteger(status);
+	}
+
+	public PkiStatusInfo(int status, PkiFreeText statusString)
+	{
+		this.status = new DerInteger(status);
+		this.statusString = statusString;
+	}
+
+	public PkiStatusInfo(int status, PkiFreeText statusString, PkiFailureInfo failInfo)
+	{
+		this.status = new DerInteger(status);
+		this.statusString = statusString;
+		this.failInfo = failInfo;
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector(status);
+		if (statusString != null)
+		{
+			asn1EncodableVector.Add(statusString);
+		}
+		if (failInfo != null)
+		{
+			asn1EncodableVector.Add(failInfo);
+		}
+		return new DerSequence(asn1EncodableVector);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cmp/PollRepContent.cs

@@ -0,0 +1,63 @@
+using System;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cmp;
+
+public class PollRepContent : Asn1Encodable
+{
+	private readonly DerInteger certReqId;
+
+	private readonly DerInteger checkAfter;
+
+	private readonly PkiFreeText reason;
+
+	public virtual DerInteger CertReqID => certReqId;
+
+	public virtual DerInteger CheckAfter => checkAfter;
+
+	public virtual PkiFreeText Reason => reason;
+
+	private PollRepContent(Asn1Sequence seq)
+	{
+		certReqId = DerInteger.GetInstance(seq[0]);
+		checkAfter = DerInteger.GetInstance(seq[1]);
+		if (seq.Count > 2)
+		{
+			reason = PkiFreeText.GetInstance(seq[2]);
+		}
+	}
+
+	public static PollRepContent GetInstance(object obj)
+	{
+		if (obj is PollRepContent)
+		{
+			return (PollRepContent)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new PollRepContent((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("Invalid object: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public PollRepContent(DerInteger certReqId, DerInteger checkAfter)
+	{
+		this.certReqId = certReqId;
+		this.checkAfter = checkAfter;
+		reason = null;
+	}
+
+	public PollRepContent(DerInteger certReqId, DerInteger checkAfter, PkiFreeText reason)
+	{
+		this.certReqId = certReqId;
+		this.checkAfter = checkAfter;
+		this.reason = reason;
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector(certReqId, checkAfter);
+		asn1EncodableVector.AddOptional(reason);
+		return new DerSequence(asn1EncodableVector);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cmp/PollReqContent.cs

@@ -0,0 +1,52 @@
+using System;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cmp;
+
+public class PollReqContent : Asn1Encodable
+{
+	private readonly Asn1Sequence content;
+
+	private PollReqContent(Asn1Sequence seq)
+	{
+		content = seq;
+	}
+
+	public static PollReqContent GetInstance(object obj)
+	{
+		if (obj is PollReqContent)
+		{
+			return (PollReqContent)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new PollReqContent((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("Invalid object: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public virtual DerInteger[][] GetCertReqIDs()
+	{
+		DerInteger[][] array = new DerInteger[content.Count][];
+		for (int i = 0; i != array.Length; i++)
+		{
+			array[i] = SequenceToDerIntegerArray((Asn1Sequence)content[i]);
+		}
+		return array;
+	}
+
+	private static DerInteger[] SequenceToDerIntegerArray(Asn1Sequence seq)
+	{
+		DerInteger[] array = new DerInteger[seq.Count];
+		for (int i = 0; i != array.Length; i++)
+		{
+			array[i] = DerInteger.GetInstance(seq[i]);
+		}
+		return array;
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		return content;
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cmp/PopoDecKeyChallContent.cs

@@ -0,0 +1,42 @@
+using System;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cmp;
+
+public class PopoDecKeyChallContent : Asn1Encodable
+{
+	private readonly Asn1Sequence content;
+
+	private PopoDecKeyChallContent(Asn1Sequence seq)
+	{
+		content = seq;
+	}
+
+	public static PopoDecKeyChallContent GetInstance(object obj)
+	{
+		if (obj is PopoDecKeyChallContent)
+		{
+			return (PopoDecKeyChallContent)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new PopoDecKeyChallContent((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("Invalid object: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public virtual Challenge[] ToChallengeArray()
+	{
+		Challenge[] array = new Challenge[content.Count];
+		for (int i = 0; i != array.Length; i++)
+		{
+			array[i] = Challenge.GetInstance(content[i]);
+		}
+		return array;
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		return content;
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cmp/PopoDecKeyRespContent.cs

@@ -0,0 +1,42 @@
+using System;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cmp;
+
+public class PopoDecKeyRespContent : Asn1Encodable
+{
+	private readonly Asn1Sequence content;
+
+	private PopoDecKeyRespContent(Asn1Sequence seq)
+	{
+		content = seq;
+	}
+
+	public static PopoDecKeyRespContent GetInstance(object obj)
+	{
+		if (obj is PopoDecKeyRespContent)
+		{
+			return (PopoDecKeyRespContent)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new PopoDecKeyRespContent((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("Invalid object: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public virtual DerInteger[] ToDerIntegerArray()
+	{
+		DerInteger[] array = new DerInteger[content.Count];
+		for (int i = 0; i != array.Length; i++)
+		{
+			array[i] = DerInteger.GetInstance(content[i]);
+		}
+		return array;
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		return content;
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cmp/ProtectedPart.cs

@@ -0,0 +1,45 @@
+using System;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cmp;
+
+public class ProtectedPart : Asn1Encodable
+{
+	private readonly PkiHeader header;
+
+	private readonly PkiBody body;
+
+	public virtual PkiHeader Header => header;
+
+	public virtual PkiBody Body => body;
+
+	private ProtectedPart(Asn1Sequence seq)
+	{
+		header = PkiHeader.GetInstance(seq[0]);
+		body = PkiBody.GetInstance(seq[1]);
+	}
+
+	public static ProtectedPart GetInstance(object obj)
+	{
+		if (obj is ProtectedPart)
+		{
+			return (ProtectedPart)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new ProtectedPart((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("Invalid object: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public ProtectedPart(PkiHeader header, PkiBody body)
+	{
+		this.header = header;
+		this.body = body;
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		return new DerSequence(header, body);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cmp/RevAnnContent.cs

@@ -0,0 +1,61 @@
+using System;
+using Org.BouncyCastle.Asn1.Crmf;
+using Org.BouncyCastle.Asn1.X509;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cmp;
+
+public class RevAnnContent : Asn1Encodable
+{
+	private readonly PkiStatusEncodable status;
+
+	private readonly CertId certId;
+
+	private readonly DerGeneralizedTime willBeRevokedAt;
+
+	private readonly DerGeneralizedTime badSinceDate;
+
+	private readonly X509Extensions crlDetails;
+
+	public virtual PkiStatusEncodable Status => status;
+
+	public virtual CertId CertID => certId;
+
+	public virtual DerGeneralizedTime WillBeRevokedAt => willBeRevokedAt;
+
+	public virtual DerGeneralizedTime BadSinceDate => badSinceDate;
+
+	public virtual X509Extensions CrlDetails => crlDetails;
+
+	private RevAnnContent(Asn1Sequence seq)
+	{
+		status = PkiStatusEncodable.GetInstance(seq[0]);
+		certId = CertId.GetInstance(seq[1]);
+		willBeRevokedAt = DerGeneralizedTime.GetInstance(seq[2]);
+		badSinceDate = DerGeneralizedTime.GetInstance(seq[3]);
+		if (seq.Count > 4)
+		{
+			crlDetails = X509Extensions.GetInstance(seq[4]);
+		}
+	}
+
+	public static RevAnnContent GetInstance(object obj)
+	{
+		if (obj is RevAnnContent)
+		{
+			return (RevAnnContent)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new RevAnnContent((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("Invalid object: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector(status, certId, willBeRevokedAt, badSinceDate);
+		asn1EncodableVector.AddOptional(crlDetails);
+		return new DerSequence(asn1EncodableVector);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cmp/RevDetails.cs

@@ -0,0 +1,54 @@
+using System;
+using Org.BouncyCastle.Asn1.Crmf;
+using Org.BouncyCastle.Asn1.X509;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cmp;
+
+public class RevDetails : Asn1Encodable
+{
+	private readonly CertTemplate certDetails;
+
+	private readonly X509Extensions crlEntryDetails;
+
+	public virtual CertTemplate CertDetails => certDetails;
+
+	public virtual X509Extensions CrlEntryDetails => crlEntryDetails;
+
+	private RevDetails(Asn1Sequence seq)
+	{
+		certDetails = CertTemplate.GetInstance(seq[0]);
+		crlEntryDetails = ((seq.Count <= 1) ? null : X509Extensions.GetInstance(seq[1]));
+	}
+
+	public static RevDetails GetInstance(object obj)
+	{
+		if (obj is RevDetails)
+		{
+			return (RevDetails)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new RevDetails((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("Invalid object: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public RevDetails(CertTemplate certDetails)
+		: this(certDetails, null)
+	{
+	}
+
+	public RevDetails(CertTemplate certDetails, X509Extensions crlEntryDetails)
+	{
+		this.certDetails = certDetails;
+		this.crlEntryDetails = crlEntryDetails;
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector(certDetails);
+		asn1EncodableVector.AddOptional(crlEntryDetails);
+		return new DerSequence(asn1EncodableVector);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cmp/RevRepContent.cs

@@ -0,0 +1,99 @@
+using System;
+using Org.BouncyCastle.Asn1.Crmf;
+using Org.BouncyCastle.Asn1.X509;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cmp;
+
+public class RevRepContent : Asn1Encodable
+{
+	private readonly Asn1Sequence status;
+
+	private readonly Asn1Sequence revCerts;
+
+	private readonly Asn1Sequence crls;
+
+	private RevRepContent(Asn1Sequence seq)
+	{
+		status = Asn1Sequence.GetInstance(seq[0]);
+		for (int i = 1; i < seq.Count; i++)
+		{
+			Asn1TaggedObject instance = Asn1TaggedObject.GetInstance(seq[i]);
+			if (instance.TagNo == 0)
+			{
+				revCerts = Asn1Sequence.GetInstance(instance, explicitly: true);
+			}
+			else
+			{
+				crls = Asn1Sequence.GetInstance(instance, explicitly: true);
+			}
+		}
+	}
+
+	public static RevRepContent GetInstance(object obj)
+	{
+		if (obj is RevRepContent)
+		{
+			return (RevRepContent)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new RevRepContent((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("Invalid object: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public virtual PkiStatusInfo[] GetStatus()
+	{
+		PkiStatusInfo[] array = new PkiStatusInfo[status.Count];
+		for (int i = 0; i != array.Length; i++)
+		{
+			array[i] = PkiStatusInfo.GetInstance(status[i]);
+		}
+		return array;
+	}
+
+	public virtual CertId[] GetRevCerts()
+	{
+		if (revCerts == null)
+		{
+			return null;
+		}
+		CertId[] array = new CertId[revCerts.Count];
+		for (int i = 0; i != array.Length; i++)
+		{
+			array[i] = CertId.GetInstance(revCerts[i]);
+		}
+		return array;
+	}
+
+	public virtual CertificateList[] GetCrls()
+	{
+		if (crls == null)
+		{
+			return null;
+		}
+		CertificateList[] array = new CertificateList[crls.Count];
+		for (int i = 0; i != array.Length; i++)
+		{
+			array[i] = CertificateList.GetInstance(crls[i]);
+		}
+		return array;
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		Asn1EncodableVector v = new Asn1EncodableVector(status);
+		AddOptional(v, 0, revCerts);
+		AddOptional(v, 1, crls);
+		return new DerSequence(v);
+	}
+
+	private void AddOptional(Asn1EncodableVector v, int tagNo, Asn1Encodable obj)
+	{
+		if (obj != null)
+		{
+			v.Add(new DerTaggedObject(explicitly: true, tagNo, obj));
+		}
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cmp/RevRepContentBuilder.cs

@@ -0,0 +1,52 @@
+using System;
+using Org.BouncyCastle.Asn1.Crmf;
+using Org.BouncyCastle.Asn1.X509;
+
+namespace Org.BouncyCastle.Asn1.Cmp;
+
+public class RevRepContentBuilder
+{
+	private readonly Asn1EncodableVector status = new Asn1EncodableVector();
+
+	private readonly Asn1EncodableVector revCerts = new Asn1EncodableVector();
+
+	private readonly Asn1EncodableVector crls = new Asn1EncodableVector();
+
+	public virtual RevRepContentBuilder Add(PkiStatusInfo status)
+	{
+		this.status.Add(status);
+		return this;
+	}
+
+	public virtual RevRepContentBuilder Add(PkiStatusInfo status, CertId certId)
+	{
+		if (this.status.Count != revCerts.Count)
+		{
+			throw new InvalidOperationException("status and revCerts sequence must be in common order");
+		}
+		this.status.Add(status);
+		revCerts.Add(certId);
+		return this;
+	}
+
+	public virtual RevRepContentBuilder AddCrl(CertificateList crl)
+	{
+		crls.Add(crl);
+		return this;
+	}
+
+	public virtual RevRepContent Build()
+	{
+		Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector();
+		asn1EncodableVector.Add(new DerSequence(status));
+		if (revCerts.Count != 0)
+		{
+			asn1EncodableVector.Add(new DerTaggedObject(explicitly: true, 0, new DerSequence(revCerts)));
+		}
+		if (crls.Count != 0)
+		{
+			asn1EncodableVector.Add(new DerTaggedObject(explicitly: true, 1, new DerSequence(crls)));
+		}
+		return RevRepContent.GetInstance(new DerSequence(asn1EncodableVector));
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cmp/RevReqContent.cs

@@ -0,0 +1,47 @@
+using System;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cmp;
+
+public class RevReqContent : Asn1Encodable
+{
+	private readonly Asn1Sequence content;
+
+	private RevReqContent(Asn1Sequence seq)
+	{
+		content = seq;
+	}
+
+	public static RevReqContent GetInstance(object obj)
+	{
+		if (obj is RevReqContent)
+		{
+			return (RevReqContent)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new RevReqContent((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("Invalid object: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public RevReqContent(params RevDetails[] revDetails)
+	{
+		content = new DerSequence(revDetails);
+	}
+
+	public virtual RevDetails[] ToRevDetailsArray()
+	{
+		RevDetails[] array = new RevDetails[content.Count];
+		for (int i = 0; i != array.Length; i++)
+		{
+			array[i] = RevDetails.GetInstance(content[i]);
+		}
+		return array;
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		return content;
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cms/Attribute.cs

@@ -0,0 +1,45 @@
+using System;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cms;
+
+public class Attribute : Asn1Encodable
+{
+	private DerObjectIdentifier attrType;
+
+	private Asn1Set attrValues;
+
+	public DerObjectIdentifier AttrType => attrType;
+
+	public Asn1Set AttrValues => attrValues;
+
+	public static Attribute GetInstance(object obj)
+	{
+		if (obj == null || obj is Attribute)
+		{
+			return (Attribute)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new Attribute((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("unknown object in factory: " + Platform.GetTypeName(obj), "obj");
+	}
+
+	public Attribute(Asn1Sequence seq)
+	{
+		attrType = (DerObjectIdentifier)seq[0];
+		attrValues = (Asn1Set)seq[1];
+	}
+
+	public Attribute(DerObjectIdentifier attrType, Asn1Set attrValues)
+	{
+		this.attrType = attrType;
+		this.attrValues = attrValues;
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		return new DerSequence(attrType, attrValues);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cms/AttributeTable.cs

@@ -0,0 +1,170 @@
+using System;
+using System.Collections;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cms;
+
+public class AttributeTable
+{
+	private readonly IDictionary attributes;
+
+	public Attribute this[DerObjectIdentifier oid]
+	{
+		get
+		{
+			object obj = attributes[oid];
+			if (obj is IList)
+			{
+				return (Attribute)((IList)obj)[0];
+			}
+			return (Attribute)obj;
+		}
+	}
+
+	public int Count
+	{
+		get
+		{
+			int num = 0;
+			foreach (object value in attributes.Values)
+			{
+				num = ((!(value is IList)) ? (num + 1) : (num + ((IList)value).Count));
+			}
+			return num;
+		}
+	}
+
+	[Obsolete]
+	public AttributeTable(Hashtable attrs)
+	{
+		attributes = Platform.CreateHashtable(attrs);
+	}
+
+	public AttributeTable(IDictionary attrs)
+	{
+		attributes = Platform.CreateHashtable(attrs);
+	}
+
+	public AttributeTable(Asn1EncodableVector v)
+	{
+		attributes = Platform.CreateHashtable(v.Count);
+		foreach (Asn1Encodable item in v)
+		{
+			Attribute instance = Attribute.GetInstance(item);
+			AddAttribute(instance);
+		}
+	}
+
+	public AttributeTable(Asn1Set s)
+	{
+		attributes = Platform.CreateHashtable(s.Count);
+		for (int i = 0; i != s.Count; i++)
+		{
+			Attribute instance = Attribute.GetInstance(s[i]);
+			AddAttribute(instance);
+		}
+	}
+
+	public AttributeTable(Attributes attrs)
+		: this(Asn1Set.GetInstance(attrs.ToAsn1Object()))
+	{
+	}
+
+	private void AddAttribute(Attribute a)
+	{
+		DerObjectIdentifier attrType = a.AttrType;
+		object obj = attributes[attrType];
+		if (obj == null)
+		{
+			attributes[attrType] = a;
+			return;
+		}
+		IList list;
+		if (obj is Attribute)
+		{
+			list = Platform.CreateArrayList();
+			list.Add(obj);
+			list.Add(a);
+		}
+		else
+		{
+			list = (IList)obj;
+			list.Add(a);
+		}
+		attributes[attrType] = list;
+	}
+
+	[Obsolete("Use 'object[oid]' syntax instead")]
+	public Attribute Get(DerObjectIdentifier oid)
+	{
+		return this[oid];
+	}
+
+	public Asn1EncodableVector GetAll(DerObjectIdentifier oid)
+	{
+		Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector();
+		object obj = attributes[oid];
+		if (obj is IList)
+		{
+			foreach (Attribute item in (IList)obj)
+			{
+				asn1EncodableVector.Add(item);
+			}
+		}
+		else if (obj != null)
+		{
+			asn1EncodableVector.Add((Attribute)obj);
+		}
+		return asn1EncodableVector;
+	}
+
+	public IDictionary ToDictionary()
+	{
+		return Platform.CreateHashtable(attributes);
+	}
+
+	[Obsolete("Use 'ToDictionary' instead")]
+	public Hashtable ToHashtable()
+	{
+		return new Hashtable(attributes);
+	}
+
+	public Asn1EncodableVector ToAsn1EncodableVector()
+	{
+		Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector();
+		foreach (object value in attributes.Values)
+		{
+			if (value is IList)
+			{
+				foreach (object item in (IList)value)
+				{
+					asn1EncodableVector.Add(Attribute.GetInstance(item));
+				}
+			}
+			else
+			{
+				asn1EncodableVector.Add(Attribute.GetInstance(value));
+			}
+		}
+		return asn1EncodableVector;
+	}
+
+	public Attributes ToAttributes()
+	{
+		return new Attributes(ToAsn1EncodableVector());
+	}
+
+	public AttributeTable Add(DerObjectIdentifier attrType, Asn1Encodable attrValue)
+	{
+		AttributeTable attributeTable = new AttributeTable(attributes);
+		attributeTable.AddAttribute(new Attribute(attrType, new DerSet(attrValue)));
+		return attributeTable;
+	}
+
+	public AttributeTable Remove(DerObjectIdentifier attrType)
+	{
+		AttributeTable attributeTable = new AttributeTable(attributes);
+		attributeTable.attributes.Remove(attrType);
+		return attributeTable;
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cms/Attributes.cs

@@ -0,0 +1,44 @@
+namespace Org.BouncyCastle.Asn1.Cms;
+
+public class Attributes : Asn1Encodable
+{
+	private readonly Asn1Set attributes;
+
+	private Attributes(Asn1Set attributes)
+	{
+		this.attributes = attributes;
+	}
+
+	public Attributes(Asn1EncodableVector v)
+	{
+		attributes = new BerSet(v);
+	}
+
+	public static Attributes GetInstance(object obj)
+	{
+		if (obj is Attributes)
+		{
+			return (Attributes)obj;
+		}
+		if (obj != null)
+		{
+			return new Attributes(Asn1Set.GetInstance(obj));
+		}
+		return null;
+	}
+
+	public virtual Attribute[] GetAttributes()
+	{
+		Attribute[] array = new Attribute[attributes.Count];
+		for (int i = 0; i != array.Length; i++)
+		{
+			array[i] = Attribute.GetInstance(attributes[i]);
+		}
+		return array;
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		return attributes;
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cms/AuthEnvelopedData.cs

@@ -0,0 +1,112 @@
+using System;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cms;
+
+public class AuthEnvelopedData : Asn1Encodable
+{
+	private DerInteger version;
+
+	private OriginatorInfo originatorInfo;
+
+	private Asn1Set recipientInfos;
+
+	private EncryptedContentInfo authEncryptedContentInfo;
+
+	private Asn1Set authAttrs;
+
+	private Asn1OctetString mac;
+
+	private Asn1Set unauthAttrs;
+
+	public DerInteger Version => version;
+
+	public OriginatorInfo OriginatorInfo => originatorInfo;
+
+	public Asn1Set RecipientInfos => recipientInfos;
+
+	public EncryptedContentInfo AuthEncryptedContentInfo => authEncryptedContentInfo;
+
+	public Asn1Set AuthAttrs => authAttrs;
+
+	public Asn1OctetString Mac => mac;
+
+	public Asn1Set UnauthAttrs => unauthAttrs;
+
+	public AuthEnvelopedData(OriginatorInfo originatorInfo, Asn1Set recipientInfos, EncryptedContentInfo authEncryptedContentInfo, Asn1Set authAttrs, Asn1OctetString mac, Asn1Set unauthAttrs)
+	{
+		version = new DerInteger(0);
+		this.originatorInfo = originatorInfo;
+		this.recipientInfos = recipientInfos;
+		this.authEncryptedContentInfo = authEncryptedContentInfo;
+		this.authAttrs = authAttrs;
+		this.mac = mac;
+		this.unauthAttrs = unauthAttrs;
+	}
+
+	private AuthEnvelopedData(Asn1Sequence seq)
+	{
+		int num = 0;
+		Asn1Object asn1Object = seq[num++].ToAsn1Object();
+		version = (DerInteger)asn1Object;
+		asn1Object = seq[num++].ToAsn1Object();
+		if (asn1Object is Asn1TaggedObject)
+		{
+			originatorInfo = OriginatorInfo.GetInstance((Asn1TaggedObject)asn1Object, explicitly: false);
+			asn1Object = seq[num++].ToAsn1Object();
+		}
+		recipientInfos = Asn1Set.GetInstance(asn1Object);
+		asn1Object = seq[num++].ToAsn1Object();
+		authEncryptedContentInfo = EncryptedContentInfo.GetInstance(asn1Object);
+		asn1Object = seq[num++].ToAsn1Object();
+		if (asn1Object is Asn1TaggedObject)
+		{
+			authAttrs = Asn1Set.GetInstance((Asn1TaggedObject)asn1Object, explicitly: false);
+			asn1Object = seq[num++].ToAsn1Object();
+		}
+		mac = Asn1OctetString.GetInstance(asn1Object);
+		if (seq.Count > num)
+		{
+			asn1Object = seq[num++].ToAsn1Object();
+			unauthAttrs = Asn1Set.GetInstance((Asn1TaggedObject)asn1Object, explicitly: false);
+		}
+	}
+
+	public static AuthEnvelopedData GetInstance(Asn1TaggedObject obj, bool isExplicit)
+	{
+		return GetInstance(Asn1Sequence.GetInstance(obj, isExplicit));
+	}
+
+	public static AuthEnvelopedData GetInstance(object obj)
+	{
+		if (obj == null || obj is AuthEnvelopedData)
+		{
+			return (AuthEnvelopedData)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new AuthEnvelopedData((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("Invalid AuthEnvelopedData: " + Platform.GetTypeName(obj));
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector(version);
+		if (originatorInfo != null)
+		{
+			asn1EncodableVector.Add(new DerTaggedObject(explicitly: false, 0, originatorInfo));
+		}
+		asn1EncodableVector.Add(recipientInfos, authEncryptedContentInfo);
+		if (authAttrs != null)
+		{
+			asn1EncodableVector.Add(new DerTaggedObject(explicitly: false, 1, authAttrs));
+		}
+		asn1EncodableVector.Add(mac);
+		if (unauthAttrs != null)
+		{
+			asn1EncodableVector.Add(new DerTaggedObject(explicitly: false, 2, unauthAttrs));
+		}
+		return new BerSequence(asn1EncodableVector);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cms/AuthEnvelopedDataParser.cs

@@ -0,0 +1,107 @@
+namespace Org.BouncyCastle.Asn1.Cms;
+
+public class AuthEnvelopedDataParser
+{
+	private Asn1SequenceParser seq;
+
+	private DerInteger version;
+
+	private IAsn1Convertible nextObject;
+
+	private bool originatorInfoCalled;
+
+	public DerInteger Version => version;
+
+	public AuthEnvelopedDataParser(Asn1SequenceParser seq)
+	{
+		this.seq = seq;
+		version = (DerInteger)seq.ReadObject();
+	}
+
+	public OriginatorInfo GetOriginatorInfo()
+	{
+		originatorInfoCalled = true;
+		if (nextObject == null)
+		{
+			nextObject = seq.ReadObject();
+		}
+		if (nextObject is Asn1TaggedObjectParser && ((Asn1TaggedObjectParser)nextObject).TagNo == 0)
+		{
+			Asn1SequenceParser asn1SequenceParser = (Asn1SequenceParser)((Asn1TaggedObjectParser)nextObject).GetObjectParser(16, isExplicit: false);
+			nextObject = null;
+			return OriginatorInfo.GetInstance(asn1SequenceParser.ToAsn1Object());
+		}
+		return null;
+	}
+
+	public Asn1SetParser GetRecipientInfos()
+	{
+		if (!originatorInfoCalled)
+		{
+			GetOriginatorInfo();
+		}
+		if (nextObject == null)
+		{
+			nextObject = seq.ReadObject();
+		}
+		Asn1SetParser result = (Asn1SetParser)nextObject;
+		nextObject = null;
+		return result;
+	}
+
+	public EncryptedContentInfoParser GetAuthEncryptedContentInfo()
+	{
+		if (nextObject == null)
+		{
+			nextObject = seq.ReadObject();
+		}
+		if (nextObject != null)
+		{
+			Asn1SequenceParser asn1SequenceParser = (Asn1SequenceParser)nextObject;
+			nextObject = null;
+			return new EncryptedContentInfoParser(asn1SequenceParser);
+		}
+		return null;
+	}
+
+	public Asn1SetParser GetAuthAttrs()
+	{
+		if (nextObject == null)
+		{
+			nextObject = seq.ReadObject();
+		}
+		if (nextObject is Asn1TaggedObjectParser)
+		{
+			IAsn1Convertible asn1Convertible = nextObject;
+			nextObject = null;
+			return (Asn1SetParser)((Asn1TaggedObjectParser)asn1Convertible).GetObjectParser(17, isExplicit: false);
+		}
+		return null;
+	}
+
+	public Asn1OctetString GetMac()
+	{
+		if (nextObject == null)
+		{
+			nextObject = seq.ReadObject();
+		}
+		IAsn1Convertible asn1Convertible = nextObject;
+		nextObject = null;
+		return Asn1OctetString.GetInstance(asn1Convertible.ToAsn1Object());
+	}
+
+	public Asn1SetParser GetUnauthAttrs()
+	{
+		if (nextObject == null)
+		{
+			nextObject = seq.ReadObject();
+		}
+		if (nextObject != null)
+		{
+			IAsn1Convertible asn1Convertible = nextObject;
+			nextObject = null;
+			return (Asn1SetParser)((Asn1TaggedObjectParser)asn1Convertible).GetObjectParser(17, isExplicit: false);
+		}
+		return null;
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cms/AuthenticatedData.cs

@@ -0,0 +1,174 @@
+using System;
+using Org.BouncyCastle.Asn1.X509;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cms;
+
+public class AuthenticatedData : Asn1Encodable
+{
+	private DerInteger version;
+
+	private OriginatorInfo originatorInfo;
+
+	private Asn1Set recipientInfos;
+
+	private AlgorithmIdentifier macAlgorithm;
+
+	private AlgorithmIdentifier digestAlgorithm;
+
+	private ContentInfo encapsulatedContentInfo;
+
+	private Asn1Set authAttrs;
+
+	private Asn1OctetString mac;
+
+	private Asn1Set unauthAttrs;
+
+	public DerInteger Version => version;
+
+	public OriginatorInfo OriginatorInfo => originatorInfo;
+
+	public Asn1Set RecipientInfos => recipientInfos;
+
+	public AlgorithmIdentifier MacAlgorithm => macAlgorithm;
+
+	public AlgorithmIdentifier DigestAlgorithm => digestAlgorithm;
+
+	public ContentInfo EncapsulatedContentInfo => encapsulatedContentInfo;
+
+	public Asn1Set AuthAttrs => authAttrs;
+
+	public Asn1OctetString Mac => mac;
+
+	public Asn1Set UnauthAttrs => unauthAttrs;
+
+	public AuthenticatedData(OriginatorInfo originatorInfo, Asn1Set recipientInfos, AlgorithmIdentifier macAlgorithm, AlgorithmIdentifier digestAlgorithm, ContentInfo encapsulatedContent, Asn1Set authAttrs, Asn1OctetString mac, Asn1Set unauthAttrs)
+	{
+		if ((digestAlgorithm != null || authAttrs != null) && (digestAlgorithm == null || authAttrs == null))
+		{
+			throw new ArgumentException("digestAlgorithm and authAttrs must be set together");
+		}
+		version = new DerInteger(CalculateVersion(originatorInfo));
+		this.originatorInfo = originatorInfo;
+		this.macAlgorithm = macAlgorithm;
+		this.digestAlgorithm = digestAlgorithm;
+		this.recipientInfos = recipientInfos;
+		encapsulatedContentInfo = encapsulatedContent;
+		this.authAttrs = authAttrs;
+		this.mac = mac;
+		this.unauthAttrs = unauthAttrs;
+	}
+
+	private AuthenticatedData(Asn1Sequence seq)
+	{
+		int num = 0;
+		version = (DerInteger)seq[num++];
+		Asn1Encodable asn1Encodable = seq[num++];
+		if (asn1Encodable is Asn1TaggedObject)
+		{
+			originatorInfo = OriginatorInfo.GetInstance((Asn1TaggedObject)asn1Encodable, explicitly: false);
+			asn1Encodable = seq[num++];
+		}
+		recipientInfos = Asn1Set.GetInstance(asn1Encodable);
+		macAlgorithm = AlgorithmIdentifier.GetInstance(seq[num++]);
+		asn1Encodable = seq[num++];
+		if (asn1Encodable is Asn1TaggedObject)
+		{
+			digestAlgorithm = AlgorithmIdentifier.GetInstance((Asn1TaggedObject)asn1Encodable, explicitly: false);
+			asn1Encodable = seq[num++];
+		}
+		encapsulatedContentInfo = ContentInfo.GetInstance(asn1Encodable);
+		asn1Encodable = seq[num++];
+		if (asn1Encodable is Asn1TaggedObject)
+		{
+			authAttrs = Asn1Set.GetInstance((Asn1TaggedObject)asn1Encodable, explicitly: false);
+			asn1Encodable = seq[num++];
+		}
+		mac = Asn1OctetString.GetInstance(asn1Encodable);
+		if (seq.Count > num)
+		{
+			unauthAttrs = Asn1Set.GetInstance((Asn1TaggedObject)seq[num], explicitly: false);
+		}
+	}
+
+	public static AuthenticatedData GetInstance(Asn1TaggedObject obj, bool isExplicit)
+	{
+		return GetInstance(Asn1Sequence.GetInstance(obj, isExplicit));
+	}
+
+	public static AuthenticatedData GetInstance(object obj)
+	{
+		if (obj == null || obj is AuthenticatedData)
+		{
+			return (AuthenticatedData)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new AuthenticatedData((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("Invalid AuthenticatedData: " + Platform.GetTypeName(obj));
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector(version);
+		if (originatorInfo != null)
+		{
+			asn1EncodableVector.Add(new DerTaggedObject(explicitly: false, 0, originatorInfo));
+		}
+		asn1EncodableVector.Add(recipientInfos, macAlgorithm);
+		if (digestAlgorithm != null)
+		{
+			asn1EncodableVector.Add(new DerTaggedObject(explicitly: false, 1, digestAlgorithm));
+		}
+		asn1EncodableVector.Add(encapsulatedContentInfo);
+		if (authAttrs != null)
+		{
+			asn1EncodableVector.Add(new DerTaggedObject(explicitly: false, 2, authAttrs));
+		}
+		asn1EncodableVector.Add(mac);
+		if (unauthAttrs != null)
+		{
+			asn1EncodableVector.Add(new DerTaggedObject(explicitly: false, 3, unauthAttrs));
+		}
+		return new BerSequence(asn1EncodableVector);
+	}
+
+	public static int CalculateVersion(OriginatorInfo origInfo)
+	{
+		if (origInfo == null)
+		{
+			return 0;
+		}
+		int result = 0;
+		foreach (object certificate in origInfo.Certificates)
+		{
+			if (certificate is Asn1TaggedObject)
+			{
+				Asn1TaggedObject asn1TaggedObject = (Asn1TaggedObject)certificate;
+				if (asn1TaggedObject.TagNo == 2)
+				{
+					result = 1;
+				}
+				else if (asn1TaggedObject.TagNo == 3)
+				{
+					result = 3;
+					break;
+				}
+			}
+		}
+		foreach (object crl in origInfo.Crls)
+		{
+			if (crl is Asn1TaggedObject)
+			{
+				Asn1TaggedObject asn1TaggedObject2 = (Asn1TaggedObject)crl;
+				if (asn1TaggedObject2.TagNo == 1)
+				{
+					result = 3;
+					break;
+				}
+			}
+		}
+		return result;
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cms/AuthenticatedDataParser.cs

@@ -0,0 +1,139 @@
+using Org.BouncyCastle.Asn1.X509;
+
+namespace Org.BouncyCastle.Asn1.Cms;
+
+public class AuthenticatedDataParser
+{
+	private Asn1SequenceParser seq;
+
+	private DerInteger version;
+
+	private IAsn1Convertible nextObject;
+
+	private bool originatorInfoCalled;
+
+	public DerInteger Version => version;
+
+	public AuthenticatedDataParser(Asn1SequenceParser seq)
+	{
+		this.seq = seq;
+		version = (DerInteger)seq.ReadObject();
+	}
+
+	public OriginatorInfo GetOriginatorInfo()
+	{
+		originatorInfoCalled = true;
+		if (nextObject == null)
+		{
+			nextObject = seq.ReadObject();
+		}
+		if (nextObject is Asn1TaggedObjectParser && ((Asn1TaggedObjectParser)nextObject).TagNo == 0)
+		{
+			Asn1SequenceParser asn1SequenceParser = (Asn1SequenceParser)((Asn1TaggedObjectParser)nextObject).GetObjectParser(16, isExplicit: false);
+			nextObject = null;
+			return OriginatorInfo.GetInstance(asn1SequenceParser.ToAsn1Object());
+		}
+		return null;
+	}
+
+	public Asn1SetParser GetRecipientInfos()
+	{
+		if (!originatorInfoCalled)
+		{
+			GetOriginatorInfo();
+		}
+		if (nextObject == null)
+		{
+			nextObject = seq.ReadObject();
+		}
+		Asn1SetParser result = (Asn1SetParser)nextObject;
+		nextObject = null;
+		return result;
+	}
+
+	public AlgorithmIdentifier GetMacAlgorithm()
+	{
+		if (nextObject == null)
+		{
+			nextObject = seq.ReadObject();
+		}
+		if (nextObject != null)
+		{
+			Asn1SequenceParser asn1SequenceParser = (Asn1SequenceParser)nextObject;
+			nextObject = null;
+			return AlgorithmIdentifier.GetInstance(asn1SequenceParser.ToAsn1Object());
+		}
+		return null;
+	}
+
+	public AlgorithmIdentifier GetDigestAlgorithm()
+	{
+		if (nextObject == null)
+		{
+			nextObject = seq.ReadObject();
+		}
+		if (nextObject is Asn1TaggedObjectParser)
+		{
+			AlgorithmIdentifier instance = AlgorithmIdentifier.GetInstance((Asn1TaggedObject)nextObject.ToAsn1Object(), explicitly: false);
+			nextObject = null;
+			return instance;
+		}
+		return null;
+	}
+
+	public ContentInfoParser GetEnapsulatedContentInfo()
+	{
+		if (nextObject == null)
+		{
+			nextObject = seq.ReadObject();
+		}
+		if (nextObject != null)
+		{
+			Asn1SequenceParser asn1SequenceParser = (Asn1SequenceParser)nextObject;
+			nextObject = null;
+			return new ContentInfoParser(asn1SequenceParser);
+		}
+		return null;
+	}
+
+	public Asn1SetParser GetAuthAttrs()
+	{
+		if (nextObject == null)
+		{
+			nextObject = seq.ReadObject();
+		}
+		if (nextObject is Asn1TaggedObjectParser)
+		{
+			IAsn1Convertible asn1Convertible = nextObject;
+			nextObject = null;
+			return (Asn1SetParser)((Asn1TaggedObjectParser)asn1Convertible).GetObjectParser(17, isExplicit: false);
+		}
+		return null;
+	}
+
+	public Asn1OctetString GetMac()
+	{
+		if (nextObject == null)
+		{
+			nextObject = seq.ReadObject();
+		}
+		IAsn1Convertible asn1Convertible = nextObject;
+		nextObject = null;
+		return Asn1OctetString.GetInstance(asn1Convertible.ToAsn1Object());
+	}
+
+	public Asn1SetParser GetUnauthAttrs()
+	{
+		if (nextObject == null)
+		{
+			nextObject = seq.ReadObject();
+		}
+		if (nextObject != null)
+		{
+			IAsn1Convertible asn1Convertible = nextObject;
+			nextObject = null;
+			return (Asn1SetParser)((Asn1TaggedObjectParser)asn1Convertible).GetObjectParser(17, isExplicit: false);
+		}
+		return null;
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cms/CmsAttributes.cs

@@ -0,0 +1,16 @@
+using Org.BouncyCastle.Asn1.Pkcs;
+
+namespace Org.BouncyCastle.Asn1.Cms;
+
+public abstract class CmsAttributes
+{
+	public static readonly DerObjectIdentifier ContentType = PkcsObjectIdentifiers.Pkcs9AtContentType;
+
+	public static readonly DerObjectIdentifier MessageDigest = PkcsObjectIdentifiers.Pkcs9AtMessageDigest;
+
+	public static readonly DerObjectIdentifier SigningTime = PkcsObjectIdentifiers.Pkcs9AtSigningTime;
+
+	public static readonly DerObjectIdentifier CounterSignature = PkcsObjectIdentifiers.Pkcs9AtCounterSignature;
+
+	public static readonly DerObjectIdentifier ContentHint = PkcsObjectIdentifiers.IdAAContentHint;
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cms/CmsObjectIdentifiers.cs

@@ -0,0 +1,32 @@
+using Org.BouncyCastle.Asn1.Pkcs;
+
+namespace Org.BouncyCastle.Asn1.Cms;
+
+public abstract class CmsObjectIdentifiers
+{
+	public static readonly DerObjectIdentifier Data = PkcsObjectIdentifiers.Data;
+
+	public static readonly DerObjectIdentifier SignedData = PkcsObjectIdentifiers.SignedData;
+
+	public static readonly DerObjectIdentifier EnvelopedData = PkcsObjectIdentifiers.EnvelopedData;
+
+	public static readonly DerObjectIdentifier SignedAndEnvelopedData = PkcsObjectIdentifiers.SignedAndEnvelopedData;
+
+	public static readonly DerObjectIdentifier DigestedData = PkcsObjectIdentifiers.DigestedData;
+
+	public static readonly DerObjectIdentifier EncryptedData = PkcsObjectIdentifiers.EncryptedData;
+
+	public static readonly DerObjectIdentifier AuthenticatedData = PkcsObjectIdentifiers.IdCTAuthData;
+
+	public static readonly DerObjectIdentifier CompressedData = PkcsObjectIdentifiers.IdCTCompressedData;
+
+	public static readonly DerObjectIdentifier AuthEnvelopedData = PkcsObjectIdentifiers.IdCTAuthEnvelopedData;
+
+	public static readonly DerObjectIdentifier timestampedData = PkcsObjectIdentifiers.IdCTTimestampedData;
+
+	public static readonly DerObjectIdentifier id_ri = new DerObjectIdentifier("1.3.6.1.5.5.7.16");
+
+	public static readonly DerObjectIdentifier id_ri_ocsp_response = id_ri.Branch("2");
+
+	public static readonly DerObjectIdentifier id_ri_scvp = id_ri.Branch("4");
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cms/CompressedData.cs

@@ -0,0 +1,57 @@
+using System;
+using Org.BouncyCastle.Asn1.X509;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cms;
+
+public class CompressedData : Asn1Encodable
+{
+	private DerInteger version;
+
+	private AlgorithmIdentifier compressionAlgorithm;
+
+	private ContentInfo encapContentInfo;
+
+	public DerInteger Version => version;
+
+	public AlgorithmIdentifier CompressionAlgorithmIdentifier => compressionAlgorithm;
+
+	public ContentInfo EncapContentInfo => encapContentInfo;
+
+	public CompressedData(AlgorithmIdentifier compressionAlgorithm, ContentInfo encapContentInfo)
+	{
+		version = new DerInteger(0);
+		this.compressionAlgorithm = compressionAlgorithm;
+		this.encapContentInfo = encapContentInfo;
+	}
+
+	public CompressedData(Asn1Sequence seq)
+	{
+		version = (DerInteger)seq[0];
+		compressionAlgorithm = AlgorithmIdentifier.GetInstance(seq[1]);
+		encapContentInfo = ContentInfo.GetInstance(seq[2]);
+	}
+
+	public static CompressedData GetInstance(Asn1TaggedObject ato, bool explicitly)
+	{
+		return GetInstance(Asn1Sequence.GetInstance(ato, explicitly));
+	}
+
+	public static CompressedData GetInstance(object obj)
+	{
+		if (obj == null || obj is CompressedData)
+		{
+			return (CompressedData)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new CompressedData((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("Invalid CompressedData: " + Platform.GetTypeName(obj));
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		return new BerSequence(version, compressionAlgorithm, encapContentInfo);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cms/CompressedDataParser.cs

@@ -0,0 +1,28 @@
+using Org.BouncyCastle.Asn1.X509;
+
+namespace Org.BouncyCastle.Asn1.Cms;
+
+public class CompressedDataParser
+{
+	private DerInteger _version;
+
+	private AlgorithmIdentifier _compressionAlgorithm;
+
+	private ContentInfoParser _encapContentInfo;
+
+	public DerInteger Version => _version;
+
+	public AlgorithmIdentifier CompressionAlgorithmIdentifier => _compressionAlgorithm;
+
+	public CompressedDataParser(Asn1SequenceParser seq)
+	{
+		_version = (DerInteger)seq.ReadObject();
+		_compressionAlgorithm = AlgorithmIdentifier.GetInstance(seq.ReadObject().ToAsn1Object());
+		_encapContentInfo = new ContentInfoParser((Asn1SequenceParser)seq.ReadObject());
+	}
+
+	public ContentInfoParser GetEncapContentInfo()
+	{
+		return _encapContentInfo;
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cms/ContentInfo.cs

@@ -0,0 +1,67 @@
+using System;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cms;
+
+public class ContentInfo : Asn1Encodable
+{
+	private readonly DerObjectIdentifier contentType;
+
+	private readonly Asn1Encodable content;
+
+	public DerObjectIdentifier ContentType => contentType;
+
+	public Asn1Encodable Content => content;
+
+	public static ContentInfo GetInstance(object obj)
+	{
+		if (obj == null || obj is ContentInfo)
+		{
+			return (ContentInfo)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new ContentInfo((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("unknown object in factory: " + Platform.GetTypeName(obj));
+	}
+
+	public static ContentInfo GetInstance(Asn1TaggedObject obj, bool isExplicit)
+	{
+		return GetInstance(Asn1Sequence.GetInstance(obj, isExplicit));
+	}
+
+	private ContentInfo(Asn1Sequence seq)
+	{
+		if (seq.Count < 1 || seq.Count > 2)
+		{
+			throw new ArgumentException("Bad sequence size: " + seq.Count, "seq");
+		}
+		contentType = (DerObjectIdentifier)seq[0];
+		if (seq.Count > 1)
+		{
+			Asn1TaggedObject asn1TaggedObject = (Asn1TaggedObject)seq[1];
+			if (!asn1TaggedObject.IsExplicit() || asn1TaggedObject.TagNo != 0)
+			{
+				throw new ArgumentException("Bad tag for 'content'", "seq");
+			}
+			content = asn1TaggedObject.GetObject();
+		}
+	}
+
+	public ContentInfo(DerObjectIdentifier contentType, Asn1Encodable content)
+	{
+		this.contentType = contentType;
+		this.content = content;
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector(contentType);
+		if (content != null)
+		{
+			asn1EncodableVector.Add(new BerTaggedObject(0, content));
+		}
+		return new BerSequence(asn1EncodableVector);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cms/ContentInfoParser.cs

@@ -0,0 +1,25 @@
+namespace Org.BouncyCastle.Asn1.Cms;
+
+public class ContentInfoParser
+{
+	private DerObjectIdentifier contentType;
+
+	private Asn1TaggedObjectParser content;
+
+	public DerObjectIdentifier ContentType => contentType;
+
+	public ContentInfoParser(Asn1SequenceParser seq)
+	{
+		contentType = (DerObjectIdentifier)seq.ReadObject();
+		content = (Asn1TaggedObjectParser)seq.ReadObject();
+	}
+
+	public IAsn1Convertible GetContent(int tag)
+	{
+		if (content == null)
+		{
+			return null;
+		}
+		return content.GetObjectParser(tag, isExplicit: true);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cms/Ecc/MQVuserKeyingMaterial.cs

@@ -0,0 +1,58 @@
+using System;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cms.Ecc;
+
+public class MQVuserKeyingMaterial : Asn1Encodable
+{
+	private OriginatorPublicKey ephemeralPublicKey;
+
+	private Asn1OctetString addedukm;
+
+	public OriginatorPublicKey EphemeralPublicKey => ephemeralPublicKey;
+
+	public Asn1OctetString AddedUkm => addedukm;
+
+	public MQVuserKeyingMaterial(OriginatorPublicKey ephemeralPublicKey, Asn1OctetString addedukm)
+	{
+		this.ephemeralPublicKey = ephemeralPublicKey;
+		this.addedukm = addedukm;
+	}
+
+	private MQVuserKeyingMaterial(Asn1Sequence seq)
+	{
+		ephemeralPublicKey = OriginatorPublicKey.GetInstance(seq[0]);
+		if (seq.Count > 1)
+		{
+			addedukm = Asn1OctetString.GetInstance((Asn1TaggedObject)seq[1], isExplicit: true);
+		}
+	}
+
+	public static MQVuserKeyingMaterial GetInstance(Asn1TaggedObject obj, bool isExplicit)
+	{
+		return GetInstance(Asn1Sequence.GetInstance(obj, isExplicit));
+	}
+
+	public static MQVuserKeyingMaterial GetInstance(object obj)
+	{
+		if (obj == null || obj is MQVuserKeyingMaterial)
+		{
+			return (MQVuserKeyingMaterial)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new MQVuserKeyingMaterial((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("Invalid MQVuserKeyingMaterial: " + Platform.GetTypeName(obj));
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector(ephemeralPublicKey);
+		if (addedukm != null)
+		{
+			asn1EncodableVector.Add(new DerTaggedObject(explicitly: true, 0, addedukm));
+		}
+		return new DerSequence(asn1EncodableVector);
+	}
+}

output/Libraries/BouncyCastle.Crypto/Org/BouncyCastle/Asn1/Cms/EncryptedContentInfo.cs

@@ -0,0 +1,60 @@
+using System;
+using Org.BouncyCastle.Asn1.X509;
+using Org.BouncyCastle.Utilities;
+
+namespace Org.BouncyCastle.Asn1.Cms;
+
+public class EncryptedContentInfo : Asn1Encodable
+{
+	private DerObjectIdentifier contentType;
+
+	private AlgorithmIdentifier contentEncryptionAlgorithm;
+
+	private Asn1OctetString encryptedContent;
+
+	public DerObjectIdentifier ContentType => contentType;
+
+	public AlgorithmIdentifier ContentEncryptionAlgorithm => contentEncryptionAlgorithm;
+
+	public Asn1OctetString EncryptedContent => encryptedContent;
+
+	public EncryptedContentInfo(DerObjectIdentifier contentType, AlgorithmIdentifier contentEncryptionAlgorithm, Asn1OctetString encryptedContent)
+	{
+		this.contentType = contentType;
+		this.contentEncryptionAlgorithm = contentEncryptionAlgorithm;
+		this.encryptedContent = encryptedContent;
+	}
+
+	public EncryptedContentInfo(Asn1Sequence seq)
+	{
+		contentType = (DerObjectIdentifier)seq[0];
+		contentEncryptionAlgorithm = AlgorithmIdentifier.GetInstance(seq[1]);
+		if (seq.Count > 2)
+		{
+			encryptedContent = Asn1OctetString.GetInstance((Asn1TaggedObject)seq[2], isExplicit: false);
+		}
+	}
+
+	public static EncryptedContentInfo GetInstance(object obj)
+	{
+		if (obj == null || obj is EncryptedContentInfo)
+		{
+			return (EncryptedContentInfo)obj;
+		}
+		if (obj is Asn1Sequence)
+		{
+			return new EncryptedContentInfo((Asn1Sequence)obj);
+		}
+		throw new ArgumentException("Invalid EncryptedContentInfo: " + Platform.GetTypeName(obj));
+	}
+
+	public override Asn1Object ToAsn1Object()
+	{
+		Asn1EncodableVector asn1EncodableVector = new Asn1EncodableVector(contentType, contentEncryptionAlgorithm);
+		if (encryptedContent != null)
+		{
+			asn1EncodableVector.Add(new BerTaggedObject(explicitly: false, 0, encryptedContent));
+		}
+		return new BerSequence(asn1EncodableVector);
+	}
+}