Create a serializer and deserializer for ASN.1 data

This enables serialization and deserialization of [StructLayout(LayoutKind.Sequential)] types to/from ASN.1 BER/CER/DER data streams.

Ambiguous types (like string) require attributes to identify their ASN.1 representation, and other attributes exist to optionally control the serialization mechanism (such as [OptionalValue], [ExpectedTag], [AnyValue]).

For background, see ITU-T-REC-X.680-201508 (ASN.1 language).

Author: bartonjs

src/Common/src/System/Security/Cryptography/Asn1V2.Serializer.cs

@@ -120,7 +120,7 @@ public Asn1Tag(UniversalTagNumber universalTagNumber, bool isConstructed = false
                 universalTagNumber > UniversalTagNumber.RelativeObjectIdentifierIRI ||
                 universalTagNumber == ReservedIndex)
             {
-                throw new ArgumentOutOfRangeException(nameof(universalTagNumber), universalTagNumber, null);
+                throw new ArgumentOutOfRangeException(nameof(universalTagNumber));
             }
         }
 
@@ -129,7 +129,12 @@ public Asn1Tag(TagClass tagClass, int tagValue, bool isConstructed = false)
         {
             if (tagClass < TagClass.Universal || tagClass > TagClass.Private)
             {
-                throw new ArgumentOutOfRangeException(nameof(tagClass), tagClass, null);
+                throw new ArgumentOutOfRangeException(nameof(tagClass));
+            }
+
+            if (tagValue < 0)
+            {
+                throw new ArgumentOutOfRangeException(nameof(tagValue));
             }
         }
 

src/Common/src/System/Security/Cryptography/Asn1V2.cs

@@ -432,6 +432,38 @@ public ReadOnlyMemory<byte> GetIntegerBytes(Asn1Tag expectedTag)
             return contents;
         }
 
+        public BigInteger GetInteger() => GetInteger(Asn1Tag.Integer);
+
+        public BigInteger GetInteger(Asn1Tag expectedTag)
+        {
+            ReadOnlyMemory<byte> contents =
+                GetIntegerContents(expectedTag, UniversalTagNumber.Integer, out int headerLength);
+
+            // TODO: Split this for netcoreapp/netstandard to use the Big-Endian BigInteger parsing
+            byte[] tmp = ArrayPool<byte>.Shared.Rent(contents.Length);
+            BigInteger value;
+
+            try
+            {
+                byte fill = (contents.Span[0] & 0x80) == 0 ? (byte)0 : (byte)0xFF;
+                // Fill the unused portions of tmp with positive or negative padding.
+                new Span<byte>(tmp, contents.Length, tmp.Length - contents.Length).Fill(fill);
+                contents.CopyTo(tmp);
+                // Convert to Little-Endian.
+                AsnWriter.Reverse(new Span<byte>(tmp, 0, contents.Length));
+                value = new BigInteger(tmp);
+            }
+            finally
+            {
+                // Clear the whole tmp so that not even the sign bit is returned to the array pool.
+                Array.Clear(tmp, 0, tmp.Length);
+                ArrayPool<byte>.Shared.Return(tmp);
+            }
+
+            _data = _data.Slice(headerLength + contents.Length);
+            return value;
+        }
+
         private bool TryReadSignedInteger(
             int sizeLimit,
             Asn1Tag expectedTag,

src/Common/src/System/Security/Cryptography/AsnReader.cs

@@ -1544,7 +1544,7 @@ private static void SortContents(byte[] buffer, int start, int end)
             ArrayPool<byte>.Shared.Return(tmp);
         }
 
-        private static void Reverse(Span<byte> span)
+        internal static void Reverse(Span<byte> span)
         {
             int i = 0;
             int j = span.Length - 1;

src/Common/src/System/Security/Cryptography/AsnWriter.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System.Numerics;
 using System.Security.Cryptography.Asn1;
 using Test.Cryptography;
 using Xunit;
@@ -415,6 +416,112 @@ public static void GetIntegerBytes()
             Assert.Equal(Payload, contents.ByteArrayToHex());
         }
 
