为什么 Json.NET 无法序列化 X509Certificate2？

Question

每当我尝试使用 Json.NET 序列化 X509Certificate2 实例（不使用其 ISerialized 实现，但选择忽略它）时，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 serialization 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();
    }
}