Пример #1
0
        // SEQUENCE
        //   INTEGER 0 version
        //   SEQUENCE
        //     OBJECT IDENTIFIER 1.2.840.113549.1.1.1
        //     NULL
        //   OCTET STRING
        //     SEQUENCE
        //       INTEGER 0
        //       INTEGER N
        //       INTEGER E
        //       INTEGER D
        //       INTEGER P
        //       INTEGER Q
        //       INTEGER DP
        //       INTEGER DQ
        //       INTEGER QI
        private static RsaJwk ReadRsaPrivateKey(ref AsnReader reader)
        {
            reader = reader.ReadOctetString();
            reader = reader.ReadSequence();
            var version = reader.ReadInteger();

            if (version.Length != 1 || version[0] != 0)
            {
                ThrowHelper.ThrowInvalidOperationException_InvalidPem();
            }

            var n  = reader.ReadInteger();
            var e  = reader.ReadInteger();
            var d  = reader.ReadInteger();
            var p  = reader.ReadInteger();
            var q  = reader.ReadInteger();
            var dp = reader.ReadInteger();
            var dq = reader.ReadInteger();
            var qi = reader.ReadInteger();

            if (reader.Read())
            {
                ThrowHelper.ThrowInvalidOperationException_InvalidPem();
            }

            return(RsaJwk.FromByteArray(
                       n: AsnReader.TrimLeadingZeroes(n),
                       e: AsnReader.TrimLeadingZeroes(e, align: false),
                       d: AsnReader.TrimLeadingZeroes(d),
                       p: AsnReader.TrimLeadingZeroes(p),
                       q: AsnReader.TrimLeadingZeroes(q),
                       dp: AsnReader.TrimLeadingZeroes(dp),
                       dq: AsnReader.TrimLeadingZeroes(dq),
                       qi: AsnReader.TrimLeadingZeroes(qi)));
        }
Пример #2
0
        // SEQUENCE
        //   INTEGER N
        //   INTEGER E
        public static RsaJwk ReadRsaPublicKey(ReadOnlySpan <char> key)
        {
            var data = key.Slice(PublicRsaKeyPrefix.Length, key.Length - PublicRsaKeyPrefix.Length - PublicRsaKeySuffix.Length);

            byte[]      tmpArray;
            Span <byte> keyData = tmpArray = ArrayPool <byte> .Shared.Rent(Base64.GetArraySizeRequiredToDecode(data.Length));

            try
            {
                int length = Base64.Decode(data, keyData);
                var reader = new AsnReader(keyData.Slice(0, length));

                reader = reader.ReadSequence();
                var n = reader.ReadInteger();
                var e = reader.ReadInteger();
                if (reader.Read())
                {
                    ThrowHelper.ThrowInvalidOperationException_InvalidPem();
                }

                return(RsaJwk.FromByteArray(
                           n: AsnReader.TrimLeadingZeroes(n),
                           e: AsnReader.TrimLeadingZeroes(e, align: false)));
            }
            finally
            {
                ArrayPool <byte> .Shared.Return(tmpArray);
            }
        }
Пример #3
0
        // SEQUENCE
        //   SEQUENCE
        //     OBJECT IDENTIFIER 1.2.840.113549.1.1.1
        //     NULL
        //   BIT STRING
        //     SEQUENCE
        //       INTEGER N
        //       INTEGER E
        private static AsymmetricJwk ReadRsaPublicKey(ref AsnReader reader)
        {
            reader = reader.ReadBitString();
            reader = reader.ReadSequence();
            var n = reader.ReadInteger();
            var e = reader.ReadInteger();

            if (reader.Read())
            {
                ThrowHelper.ThrowInvalidOperationException_InvalidPem();
            }

            return(RsaJwk.FromByteArray(
                       n: AsnReader.TrimLeadingZeroes(n),
                       e: AsnReader.TrimLeadingZeroes(e, align: false)));
        }
