CommandProviderConfiguration.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Text.Json.Serialization;
using System.Threading.Tasks;
 
namespace SAPTeam.EasySign.CommandLine
{
    public class CommandProviderConfiguration
    {
        public Dictionary<string, bool> Settings { get; set; } = new Dictionary<string, bool>
        {
            ["trust.enable"] = true,
            ["selfsign.enable"] = true,
        };
 
        protected string[] ProtectedPrefixes { get; set; } = [];
 
        public Dictionary<string, byte[]> TrustedRootCA { get; set; } = [];
 
        public Dictionary<string, byte[]> IntermediateCA { get; set; } = [];
 
        public Dictionary<string, byte[]> IssuedCertificates { get; set; } = [];
 
        public byte[]? SelfSignedRootCA { get; set; } = null;
 
        public CommandProviderConfiguration()
        {
            
        }
 
        public CommandProviderConfiguration(string[] protectedPrefixes)
        {
            AddProtectedPrefix(protectedPrefixes);
        }
 
        protected void CheckProtectedPrefix(string id)
        {
            if (IsProtected(id))
            {
                throw new InvalidOperationException($"The ID '{id}' is protected and cannot be modified.");
            }
        }
 
        public bool IsProtected(string id)
        {
            return ProtectedPrefixes.Any(id.StartsWith);
        }
 
        public void AddProtectedPrefix(params string[] prefixes)
        {
            if (prefixes == null || prefixes.Length == 0)
            {
                throw new ArgumentNullException(nameof(prefixes), "Prefixes cannot be null or empty.");
            }
 
            ProtectedPrefixes = ProtectedPrefixes.Union(prefixes).ToArray();
        }
 
        public void AddSAPTeamCertificates()
        {
            AddProtectedPrefix("sapteam:");
 
            TrustedRootCA["sapteam:rootca"] = SAPTeamCertificates.RootCA;
            IntermediateCA["sapteam:packages"] = SAPTeamCertificates.PackagesIntermediateCA;
        }
 
        public string AddCertificate(CertificateStore certificateStore, X509Certificate2 certificate, string? id = null)
        {
            id = !string.IsNullOrEmpty(id) ? id : certificate.Thumbprint.ToLowerInvariant()[^6..];
            if (certificateStore != CertificateStore.IssuedCertificates)
            {
                CheckProtectedPrefix(id);
            }
 
            byte[] data = certificateStore == CertificateStore.IssuedCertificates ? certificate.Export(X509ContentType.Pfx) : certificate.Export(X509ContentType.Cert);
 
            switch (certificateStore)
            {
                case CertificateStore.TrustedRootCA:
                    TrustedRootCA[id] = data;
                    break;
                case CertificateStore.IntermediateCA:
                    IntermediateCA[id] = data;
                    break;
                case CertificateStore.IssuedCertificates:
                    IssuedCertificates[id] = data;
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(certificateStore), certificateStore, null);
            }
 
            return id;
        }
 
        public X509Certificate2Collection LoadCertificates(CertificateStore certificateStore)
        {
            X509Certificate2Collection certificates = new X509Certificate2Collection();
 
            switch (certificateStore)
            {
                case CertificateStore.TrustedRootCA:
                    foreach (var id in TrustedRootCA.Keys)
                    {
                        certificates.Add(LoadCertificate(certificateStore, id));
                    }
                    break;
                case CertificateStore.IntermediateCA:
                    foreach (var id in IntermediateCA.Keys)
                    {
                        certificates.Add(LoadCertificate(certificateStore, id));
                    }
                    break;
                case CertificateStore.IssuedCertificates:
                    foreach (var id in IssuedCertificates.Keys)
                    {
                        certificates.Add(LoadCertificate(certificateStore, id));
                    }
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(certificateStore), certificateStore, null);
            }
 
            return certificates;
        }
 
        public X509Certificate2 LoadCertificate(CertificateStore certificateStore, string id)
        {
            byte[] data;
 
            switch (certificateStore)
            {
                case CertificateStore.TrustedRootCA:
                    data = TrustedRootCA[id];
                    break;
                case CertificateStore.IntermediateCA:
                    data = IntermediateCA[id];
                    break;
                case CertificateStore.IssuedCertificates:
                    data = IssuedCertificates[id];
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(certificateStore), certificateStore, null);
            }
 
            return certificateStore == CertificateStore.IssuedCertificates
                ? CertificateUtilities.ImportPFX(data).Single()
                : CertificateUtilities.Import(data);
        }
 
        public bool RemoveCertificate(CertificateStore certificateStore, string id)
        {
            if (certificateStore != CertificateStore.IssuedCertificates)
            {
                CheckProtectedPrefix(id);
            }
 
            bool result;
 
            switch (certificateStore)
            {
                case CertificateStore.TrustedRootCA:
                    result = TrustedRootCA.Remove(id);
                    break;
                case CertificateStore.IntermediateCA:
                    result = IntermediateCA.Remove(id);
                    break;
                case CertificateStore.IssuedCertificates:
                    result = IssuedCertificates.Remove(id);
                    break;
                default:
                    throw new ArgumentOutOfRangeException(nameof(certificateStore), certificateStore, null);
            }
 
            return result;
        }
    }
}