為什么 Json.NET 無法序列化 X509Certificate2？

Question

每當我嘗試使用 Json.NET 序列化 X509Certificate2 實例時（不使用其 ISerializable 實現，但選擇忽略它），Json.NET 會引發異常。

異常消息是“'System.Security.Cryptography.X509Certificates.X509Certificate2'上已存在名為'CertContext'的成員。使用 JsonPropertyAttribute 指定另一個名稱。”

我寫了一個程序來重現它：

using System.Reflection;
using System.Security.Cryptography.X509Certificates;
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;

internal class Program
{
    private static void Main(string[] args)
    {
        var resolver = new DefaultContractResolver
        {
            IgnoreSerializableInterface = true,
            DefaultMembersSearchFlags =
                BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.GetProperty
        };

        JsonConvert.SerializeObject(new X509Certificate2(), new JsonSerializerSettings {ContractResolver = resolver});
    }
}

經過調查，我注意到 X509Certificate2 實現了一個名為“CertContext”的屬性，該屬性在其基類 X509Certificate 中隱藏了一個同名的方法。 我如何告訴 Json.NET 只采用派生程度最高的屬性，就像通常那樣？

Answer 1

我最近發現需要序列化X509Certificate2實例，以便比較兩個行為不同的假定相同環境的差異。 我能夠通過以下JsonSerializerSettings實現序列化：

new JsonSerializerSettings {
    Error = (s, a) => a.ErrorContext.Handled = true,
    ContractResolver = new DefaultContractResolver {
        IgnoreSerializableInterface = true
    }
}

這是一個完整的工作示例，它 JSON 序列化本地機器存儲中的第一個證書並打開它：

namespace ConsoleApp1
{
    using System.Diagnostics;
    using System.IO;
    using System.Security.Cryptography.X509Certificates;

    using Newtonsoft.Json;
    using Newtonsoft.Json.Serialization;

    class Program
    {
        static void Main(string[] args)
        {
            var store = new X509Store(StoreName.My, StoreLocation.LocalMachine);

            try
            {
                store.Open(OpenFlags.ReadOnly);

                var cert = store.Certificates[0];

                var path = Path.GetTempFileName();

                File.WriteAllText(
                    path,
                    JsonConvert.SerializeObject(
                        cert, new JsonSerializerSettings {
                            Formatting = Formatting.Indented,
                            // Ignore serializtion errors
                            Error = (s, a) => a.ErrorContext.Handled = true,
                            ContractResolver = new DefaultContractResolver {
                                // Ensures all properties are serialized
                                IgnoreSerializableInterface = true
                            }
                        }
                    )
                );

                Process.Start(path);
            }
            finally
            {
                store.Close();
            }
        }
    }
}

Answer 2

為此，您可以使用轉換器：

public class X509Certificate2JsonConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return objectType == typeof(X509Certificate2);
    }

    public override object ReadJson(JsonReader reader,
        Type objectType, object existingValue, JsonSerializer serializer)
    {
        var deserializedRaw = serializer.Deserialize<byte[]>(reader);
        var deserialized = new X509Certificate2(deserializedRaw);
        return deserialized;
    }

    public override void WriteJson(JsonWriter writer,
        object value, JsonSerializer serializer)
    {
        byte[] certData = ((X509Certificate2)value).Export(X509ContentType.Pfx);
        serializer.Serialize(writer, certData);
    }
}

以及對它的測試：

public class CertificateHolder : IDisposable
{
    [JsonConverter(typeof(X509Certificate2JsonConverter))]
    public X509Certificate2 Certificate { get; set; }

    public void Dispose() => Certificate?.Dispose();

    public static X509Certificate2 CreateCertificate()
    {
        var ecdsa = ECDsa.Create();
        var req = new CertificateRequest("cn=foobar", ecdsa, HashAlgorithmName.SHA256);
        var c = req.CreateSelfSigned(DateTimeOffset.Now, DateTimeOffset.Now.AddYears(5));
        return c;
    }
}

[TestFixture]
class X509Certificate2JsonConverterTests
{
    [Test]
    public void Serialization()
    {
        var holder = new CertificateHolder();
        holder.Certificate = CertificateHolder.CreateCertificate();
        var str = JsonConvert.SerializeObject(holder);
        var holderRestored = JsonConvert.DeserializeObject<CertificateHolder>(str);
        var holderStr = holder.Certificate.ToString();
        var holderRestoredStr = holderRestored.Certificate.ToString();
        Assert.AreEqual(holderStr, holderRestoredStr);
        holder.Dispose();
        holderRestored.Dispose();
    }
}