Пример #4
0
        // SEQUENCE
        //   INTEGER 0
        //   INTEGER N
        //   INTEGER E
        //   INTEGER D
        //   INTEGER P
        //   INTEGER Q
        //   INTEGER DP
        //   INTEGER DQ
        //   INTEGER QI
        public static RsaJwk ReadRsaPrivateKey(ReadOnlySpan <char> key)
        {
            var data = key.Slice(PrivateRsaKeyPrefix.Length, key.Length - PrivateRsaKeyPrefix.Length - PrivatRsaKeySuffix.Length);

            byte[]      tmpArray;
            Span <byte> keyData = tmpArray = ArrayPool <byte> .Shared.Rent(Base64.GetArraySizeRequiredToDecode(data.Length));

            try
            {
                int length = Base64.Decode(data, keyData);
                var reader = new AsnReader(keyData.Slice(0, length));
                reader = reader.ReadSequence();
                var version = reader.ReadInteger();
                if (version.Length != 1 || version[0] != 0)
                {
                    ThrowHelper.ThrowInvalidOperationException_InvalidPem();
                }

                var n  = reader.ReadInteger();
                var e  = reader.ReadInteger();
                var d  = reader.ReadInteger();
                var p  = reader.ReadInteger();
                var q  = reader.ReadInteger();
                var dp = reader.ReadInteger();
                var dq = reader.ReadInteger();
                var qi = reader.ReadInteger();
                if (reader.Read())
                {
                    ThrowHelper.ThrowInvalidOperationException_InvalidPem();
                }

                return(RsaJwk.FromByteArray(
                           n: AsnReader.TrimLeadingZeroes(n),
                           e: AsnReader.TrimLeadingZeroes(e, align: false),
                           d: AsnReader.TrimLeadingZeroes(d),
                           p: AsnReader.TrimLeadingZeroes(p),
                           q: AsnReader.TrimLeadingZeroes(q),
                           dp: AsnReader.TrimLeadingZeroes(dp),
                           dq: AsnReader.TrimLeadingZeroes(dq),
                           qi: AsnReader.TrimLeadingZeroes(qi)));
            }
            finally
            {
                ArrayPool <byte> .Shared.Return(tmpArray);
            }
        }
Пример #5
0
        // SEQUENCE
        //   INTEGER N
        //   INTEGER E
        public static RsaJwk ReadRsaPublicKey(string key)
        {
            string base64KeyData = key.Substring(PublicRsaKeyPrefix.Length, key.Length - PublicRsaKeyPrefix.Length - PublicRsaKeySuffix.Length);

            byte[] keyData = Convert.FromBase64String(base64KeyData);

            var reader = new AsnReader(keyData);

            reader = reader.ReadSequence();
            var n = reader.ReadInteger();
            var e = reader.ReadInteger();

            if (reader.Read())
            {
                ThrowHelper.ThrowInvalidOperationException_InvalidPem();
            }

            return(RsaJwk.FromByteArray(
                       n: AsnReader.TrimLeadingZeroes(n),
                       e: AsnReader.TrimLeadingZeroes(e, align: false)));
        }
Пример #6
0
        // SEQUENCE
        //   INTEGER 0
        //   INTEGER N
        //   INTEGER E
        //   INTEGER D
        //   INTEGER P
        //   INTEGER Q
        //   INTEGER DP
        //   INTEGER DQ
        //   INTEGER QI
        public static RsaJwk ReadRsaPrivateKey(string key)
        {
            string base64KeyData = key.Substring(PrivateRsaKeyPrefix.Length, key.Length - PrivateRsaKeyPrefix.Length - PrivatRsaKeySuffix.Length);

            byte[] keyData = Convert.FromBase64String(base64KeyData);

            var reader = new AsnReader(keyData);

            reader = reader.ReadSequence();
            var version = reader.ReadInteger();

            if (version.Length != 1 || version[0] != 0)
            {
                ThrowHelper.ThrowInvalidOperationException_InvalidPem();
            }

            var n  = reader.ReadInteger();
            var e  = reader.ReadInteger();
            var d  = reader.ReadInteger();
            var p  = reader.ReadInteger();
            var q  = reader.ReadInteger();
            var dp = reader.ReadInteger();
            var dq = reader.ReadInteger();
            var qi = reader.ReadInteger();

            if (reader.Read())
            {
                ThrowHelper.ThrowInvalidOperationException_InvalidPem();
            }

            return(RsaJwk.FromByteArray(
                       n: AsnReader.TrimLeadingZeroes(n),
                       e: AsnReader.TrimLeadingZeroes(e, align: false),
                       d: AsnReader.TrimLeadingZeroes(d),
                       p: AsnReader.TrimLeadingZeroes(p),
                       q: AsnReader.TrimLeadingZeroes(q),
                       dp: AsnReader.TrimLeadingZeroes(dp),
                       dq: AsnReader.TrimLeadingZeroes(dq),
                       qi: AsnReader.TrimLeadingZeroes(qi)));
        }
