CertificateService.cs

#region Usings
using sage.ew.global;
using sage.ew.interficies;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Security;
using System.Security.Cryptography.X509Certificates;
using System.Text;
#endregion Using

namespace sage.ew.functions.Clases
{
    public class CertificateService : ICertificateService
    {
        #region Propiedades privadas
        List<string> _lstFileNameCert = new List<string>();
        private string _cMensajeError = string.Empty;
        #endregion _cMensajeError

        #region Constructor
        public CertificateService()
        {
        }
        #endregion Constructor

        #region Propiedades públicas
        public string _MensajeError
        {
            get { return _cMensajeError; }
        }
        #endregion Propiedades públicas

        #region Destructor
        ~CertificateService()
        {
            CloseService();
        }
        #endregion Destructor

        #region Métodos públicos
        public string _GetFileCertificate(string tcCertificateName, string tcCertificatePassword = "")
        {
            X509Certificate2 loCertX509 = null;
            string lcFileNameCert = string.Empty;

            try
            {
                byte[] fileContent = null;

                if (tcCertificateName == "ENTIDAD_FACEB2B")
                {
                    fileContent = RawCertificate(tcCertificateName);
                }
                else
                {
                    loCertX509 = GetCertificate(tcCertificateName, tcCertificatePassword);

                    if (loCertX509 != null)
                        fileContent = loCertX509.Export(X509ContentType.Pfx, tcCertificatePassword);
                }

                if (fileContent.Length > 0)
                {
                    lcFileNameCert = Path.GetTempFileName();
                    File.WriteAllBytes(lcFileNameCert, fileContent);
                    _lstFileNameCert.Add(lcFileNameCert);
                }
                else
                { 
                    lcFileNameCert = string.Empty;
                    _cMensajeError = string.Format("El certificado '{0}' no se ha importado correctamente. ", tcCertificateName);
                }
            }
            catch (SecurityException ex)
            {
                _cMensajeError = string.Format("El certificado '{0}' no se ha importado correctamente. {1}", tcCertificateName, ex.Message);
            }
            catch (Exception ex)
            {
                _cMensajeError = string.Format("El certificado '{0}' no se ha importado correctamente. {1}", tcCertificateName, ex);
            }

            return lcFileNameCert;
        }

        public void _CloseService()
        {
            CloseService();
        }
        #endregion Métodos públicos

        #region Métodos privados
        private void CloseService()
        {
            if (_lstFileNameCert.Count > 0)
            {
                foreach (string lcFile in _lstFileNameCert)
                    DeleteFile(lcFile);

                _lstFileNameCert.Clear();
            }
        }

        private void DeleteFile(string tcFileName)
        {
            try
            {
                if (File.Exists(tcFileName))
                    File.Delete(tcFileName);
            }
            catch (Exception)
            {
            }
        }

        private Byte[] RawCertificate(string tcCertificateName)
        {
            Byte[] loRawCertif = null;

            switch (tcCertificateName)
            {
                case "SAGESPAIN_SHA1":
                    if (FUNCTIONS._EntornoFaceB2B() == eEntornos.Pre)
                        loRawCertif = Properties.Resources.SAGESPAIN_PF_PRUEBAS;
                    else
                        loRawCertif = Properties.Resources.SAGESPAIN_SHA1;
                    break;

                case "SAGESPAIN":
                    if (FUNCTIONS._EntornoFaceB2B() == eEntornos.Pre)
                        loRawCertif = Properties.Resources.SAGESPAIN_PF_PRUEBAS;
                    else
                        loRawCertif = Properties.Resources.SAGESPAIN;
                    break;

                case "ENTIDAD_FACEB2B":
                    if (FUNCTIONS._EntornoFaceB2B() == eEntornos.Pre)
                        loRawCertif = Properties.Resources.SELLO_ENTIDAD_SGAD_PRUEBAS;
                    else
                        loRawCertif = Properties.Resources.SELLO_DE_ENTIDAD_SGAD;
                    break;

                default:
                    break;
            }

            return loRawCertif;
        }

        private X509Certificate2 GetCertificate(string tcCertificateName, string tcCertificatePassword)
        {
            if (String.IsNullOrEmpty(tcCertificateName))
                throw new SecurityException("Nombre del certificado no informado.");

            string lcError = string.Empty;

            X509Certificate2 loCertX509 = null;

            try
            {
                if (tcCertificateName == "SAGESPAIN")
                {
                    loCertX509 = GetCertificateFromResources(tcCertificateName, tcCertificatePassword, ref lcError);

                    if (loCertX509 == null)
                        loCertX509 = GetCertificateFromResources("SAGESPAIN_SHA1", tcCertificatePassword, ref lcError);
                }
                else
                {
                    Byte[] loRawCertif = RawCertificate(tcCertificateName);

                    if (loRawCertif.Length > 0)
                    {
                        loCertX509 = new X509Certificate2();
                        loCertX509.Import(loRawCertif, tcCertificatePassword, X509KeyStorageFlags.Exportable);
                    }
                }
            }
            catch (Exception ex)
            {
                _cMensajeError = string.Format("El certificado '{0}' no se ha importado correctamente. {1}", tcCertificateName, ex.Message);
            }

            if (loCertX509 == null)
            {
                if (string.IsNullOrWhiteSpace(lcError))
                    _cMensajeError = string.Format("El certificado '{0}' indicado no se encuentra o está caducado.", tcCertificateName);
                else
                    _cMensajeError = lcError;
            }

            return loCertX509;
        }

        private X509Certificate2 GetCertificateFromResources(string tcCertificateName, string tcCertificatePassword, ref string tcError)
        {
            X509Certificate2 certX509 = null;
            tcError = "";

            try
            {
                Byte[] raw = RawCertificate(tcCertificateName);

                if (raw.Length > 0)
                {
                    certX509 = new X509Certificate2();
                    certX509.Import(raw, tcCertificatePassword, X509KeyStorageFlags.Exportable);
                }
            }
            catch (Exception ex)
            {
                tcError = string.Format("El certificado '{0}' no se ha importado correctamente. {1}", tcCertificateName, ex);
                certX509 = null;
            }

            return certX509;
        }
        #endregion Métodos privados
    }
}