Merged with dotnet/release/2.2.

3 files changed, 125 insertions, 0 deletions

diff --git a/src/System.Security.Cryptography.Encoding/tests/Asn1/Serializer/SimpleDeserialize.cs b/src/System.Security.Cryptography.Encoding/tests/Asn1/Serializer/SimpleDeserialize.cs
index e61f3ac4a6..1f2d1a7a6e 100644
--- a/src/System.Security.Cryptography.Encoding/tests/Asn1/Serializer/SimpleDeserialize.cs
+++ b/src/System.Security.Cryptography.Encoding/tests/Asn1/Serializer/SimpleDeserialize.cs
@@ -498,6 +498,25 @@ namespace System.Security.Cryptography.Tests.Asn1
             Assert.Equal("020100", parsed.OctetString.ByteArrayToHex());
             Assert.Equal("010203", parsed.BitString.ByteArrayToHex());
         }
+
+        [Theory]
+        [InlineData(PublicEncodingRules.BER)]
+        // Not CER since it uses a definite encoding for the sequence.
+        [InlineData(PublicEncodingRules.DER)]
+        public static void ReadNegativeIntegers(PublicEncodingRules ruleSet)
+        {
+            byte[] inputData = (
+                "3007" +
+                  "0201FE" +
+                  "0202FEEF").HexToByteArray();
+
+            BigIntegers bigIntegers = AsnSerializer.Deserialize<BigIntegers>(
+                inputData,
+                (AsnEncodingRules)ruleSet);
+
+            Assert.Equal(-2, (int)bigIntegers.First);
+            Assert.Equal("FEEF", bigIntegers.Second.ByteArrayToHex());
+        }
     }
 
     // RFC 3280 / ITU-T X.509
@@ -881,4 +900,13 @@ namespace System.Security.Cryptography.Tests.Asn1
         [ExpectedTag(1)]
         public ReadOnlyMemory<byte> BitString;
     }
+
+    [StructLayout(LayoutKind.Sequential)]
+    public struct BigIntegers
+    {
+        public BigInteger First;
+
+        [Integer]
+        public ReadOnlyMemory<byte> Second;
+    }
 }
diff --git a/src/System.Security.Cryptography.Encoding/tests/Asn1/Serializer/SimpleSerialize.cs b/src/System.Security.Cryptography.Encoding/tests/Asn1/Serializer/SimpleSerialize.cs
index 157f56ab71..4d1ea2dcd8 100644
--- a/src/System.Security.Cryptography.Encoding/tests/Asn1/Serializer/SimpleSerialize.cs
+++ b/src/System.Security.Cryptography.Encoding/tests/Asn1/Serializer/SimpleSerialize.cs
@@ -427,5 +427,20 @@ namespace System.Security.Cryptography.Tests.Asn1
                 Assert.Equal(expectedHex, writer.Encode().ByteArrayToHex());
             }
         }
+
+        [Fact]
+        public static void WriteNegativeIntegers()
+        {
+            BigIntegers bigIntegers = new BigIntegers
+            {
+                First = -273,
+                Second = new byte[] { 0xFE, 0xED, 0xF0, 0x0D },
+            };
+
+            using (AsnWriter writer = AsnSerializer.Serialize(bigIntegers, AsnEncodingRules.DER))
+            {
+                Assert.Equal("300A0202FEEF0204FEEDF00D", writer.EncodeAsSpan().ByteArrayToHex());
+            }
+        }
     }
 }
diff --git a/src/System.Security.Cryptography.Encoding/tests/Asn1/Writer/WriteInteger.cs b/src/System.Security.Cryptography.Encoding/tests/Asn1/Writer/WriteInteger.cs
index de17502ca9..d9fc7e7ce6 100644
--- a/src/System.Security.Cryptography.Encoding/tests/Asn1/Writer/WriteInteger.cs
+++ b/src/System.Security.Cryptography.Encoding/tests/Asn1/Writer/WriteInteger.cs
@@ -4,6 +4,7 @@
 
 using System.Numerics;
 using System.Security.Cryptography.Asn1;