Пример #7
0
        public void Factory()
        {
            var kid  = JsonEncodedText.Encode("RuGrMG6-Xv3nZp-KaC_WmcwN1W7epSOnZXjIEDKugTE");
            var s_e  = "AQAB";
            var s_n  = "uyNaTUSDYSzexCCtHEcC8aTrAn80iSueyawKxkc58y_66H4NasGBPCoj2ldfvs35DIR-FcoOmtFH9bOTjq7iXQ";
            var s_d  = "JuoHESI6H67w89_Hn6W0mwMsS2ygRBXqAw3ff7O3_TWV74dI6D32xssm5Kw9dZ-glQTHLb1Ze3zsETOS0DpqEQ";
            var s_dp = "quGD4O4sGxrwjtudAEQrJLqVd1dTKuXxKI5nwaLqL2k";
            var s_dq = "SlA1yPjn7trMdIJh4CeniYhilBK_kS6IoPH0bgdx_nE";
            var s_p  = "1sEtUC-Bbg60vg_OfvmObWcpL-CiIRK7wY3V3EZbPgM";
            var s_q  = "3xRbedccU7VGQOanMbxcggQU-KbU_RHYODiI9Vn2IB8";
            var s_qi = "nqROjNAHls0Kh6CxcswXgyD0pDwl-p4QQYH4O4qUdNw";

            var e  = Base64Url.Decode(s_e);
            var n  = Base64Url.Decode(s_n);
            var d  = Base64Url.Decode(s_d);
            var dp = Base64Url.Decode(s_dp);
            var dq = Base64Url.Decode(s_dq);
            var p  = Base64Url.Decode(s_p);
            var q  = Base64Url.Decode(s_q);
            var qi = Base64Url.Decode(s_qi);

            // FromBase64Url
            var key = RsaJwk.FromBase64Url(n: s_n, e: s_e, KeyManagementAlgorithm.RsaOaep, computeThumbprint: true);

            Assert.True(key.N.SequenceEqual(n));
            Assert.True(key.E.SequenceEqual(e));
            Assert.True(key.D.IsEmpty);
            Assert.True(key.P.IsEmpty);
            Assert.True(key.Q.IsEmpty);
            Assert.True(key.DP.IsEmpty);
            Assert.True(key.DQ.IsEmpty);
            Assert.True(key.QI.IsEmpty);
            Assert.Equal(kid, key.Kid);

            key = RsaJwk.FromBase64Url(n: s_n, e: s_e, KeyManagementAlgorithm.RsaOaep, computeThumbprint: false);
            Assert.True(key.N.SequenceEqual(n));
            Assert.True(key.E.SequenceEqual(e));
            Assert.True(key.D.IsEmpty);
            Assert.True(key.P.IsEmpty);
            Assert.True(key.Q.IsEmpty);
            Assert.True(key.DP.IsEmpty);
            Assert.True(key.DQ.IsEmpty);
            Assert.True(key.QI.IsEmpty);
            Assert.True(key.Kid.EncodedUtf8Bytes.IsEmpty);

            key = RsaJwk.FromBase64Url(n: s_n, e: s_e, d: s_d, p: s_p, q: s_q, dp: s_dp, dq: s_dq, qi: s_qi, KeyManagementAlgorithm.RsaOaep, computeThumbprint: true);
            Assert.True(key.N.SequenceEqual(n));
            Assert.True(key.E.SequenceEqual(e));
            Assert.True(key.D.SequenceEqual(d));
            Assert.True(key.P.SequenceEqual(p));
            Assert.True(key.Q.SequenceEqual(q));
            Assert.True(key.DP.SequenceEqual(dp));
            Assert.True(key.DQ.SequenceEqual(dq));
            Assert.True(key.QI.SequenceEqual(qi));
            Assert.Equal(kid, key.Kid);

            key = RsaJwk.FromBase64Url(n: s_n, e: s_e, d: s_d, p: s_p, q: s_q, dp: s_dp, dq: s_dq, qi: s_qi, KeyManagementAlgorithm.RsaOaep, computeThumbprint: false);
            Assert.True(key.N.SequenceEqual(n));
            Assert.True(key.E.SequenceEqual(e));
            Assert.True(key.D.SequenceEqual(d));
            Assert.True(key.P.SequenceEqual(p));
            Assert.True(key.Q.SequenceEqual(q));
            Assert.True(key.DP.SequenceEqual(dp));
            Assert.True(key.DQ.SequenceEqual(dq));
            Assert.True(key.QI.SequenceEqual(qi));
            Assert.True(key.Kid.EncodedUtf8Bytes.IsEmpty);

            key = RsaJwk.FromBase64Url(n: s_n, e: s_e, SignatureAlgorithm.RS256, computeThumbprint: true);
            Assert.True(key.N.SequenceEqual(n));
            Assert.True(key.E.SequenceEqual(e));
            Assert.True(key.D.IsEmpty);
            Assert.True(key.P.IsEmpty);
            Assert.True(key.Q.IsEmpty);
            Assert.True(key.DP.IsEmpty);
            Assert.True(key.DQ.IsEmpty);
            Assert.True(key.QI.IsEmpty);
            Assert.Equal(kid, key.Kid);

            key = RsaJwk.FromBase64Url(n: s_n, e: s_e, SignatureAlgorithm.RS256, computeThumbprint: false);
            Assert.True(key.N.SequenceEqual(n));
            Assert.True(key.E.SequenceEqual(e));
            Assert.True(key.D.IsEmpty);
            Assert.True(key.P.IsEmpty);
            Assert.True(key.Q.IsEmpty);
            Assert.True(key.DP.IsEmpty);
            Assert.True(key.DQ.IsEmpty);
            Assert.True(key.QI.IsEmpty);
            Assert.True(key.Kid.EncodedUtf8Bytes.IsEmpty);

            key = RsaJwk.FromBase64Url(n: s_n, e: s_e, d: s_d, p: s_p, q: s_q, dp: s_dp, dq: s_dq, qi: s_qi, SignatureAlgorithm.RS256, computeThumbprint: true);
            Assert.True(key.N.SequenceEqual(n));
            Assert.True(key.E.SequenceEqual(e));
            Assert.True(key.D.SequenceEqual(d));
            Assert.True(key.P.SequenceEqual(p));
            Assert.True(key.Q.SequenceEqual(q));
            Assert.True(key.DP.SequenceEqual(dp));
            Assert.True(key.DQ.SequenceEqual(dq));
            Assert.True(key.QI.SequenceEqual(qi));
            Assert.Equal(kid, key.Kid);

            key = RsaJwk.FromBase64Url(n: s_n, e: s_e, d: s_d, p: s_p, q: s_q, dp: s_dp, dq: s_dq, qi: s_qi, SignatureAlgorithm.RS256, computeThumbprint: false);
            Assert.True(key.N.SequenceEqual(n));
            Assert.True(key.E.SequenceEqual(e));
            Assert.True(key.D.SequenceEqual(d));
            Assert.True(key.P.SequenceEqual(p));
            Assert.True(key.Q.SequenceEqual(q));
            Assert.True(key.DP.SequenceEqual(dp));
            Assert.True(key.DQ.SequenceEqual(dq));
            Assert.True(key.QI.SequenceEqual(qi));
            Assert.True(key.Kid.EncodedUtf8Bytes.IsEmpty);


            // FromByteArray
            key = RsaJwk.FromByteArray(n: n, e: e, KeyManagementAlgorithm.RsaOaep, computeThumbprint: true);
            Assert.True(key.N.SequenceEqual(n));
            Assert.True(key.E.SequenceEqual(e));
            Assert.True(key.D.IsEmpty);
            Assert.True(key.P.IsEmpty);
            Assert.True(key.Q.IsEmpty);
            Assert.True(key.DP.IsEmpty);
            Assert.True(key.DQ.IsEmpty);
            Assert.True(key.QI.IsEmpty);
            Assert.Equal(kid, key.Kid);

            key = RsaJwk.FromByteArray(n: n, e: e, KeyManagementAlgorithm.RsaOaep, computeThumbprint: false);
            Assert.True(key.N.SequenceEqual(n));
            Assert.True(key.E.SequenceEqual(e));
            Assert.True(key.D.IsEmpty);
            Assert.True(key.P.IsEmpty);
            Assert.True(key.Q.IsEmpty);
            Assert.True(key.DP.IsEmpty);
            Assert.True(key.DQ.IsEmpty);
            Assert.True(key.QI.IsEmpty);
            Assert.True(key.Kid.EncodedUtf8Bytes.IsEmpty);

            key = RsaJwk.FromByteArray(n: n, e: e, d: d, p: p, q: q, dp: dp, dq: dq, qi: qi, KeyManagementAlgorithm.RsaOaep, computeThumbprint: true);
            Assert.True(key.N.SequenceEqual(n));
            Assert.True(key.E.SequenceEqual(e));
            Assert.True(key.D.SequenceEqual(d));
            Assert.True(key.P.SequenceEqual(p));
            Assert.True(key.Q.SequenceEqual(q));
            Assert.True(key.DP.SequenceEqual(dp));
            Assert.True(key.DQ.SequenceEqual(dq));
            Assert.True(key.QI.SequenceEqual(qi));
            Assert.Equal(kid, key.Kid);

            key = RsaJwk.FromByteArray(n: n, e: e, d: d, p: p, q: q, dp: dp, dq: dq, qi: qi, KeyManagementAlgorithm.RsaOaep, computeThumbprint: false);
            Assert.True(key.N.SequenceEqual(n));
            Assert.True(key.E.SequenceEqual(e));
            Assert.True(key.D.SequenceEqual(d));
            Assert.True(key.P.SequenceEqual(p));
            Assert.True(key.Q.SequenceEqual(q));
            Assert.True(key.DP.SequenceEqual(dp));
            Assert.True(key.DQ.SequenceEqual(dq));
            Assert.True(key.QI.SequenceEqual(qi));
            Assert.True(key.Kid.EncodedUtf8Bytes.IsEmpty);

            key = RsaJwk.FromByteArray(n: n, e: e, SignatureAlgorithm.RS256, computeThumbprint: true);
            Assert.True(key.N.SequenceEqual(n));
            Assert.True(key.E.SequenceEqual(e));
            Assert.True(key.D.IsEmpty);
            Assert.True(key.P.IsEmpty);
            Assert.True(key.Q.IsEmpty);
            Assert.True(key.DP.IsEmpty);
            Assert.True(key.DQ.IsEmpty);
            Assert.True(key.QI.IsEmpty);
            Assert.Equal(kid, key.Kid);

            key = RsaJwk.FromByteArray(n: n, e: e, SignatureAlgorithm.RS256, computeThumbprint: false);
            Assert.True(key.N.SequenceEqual(n));
            Assert.True(key.E.SequenceEqual(e));
            Assert.True(key.D.IsEmpty);
            Assert.True(key.P.IsEmpty);
            Assert.True(key.Q.IsEmpty);
            Assert.True(key.DP.IsEmpty);
            Assert.True(key.DQ.IsEmpty);
            Assert.True(key.QI.IsEmpty);
            Assert.True(key.Kid.EncodedUtf8Bytes.IsEmpty);

            key = RsaJwk.FromByteArray(n: n, e: e, d: d, p: p, q: q, dp: dp, dq: dq, qi: qi, SignatureAlgorithm.RS256, computeThumbprint: true);
            Assert.True(key.N.SequenceEqual(n));
            Assert.True(key.E.SequenceEqual(e));
            Assert.True(key.D.SequenceEqual(d));
            Assert.True(key.P.SequenceEqual(p));
            Assert.True(key.Q.SequenceEqual(q));
            Assert.True(key.DP.SequenceEqual(dp));
            Assert.True(key.DQ.SequenceEqual(dq));
            Assert.True(key.QI.SequenceEqual(qi));
            Assert.Equal(kid, key.Kid);

            key = RsaJwk.FromByteArray(n: n, e: e, d: d, p: p, q: q, dp: dp, dq: dq, qi: qi, SignatureAlgorithm.RS256, computeThumbprint: false);
            Assert.True(key.N.SequenceEqual(n));
            Assert.True(key.E.SequenceEqual(e));
            Assert.True(key.D.SequenceEqual(d));
            Assert.True(key.P.SequenceEqual(p));
            Assert.True(key.Q.SequenceEqual(q));
            Assert.True(key.DP.SequenceEqual(dp));
            Assert.True(key.DQ.SequenceEqual(dq));
            Assert.True(key.QI.SequenceEqual(qi));
            Assert.True(key.Kid.EncodedUtf8Bytes.IsEmpty);
        }