+        [Theory]
+        [InlineData(PublicEncodingRules.BER)]
+        [InlineData(PublicEncodingRules.CER)]
+        [InlineData(PublicEncodingRules.DER)]
+        public static void GetBigInteger(PublicEncodingRules ruleSet)
+        {
+            byte[] inputData = (
+                "0282010100A46861FA9D5DB763633BF5A64EF6E7C2C2367F48D2D46643A22DFC" +
+                "FCCB24E58A14D0F06BDC956437F2A56BA4BEF70BA361BF12964A0D665AFD84B0" +
+                "F7494C8FA4ABC5FCA2E017C06178AEF2CDAD1B5F18E997A14B965C074E8F5649" +
+                "70607276B00583932240FE6E2DD013026F9AE13D7C91CC07C4E1E8E87737DC06" +
+                "EF2B575B89D62EFE46859F8255A123692A706C68122D4DAFE11CB205A7B3DE06" +
+                "E553F7B95F978EF8601A8DF819BF32040BDF92A0DE0DF269B4514282E17AC699" +
+                "34E8440A48AB9D1F5DF89A502CEF6DFDBE790045BD45E0C94E5CA8ADD76A013E" +
+                "9C978440FC8A9E2A9A4940B2460819C3E302AA9C9F355AD754C86D3ED77DDAA3" +
+                "DA13810B4D").HexToByteArray();
+
+            BigInteger expected = BigInteger.Parse(
+                "2075455505718444046766086325128514549301113944667492053189486607" +
+                "5638152321436011512404808361119326026027238444019992518081753153" +
+                "5965931647037093368608713442955529617501657176146245891571745113" +
+                "4028700771890451167051818999837042261788828826028681595867897235" +
+                "7967091503500375497498573022675671178275171110498592645868107163" +
+                "8525996766798322809764200941677343791419428587801897366593842552" +
+                "7272226864578661449281241619675217353931828233756506947863330597" +
+                "8338073826285687331647183058971791153730741973483420110408271570" +
+                "1367336140572971505716740825623220507359429297584634909330541150" +
+                "79473593821332264673455059897928082590541");
+
+            AsnReader reader = new AsnReader(inputData, (AsnEncodingRules)ruleSet);
+            Assert.Equal(expected, reader.GetInteger());
+        }
+
+        [Theory]
+        [InlineData(PublicEncodingRules.BER)]
+        [InlineData(PublicEncodingRules.CER)]
+        [InlineData(PublicEncodingRules.DER)]
+        public static void GetNegativeBigInteger(PublicEncodingRules ruleSet)
+        {
+            // This uses a length that doesn't line up with the array pool size so
+            // the fill code gets tested on netstandard.
+            // It's the same data as above, minus the padding and lead byte (and the
+            // next byte changed from 0x68 to 0x88)
+            byte[] inputData = (
+                "0281FF8861FA9D5DB763633BF5A64EF6E7C2C2367F48D2D46643A22DFC" +
+                "FCCB24E58A14D0F06BDC956437F2A56BA4BEF70BA361BF12964A0D665AFD84B0" +
+                "F7494C8FA4ABC5FCA2E017C06178AEF2CDAD1B5F18E997A14B965C074E8F5649" +
+                "70607276B00583932240FE6E2DD013026F9AE13D7C91CC07C4E1E8E87737DC06" +
+                "EF2B575B89D62EFE46859F8255A123692A706C68122D4DAFE11CB205A7B3DE06" +
+                "E553F7B95F978EF8601A8DF819BF32040BDF92A0DE0DF269B4514282E17AC699" +
+                "34E8440A48AB9D1F5DF89A502CEF6DFDBE790045BD45E0C94E5CA8ADD76A013E" +
+                "9C978440FC8A9E2A9A4940B2460819C3E302AA9C9F355AD754C86D3ED77DDAA3" +
+                "DA13810B4D").HexToByteArray();
+
+            BigInteger expected = BigInteger.Parse(
+                "-" +
+                "5898547409447487884446992857601985651316300515844052200158198046" +
+                "7814538020408452501006415149581619776188797413593169277984980446" +
+                "1302361382932378450492052337986628823880000831383555853860116718" +
+                "5361729331647715885538858385106930514758305144777880150203212976" +
+                "6715081632226412951106013360243549075631850526067219857352295397" +
+                "2308328327377769665309386917336850273904442596855844458638806936" +
+                "6169824439111394938336579524651037239551388910737675470211780509" +
+                "8035477769907389338548451561341965157059382875181284370047601682" +
+                "6924486017215979427815833587119797658480104671279234402026468966" +
+                "86109928634475300812601680679147599027");
+
+            AsnReader reader = new AsnReader(inputData, (AsnEncodingRules)ruleSet);
+            Assert.Equal(expected, reader.GetInteger());
+        }
+
+        [Theory]
+        [InlineData(PublicEncodingRules.BER)]
+        [InlineData(PublicEncodingRules.CER)]
+        [InlineData(PublicEncodingRules.DER)]
+        public static void GetDiminutiveBigInteger(PublicEncodingRules ruleSet)
+        {
+            // GetBigInteger with the last byte removed.
+            // Since it is no longer an ArrayPool alignment size the fill code gets tested on netstandard.
+            byte[] inputData = (
+                "0282010000A46861FA9D5DB763633BF5A64EF6E7C2C2367F48D2D46643A22DFC" +
+                "FCCB24E58A14D0F06BDC956437F2A56BA4BEF70BA361BF12964A0D665AFD84B0" +
+                "F7494C8FA4ABC5FCA2E017C06178AEF2CDAD1B5F18E997A14B965C074E8F5649" +
+                "70607276B00583932240FE6E2DD013026F9AE13D7C91CC07C4E1E8E87737DC06" +
+                "EF2B575B89D62EFE46859F8255A123692A706C68122D4DAFE11CB205A7B3DE06" +
+                "E553F7B95F978EF8601A8DF819BF32040BDF92A0DE0DF269B4514282E17AC699" +
+                "34E8440A48AB9D1F5DF89A502CEF6DFDBE790045BD45E0C94E5CA8ADD76A013E" +
+                "9C978440FC8A9E2A9A4940B2460819C3E302AA9C9F355AD754C86D3ED77DDAA3" +
+                "DA13810B").HexToByteArray();
+
+            BigInteger expected = BigInteger.Parse(
+                "2075455505718444046766086325128514549301113944667492053189486607" +
+                "5638152321436011512404808361119326026027238444019992518081753153" +
+                "5965931647037093368608713442955529617501657176146245891571745113" +
+                "4028700771890451167051818999837042261788828826028681595867897235" +
+                "7967091503500375497498573022675671178275171110498592645868107163" +
+                "8525996766798322809764200941677343791419428587801897366593842552" +
+                "7272226864578661449281241619675217353931828233756506947863330597" +
+                "8338073826285687331647183058971791153730741973483420110408271570" +
+                "1367336140572971505716740825623220507359429297584634909330541150" +
+                "79473593821332264673455059897928082590541") >> 8;
+
+            AsnReader reader = new AsnReader(inputData, (AsnEncodingRules)ruleSet);
+            Assert.Equal(expected, reader.GetInteger());
+        }
+
         [Theory]
         [InlineData(PublicEncodingRules.BER)]
         [InlineData(PublicEncodingRules.CER)]