+using Test.Cryptography;
 using Xunit;
 
 namespace System.Security.Cryptography.Tests.Asn1
@@ -280,6 +281,87 @@ namespace System.Security.Cryptography.Tests.Asn1
         }
 
         [Theory]
+        [InlineData("00")]
+        [InlineData("01")]
+        [InlineData("80")]
+        [InlineData("FF")]
+        [InlineData("0080")]
+        [InlineData("00FF")]
+        [InlineData("8000")]
+        [InlineData("00F0E0D0C0B0A090807060504030201000")]
+        [InlineData("FEFDFCFBFAF9F8F7F6F5F4F3F2F1F100")]
+        public void VerifyWriteInteger_EncodedBytes(string valueHex)
+        {
+            string expectedHex = "02" + (valueHex.Length / 2).ToString("X2") + valueHex;
+
+            using (AsnWriter writer = new AsnWriter(AsnEncodingRules.BER))
+            {
+                writer.WriteInteger(valueHex.HexToByteArray());
+
+                Verify(writer, expectedHex);
+            }
+        }
+
+        [Theory]
+        [InlineData("00")]
+        [InlineData("01")]
+        [InlineData("80")]
+        [InlineData("FF")]
+        [InlineData("0080")]
+        [InlineData("00FF")]
+        [InlineData("8000")]
+        [InlineData("00F0E0D0C0B0A090807060504030201000")]
+        [InlineData("FEFDFCFBFAF9F8F7F6F5F4F3F2F1F100")]
+        public void VerifyWriteInteger_Context4_EncodedBytes(string valueHex)
+        {
+            string expectedHex = "84" + (valueHex.Length / 2).ToString("X2") + valueHex;
+
+            using (AsnWriter writer = new AsnWriter(AsnEncodingRules.BER))
+            {
+                writer.WriteInteger(new Asn1Tag(TagClass.ContextSpecific, 4), valueHex.HexToByteArray());
+
+                Verify(writer, expectedHex);
+            }
+        }
+
+        [Theory]
+        [InlineData("")]
+        [InlineData("0000")]
+        [InlineData("0000000000000000000001")]
+        [InlineData("0001")]
+        [InlineData("007F")]
+        [InlineData("FFFF")]
+        [InlineData("FFFFFFFFFFFFFFFFFFFFFE")]
+        [InlineData("FF80")]
+        public void VerifyWriteInteger_InvalidEncodedValue_Throws(string valuHex)
+        {
+            using (AsnWriter writer = new AsnWriter(AsnEncodingRules.BER))
+            {
+                Assert.ThrowsAny<CryptographicException>(() => writer.WriteInteger(valuHex.HexToByteArray()));
+            }
+        }
+
+        [Theory]
+        [InlineData("")]
+        [InlineData("0000")]
+        [InlineData("0000000000000000000001")]
+        [InlineData("0001")]
+        [InlineData("007F")]
+        [InlineData("FFFF")]
+        [InlineData("FFFFFFFFFFFFFFFFFFFFFE")]
+        [InlineData("FF80")]
+        public void VerifyWriteInteger_Application3_InvalidEncodedValue_Throws(string valuHex)
+        {
+            using (AsnWriter writer = new AsnWriter(AsnEncodingRules.BER))
+            {
+                Asn1Tag tag = new Asn1Tag(TagClass.Application, 3);
+
+                Assert.ThrowsAny<CryptographicException>(
+                    () => writer.WriteInteger(tag, valuHex.HexToByteArray()));
+            }
+        }
+
+        [Theory]
         [InlineData(PublicEncodingRules.BER)]
         [InlineData(PublicEncodingRules.CER)]
         [InlineData(PublicEncodingRules.DER)]