9 messaggi dal 11 marzo 2013
Buongiorno,
mi sono da poco avvicinato ad ASP.NET Core grazie ad un corso di Moreno Gentili acquistato su Udemy.

Sto cercando, per esigenze lavorative, di rinnovare un vecchio applicativo un po' complesso fatto in classic asp 3.0 ed ho deciso di utilizzare questo nuovo framework visto che probabilmente rappresenta il futuro.

Avrei bisogno di sapere se esiste un modo per inviare e successivamente approvare una richiesta di certificato ad una Certification Authority che vive nella stessa intranet dell'applicativo.
Inoltre una volta approvato dovrei recuperare il certificato ed inviarlo tramite mail all'interessato.

In linea teorica so come fare la richiesta e l'approvazione con ASP.NET ma non trovo nulla che possa essermi utile su ASP.NET Core.
Inoltre non so, per nessuna delle due tecnologie, se sia possibile recuperare il certificato appena creato per inviarlo tramite mail.

Ovviamente non cerco qualcuno che scriva il codice al posto mio ma soltanto un aiuto per comprendere prima se sia possibile fare queste operazioni con ASP.NET Core e in caso affermativo qualche link dove io possa trovare qualche informazione interessante.

Grazie mille

Christian

PS: Moreno complimenti per il corso perché è fatto veramente bene.
11.867 messaggi dal 09 febbraio 2002
Contributi
Ciao, grazie mille :D sono contento che il corso ti stia piacendo! E ancora di più sapere che ti è utile per lavoro


In linea teorica so come fare la richiesta e l'approvazione con ASP.NET ma non trovo nulla che possa essermi utile su ASP.NET Core.

L'approccio dovrebbe essere lo stesso anche su ASP.NET Core. Che soluzione hai trovato per ASP.NET?

Per esempio potresti provare a richiedere ed esportare il certificato usando uno script PowerShell. Forse questo potrebbe fare al caso tuo?
https://gallery.technet.microsoft.com/scriptcenter/Request-certificates-from-b6a07151
Non l'ho provato e quindi non ti so dire né se lo script funziona ne se è quello che cerchi.

Ad ogni modo, se volessi eseguire script PowerShell da un'applicazione ASP.NET Core, potresti usare PowerShell Core.
https://www.youtube.com/watch?v=lVXK9w84cIU

Qui una release note che spiega come usando il Windows Compatibility Pack tu possa usare più di 1900 cmdlets. Forse ci sono anche quelle usate dal suddetto script.
https://docs.microsoft.com/it-it/powershell/scripting/whats-new/what-s-new-in-powershell-core-61?view=powershell-6
E anche un articolo che ne parla.
https://searchwindowsserver.techtarget.com/tip/Windows-Compatibility-module-expands-PowerShell-Core-reach

L'applicazione ASP.NET Core probabilmente dovrà essere eseguita con un utente che ha i necessari privilegi per poter eseguire le cmdlet di ottenimento del certificato. In caso per questo fatti aiutare da un amministratore di sistema.

Fammi sapere cosa scopri, la cosa è interessante.

ciao,
Moreno

Enjoy learning and just keep making
9 messaggi dal 11 marzo 2013
Ciao Moreno


L'approccio dovrebbe essere lo stesso anche su ASP.NET Core. Che soluzione hai trovato per ASP.NET?


Per ASP.NET ho trovato questo: https://blogs.msdn.microsoft.com/alejacma/2008/09/05/how-to-create-a-certificate-request-with-certenroll-and-net-c/, ma non ho avuto modo di verificare se funziona. Se funzionasse realmente secondo te la stessa soluzione sarebbe utilizzabile anche su ASP.NET Core?

Per esempio potresti provare a richiedere ed esportare il certificato usando uno script PowerShell.


Potrebbe essere molto interessante però, dovendo abilitare l'uso di PowerShell, si andrebbero a creare molti più problemi di sicurezza e non so se dai piani alti approverebbero la cosa!!!!

Ti tengo aggiornato nei prossimi giorni e nel frattempo incrocio le dita.

Un saluto
Christian
11.867 messaggi dal 09 febbraio 2002
Contributi
Ciao Christian,


Se funzionasse realmente secondo te la stessa soluzione sarebbe utilizzabile anche su ASP.NET Core?

Puoi provarci anche se non sarà facile. Leggi qui su come consumare oggetti COM da .NET Core.
https://weblog.west-wind.com/posts/2019/Jan/22/COM-Object-Access-and-dynamic-in-NET-Core-2x


dovendo abilitare l'uso di PowerShell, si andrebbero a creare molti più problemi di sicurezza e non so se dai piani alti approverebbero la cosa!!!!

PowerShell (Core) di per sé non introduce problemi di sicurezza. Ciò che è possibile (o non possibile) fare dipende unicamente dai privilegi dell'utente con cui sta girando l'applicazione ASP.NET Core.
E inoltre la tua applicazione non consentirà di eseguire codice arbitrario, ma solo quelle cmdlet che tu avrai disposto di usare.

Se non ti consentono di usarlo è più che altro un problema culturale. Tu cerca di educarli e presenta delle prove a sostegno della tua ipotesi. Oppure chiamate un consulente/sistemista esperto che saprà sfatare i pregiudizi. Del resto, anche il prompt dei comandi permette di fare format C: ma nessuno lo disabilita. E non ce n'è bisogno perché di solito le applicazioni vanno in esecuzione con utenti dai privilegi limitati che non hanno capacità di eseguire tali comandi o di accedere a cartelle che non siano quelle dell'applicazione.

In alternativa, non so le la Microsoft Certification Authority espone qualche altra interfaccia tipo webservice o rest API. Non ho esperienza in merito. Posso guardarci, anche giusto per curiosità, ma non sarà una cosa immediata perché mi servirà un po' di tempo libero per preparare il tutto.

ciao,
Moreno

Enjoy learning and just keep making
9 messaggi dal 11 marzo 2013
Ciao Moreno,
mi hai dato un bel po' di materiale su cui lavorare, da domani si torna a studiare ed ovviamente ti farò sapere come procede il lavoro.

Per il resto:

Se non ti consentono di usarlo è più che altro un problema culturale. Tu cerca di educarli e presenta delle prove a sostegno della tua ipotesi. Oppure chiamate un consulente/sistemista esperto che saprà sfatare i pregiudizi. Del resto, anche il prompt dei comandi permette di fare format C: ma nessuno lo disabilita. E non ce n'è bisogno perché di solito le applicazioni vanno in esecuzione con utenti dai privilegi limitati che non hanno capacità di eseguire tali comandi o di accedere a cartelle che non siano quelle dell'applicazione.

Veramente dove lavoro io il prompt dei comandi è disabilitato dalle policy di dominio

In alternativa, non so le la Microsoft Certification Authority espone qualche altra interfaccia tipo webservice o rest API. Non ho esperienza in merito. Posso guardarci, anche giusto per curiosità, ma non sarà una cosa immediata perché mi servirà un po' di tempo libero per preparare il tutto.

Questo è sicuramente un altro spunto da approfondire, se poi riesci a trovare qualcosa tu fammelo sapere.

Per adesso ti ringrazio per l'aiuto che mi stai dando.

Ciao
Christian
11.867 messaggi dal 09 febbraio 2002
Contributi
Ciao Christian,
mi sono creato una macchina virtuale per provare la Certification Authority. Ho visto che si può installare il web service che potrebbe consentirti di richiedere e ottenere il certificato facendo delle richieste web.

Si chiama "Certificate Enrollment Web Services" e si può installare come ruolo, come vedi in questa immagine.
http://www.petenetlive.com/wp-content/uploads/2016/10/003-configure-CA-Role-.png

In realtà, come vedi lì, c'è più di un webservice. Sono spiegati qui:
https://social.technet.microsoft.com/wiki/contents/articles/7734.certificate-enrollment-web-services-in-active-directory-certificate-services.aspx
e qui
https://techcommunity.microsoft.com/t5/Ask-the-Directory-Services-Team/Certificate-Enrollment-Web-Services/ba-p/397385
e qui
https://www.petenetlive.com/KB/Article/0001250

Abilitare questi webservice però, secondo me, non è una responsabilità dello sviluppatore. Avrete certamente una o più persone che si occupano dell'amministrazione dei sistemi, quindi dovresti manifestare la tua necessità a loro.
Così ti sapranno dire se è il caso di utilizzare i web service o PowerShell. Onestamente non so cosa sia preferibile in questo caso. Installare i web service vuol dire installare anche i ruoli di IIS e ASP.NET e non è detto che vogliano farlo su questo particolare server.

ciao,
Moreno

Enjoy learning and just keep making
9 messaggi dal 11 marzo 2013
Buongiorno Moreno,
sono a conoscenza della possibilità di abilitare questo servizio all'interno della Certification Authority e sebbene venga attualmente utilizzato nel vecchio applicativo l'idea è quello di chiudere il servizio web della CA il prima possibile.

Comunque ho trovato questo codice per ASP.NET Core:

namespace CreateCert
{
    using System;
    using System.Collections.Generic;
    using System.Security.Cryptography.X509Certificates;
    using System.Threading.Tasks;

    class Certificate
    {
        public static async Task<X509Certificate2> Create(string subject, string friendlyName, IEnumerable<string> alternativeNames)
        {
            if (string.IsNullOrEmpty(subject))
            {
                throw new ArgumentNullException(nameof(subject));
            }

            string issuer = subject;

            var subjectDn = new CX500DistinguishedNameClass();

            subjectDn.Encode($"CN={subject}", X500NameFlags.XCN_CERT_NAME_STR_NONE);


            var issuerDn = new CX500DistinguishedNameClass();

            issuerDn.Encode($"CN={issuer}", X500NameFlags.XCN_CERT_NAME_STR_NONE);

            var key = new CX509PrivateKeyClass();

            key.ProviderName = "Microsoft RSA SChannel Cryptographic Provider";

            key.Length = 2048;

            //
            // False: Current User, True: Local Machine
            key.MachineContext = true;

            key.Create();

            var cert = new CX509CertificateRequestCertificateClass();

            cert.InitializeFromPrivateKey(X509CertificateEnrollmentContext.ContextMachine, key, string.Empty);

            cert.Subject = subjectDn;

            cert.Issuer = issuerDn;

            cert.NotBefore = DateTime.UtcNow.AddMinutes(-10);

            cert.NotAfter = cert.NotBefore.AddYears(2);

            var hashAlgorithm = new CObjectIdClass();

            hashAlgorithm.InitializeFromAlgorithmName(ObjectIdGroupId.XCN_CRYPT_FIRST_ALG_OID_GROUP_ID, ObjectIdPublicKeyFlags.XCN_CRYPT_OID_INFO_PUBKEY_ANY, AlgorithmFlags.AlgorithmFlagsNone, "SHA256");

            cert.HashAlgorithm = hashAlgorithm;

            var clientAuthOid = new CObjectIdClass();

            clientAuthOid.InitializeFromValue("1.3.6.1.5.5.7.3.2");

            var serverAuthOid = new CObjectIdClass();

            serverAuthOid.InitializeFromValue("1.3.6.1.5.5.7.3.1");

            var ekuOids = new CObjectIdsClass();

            ekuOids.Add(clientAuthOid);

            ekuOids.Add(serverAuthOid);

            var ekuExt = new CX509ExtensionEnhancedKeyUsageClass();

            ekuExt.InitializeEncode(ekuOids);

            cert.X509Extensions.Add(ekuExt);

            var keyUsage = new CX509ExtensionKeyUsageClass();

            var flags = X509KeyUsageFlags.XCN_CERT_KEY_ENCIPHERMENT_KEY_USAGE | X509KeyUsageFlags.XCN_CERT_DIGITAL_SIGNATURE_KEY_USAGE;

            keyUsage.InitializeEncode(flags);

            cert.X509Extensions.Add(keyUsage);

            if (alternativeNames != null)
            {
                var names = new CAlternativeNamesClass();
                var altnames = new CX509ExtensionAlternativeNamesClass();

                foreach (string n in alternativeNames)
                {
                    var name = new CAlternativeNameClass();
                    // Dns Alternative Name
                    name.InitializeFromString(AlternativeNameType.XCN_CERT_ALT_NAME_DNS_NAME, n);
                    names.Add(name);
                }

                altnames.InitializeEncode(names);
                cert.X509Extensions.Add(altnames);
            }

            cert.Encode();

            string locator = Guid.NewGuid().ToString();

            var enrollment = new CX509EnrollmentClass();

            enrollment.CertificateFriendlyName = locator;

            // TODO get certificates see if any have name of friendlyName
            // if so append (1) or (2) or so forth to friendlyname, even if friendlyname is the empty string
            // create with criendlyname

            enrollment.InitializeFromRequest(cert);

            string certdata = enrollment.CreateRequest(EncodingType.XCN_CRYPT_STRING_BASE64HEADER);

            enrollment.InstallResponse(InstallResponseRestrictionFlags.AllowUntrustedCertificate, certdata, EncodingType.XCN_CRYPT_STRING_BASE64HEADER, string.Empty);

            await Task.Delay(1000);

            X509Certificate2 retCert = null;

            using (var store = new X509Store(StoreName.My, StoreLocation.LocalMachine))
            {
                store.Open(OpenFlags.ReadWrite);

                foreach (var certificate in store.Certificates)
                {
                    if (certificate.FriendlyName == locator)
                    {
                        retCert = certificate;

                        //
                        // Must update friendlyname while store is still open
                        if (retCert != null && friendlyName != null)
                        {
                            retCert.FriendlyName = friendlyName;
                        }

                        break;
                    }
                }
            }

            return retCert;
        }
    }

    public enum X500NameFlags
    {
        XCN_CERT_NAME_STR_AMBIGUOUS_SEPARATOR_FLAGS = 0x4c000000,
        XCN_CERT_NAME_STR_COMMA_FLAG = 0x4000000,
        XCN_CERT_NAME_STR_CRLF_FLAG = 0x8000000,
        XCN_CERT_NAME_STR_DISABLE_IE4_UTF8_FLAG = 0x10000,
        XCN_CERT_NAME_STR_DISABLE_UTF8_DIR_STR_FLAG = 0x100000,
        XCN_CERT_NAME_STR_DS_ESCAPED = 0x800000,
        XCN_CERT_NAME_STR_ENABLE_PUNYCODE_FLAG = 0x200000,
        XCN_CERT_NAME_STR_ENABLE_T61_UNICODE_FLAG = 0x20000,
        XCN_CERT_NAME_STR_ENABLE_UTF8_UNICODE_FLAG = 0x40000,
        XCN_CERT_NAME_STR_FORCE_UTF8_DIR_STR_FLAG = 0x80000,
        XCN_CERT_NAME_STR_FORWARD_FLAG = 0x1000000,
        XCN_CERT_NAME_STR_NO_PLUS_FLAG = 0x20000000,
        XCN_CERT_NAME_STR_NO_QUOTING_FLAG = 0x10000000,
        XCN_CERT_NAME_STR_NONE = 0,
        XCN_CERT_NAME_STR_REVERSE_FLAG = 0x2000000,
        XCN_CERT_NAME_STR_SEMICOLON_FLAG = 0x40000000,
        XCN_CERT_OID_NAME_STR = 2,
        XCN_CERT_SIMPLE_NAME_STR = 1,
        XCN_CERT_X500_NAME_STR = 3,
        XCN_CERT_XML_NAME_STR = 4
    }

    public enum EncodingType
    {
        XCN_CRYPT_STRING_ANY = 7,
        XCN_CRYPT_STRING_BASE64 = 1,
        XCN_CRYPT_STRING_BASE64_ANY = 6,
        XCN_CRYPT_STRING_BASE64HEADER = 0,
        XCN_CRYPT_STRING_BASE64REQUESTHEADER = 3,
        XCN_CRYPT_STRING_BASE64URI = 13,
        XCN_CRYPT_STRING_BASE64X509CRLHEADER = 9,
        XCN_CRYPT_STRING_BINARY = 2,
        XCN_CRYPT_STRING_CHAIN = 0x100,
        XCN_CRYPT_STRING_ENCODEMASK = 0xff,
        XCN_CRYPT_STRING_HASHDATA = 0x10000000,
        XCN_CRYPT_STRING_HEX = 4,
        XCN_CRYPT_STRING_HEX_ANY = 8,
        XCN_CRYPT_STRING_HEXADDR = 10,
        XCN_CRYPT_STRING_HEXASCII = 5,
        XCN_CRYPT_STRING_HEXASCIIADDR = 11,
        XCN_CRYPT_STRING_HEXRAW = 12,
        XCN_CRYPT_STRING_NOCR = -2147483648,
        XCN_CRYPT_STRING_NOCRLF = 0x40000000,
        XCN_CRYPT_STRING_PERCENTESCAPE = 0x8000000,
        XCN_CRYPT_STRING_STRICT = 0x20000000,
        XCN_CRYPT_STRING_TEXT = 0x200
    }

    public enum ObjectIdGroupId
    {
        XCN_CRYPT_ANY_GROUP_ID = 0,
        XCN_CRYPT_ENCRYPT_ALG_OID_GROUP_ID = 2,
        XCN_CRYPT_ENHKEY_USAGE_OID_GROUP_ID = 7,
        XCN_CRYPT_EXT_OR_ATTR_OID_GROUP_ID = 6,
        XCN_CRYPT_FIRST_ALG_OID_GROUP_ID = 1,
        XCN_CRYPT_GROUP_ID_MASK = 0xffff,
        XCN_CRYPT_HASH_ALG_OID_GROUP_ID = 1,
        XCN_CRYPT_KEY_LENGTH_MASK = 0xfff0000,
        XCN_CRYPT_LAST_ALG_OID_GROUP_ID = 4,
        XCN_CRYPT_LAST_OID_GROUP_ID = 10,
        XCN_CRYPT_OID_DISABLE_SEARCH_DS_FLAG = -2147483648,
        XCN_CRYPT_OID_INFO_OID_GROUP_BIT_LEN_MASK = 0xfff0000,
        XCN_CRYPT_OID_INFO_OID_GROUP_BIT_LEN_SHIFT = 0x10,
        XCN_CRYPT_OID_PREFER_CNG_ALGID_FLAG = 0x40000000,
        XCN_CRYPT_POLICY_OID_GROUP_ID = 8,
        XCN_CRYPT_PUBKEY_ALG_OID_GROUP_ID = 3,
        XCN_CRYPT_RDN_ATTR_OID_GROUP_ID = 5,
        XCN_CRYPT_SIGN_ALG_OID_GROUP_ID = 4,
        XCN_CRYPT_TEMPLATE_OID_GROUP_ID = 9
    }

    public enum ObjectIdPublicKeyFlags
    {
        XCN_CRYPT_OID_INFO_PUBKEY_ANY = 0,
        XCN_CRYPT_OID_INFO_PUBKEY_ENCRYPT_KEY_FLAG = 0x40000000,
        XCN_CRYPT_OID_INFO_PUBKEY_SIGN_KEY_FLAG = -2147483648
    }

    public enum X509CertificateEnrollmentContext
    {
        ContextNone = 0,
        ContextUser = 1,
        ContextMachine = 2,
        ContextAdministratorForceMachine = 3
    }

    public enum AlgorithmFlags
    {
        AlgorithmFlagsNone,
        AlgorithmFlagsWrap
    }

    public enum X509KeyUsageFlags
    {
        XCN_CERT_CRL_SIGN_KEY_USAGE = 2,
        XCN_CERT_DATA_ENCIPHERMENT_KEY_USAGE = 0x10,
        XCN_CERT_DECIPHER_ONLY_KEY_USAGE = 0x8000,
        XCN_CERT_DIGITAL_SIGNATURE_KEY_USAGE = 0x80,
        XCN_CERT_ENCIPHER_ONLY_KEY_USAGE = 1,
        XCN_CERT_KEY_AGREEMENT_KEY_USAGE = 8,
        XCN_CERT_KEY_CERT_SIGN_KEY_USAGE = 4,
        XCN_CERT_KEY_ENCIPHERMENT_KEY_USAGE = 0x20,
        XCN_CERT_NO_KEY_USAGE = 0,
        XCN_CERT_NON_REPUDIATION_KEY_USAGE = 0x40,
        XCN_CERT_OFFLINE_CRL_SIGN_KEY_USAGE = 2
    }

    public enum AlternativeNameType
    {
        XCN_CERT_ALT_NAME_DIRECTORY_NAME = 5,
        XCN_CERT_ALT_NAME_DNS_NAME = 3,
        XCN_CERT_ALT_NAME_GUID = 10,
        XCN_CERT_ALT_NAME_IP_ADDRESS = 8,
        XCN_CERT_ALT_NAME_OTHER_NAME = 1,
        XCN_CERT_ALT_NAME_REGISTERED_ID = 9,
        XCN_CERT_ALT_NAME_RFC822_NAME = 2,
        XCN_CERT_ALT_NAME_UNKNOWN = 0,
        XCN_CERT_ALT_NAME_URL = 7,
        XCN_CERT_ALT_NAME_USER_PRINCIPLE_NAME = 11
    }

    public enum InstallResponseRestrictionFlags
    {
        AllowNone = 0,
        AllowNoOutstandingRequest = 1,
        AllowUntrustedCertificate = 2,
        AllowUntrustedRoot = 4
    }

    public abstract class CertEnrollWrapper
    {
        protected object _instance;
        private Type _type = null;

        public CertEnrollWrapper()
        {
            if (Type != null)
            {
                _instance = Activator.CreateInstance(Type);
            }
        }

        protected abstract string TypeName { get; }

        public CertEnrollWrapper(object instance)
        {
            _instance = instance;
        }

        public object Instance {
            get => _instance;
        }

        protected Type Type {
            get {

                if (_type == null)
                {
                    _type = Type.GetTypeFromProgID(TypeName);
                }

                return _type;
            }
        }
    }

    public class CX509EnrollmentClass : CertEnrollWrapper
    {
        public CX509EnrollmentClass() : base() { }

        protected override string TypeName {
            get => "X509Enrollment.CX509Enrollment";
        }

        public string CreateRequest(EncodingType Encoding)
        {
            return (string)Type.InvokeMember(nameof(CreateRequest), System.Reflection.BindingFlags.InvokeMethod, null, _instance, new object[] { Encoding });
        }

        public void InitializeFromRequest(CX509CertificateRequestCertificateClass pRequest)
        {
            Type.InvokeMember(nameof(InitializeFromRequest), System.Reflection.BindingFlags.InvokeMethod, null, _instance, new object[] { pRequest.Instance });
        }

        public void InstallResponse(InstallResponseRestrictionFlags Restrictions, string strResponse, EncodingType Encoding, string strPassword)
        {
            Type.InvokeMember(nameof(InstallResponse), System.Reflection.BindingFlags.InvokeMethod, null, _instance, new object[] { Restrictions, strResponse, Encoding, strPassword });
        }

        public string CertificateFriendlyName {
            get => (string)Type.InvokeMember(nameof(CertificateFriendlyName), System.Reflection.BindingFlags.GetProperty, null, _instance, null);

            set => Type.InvokeMember(nameof(CertificateFriendlyName), System.Reflection.BindingFlags.SetProperty, null, _instance, new object[] { value });
        }
    }

    public class CAlternativeNameClass : CertEnrollWrapper
    {
        public CAlternativeNameClass() : base() { }

        protected override string TypeName {
            get => "X509Enrollment.CAlternativeName";
        }

        public void InitializeFromString(AlternativeNameType type, string strValue)
        {
            Type.InvokeMember(nameof(InitializeFromString), System.Reflection.BindingFlags.InvokeMethod, null, _instance, new object[] { type, strValue });
        }
    }

    public class CAlternativeNamesClass : CertEnrollWrapper
    {
        public CAlternativeNamesClass() : base() { }

        protected override string TypeName {
            get => "X509Enrollment.CAlternativeNames";
        }

        public void Add(CAlternativeNameClass pVal)
        {
            Type.InvokeMember(nameof(Add), System.Reflection.BindingFlags.InvokeMethod, null, _instance, new object[] { pVal.Instance });
        }
    }

    public class CX509ExtensionAlternativeNamesClass : CertEnrollWrapper
    {
        public CX509ExtensionAlternativeNamesClass() : base() { }

        protected override string TypeName {
            get => "X509Enrollment.CX509ExtensionAlternativeNames";
        }

        public void InitializeEncode(CAlternativeNamesClass pValue)
        {
            Type.InvokeMember(nameof(InitializeEncode), System.Reflection.BindingFlags.InvokeMethod, null, _instance, new object[] { pValue.Instance });
        }
    }

    public class CObjectIdClass : CertEnrollWrapper
    {
        public CObjectIdClass() : base() { }

        public CObjectIdClass(object instance) : base(instance) { }

        protected override string TypeName {
            get => "X509Enrollment.CObjectId";
        }

        public void InitializeFromAlgorithmName(ObjectIdGroupId GroupId, ObjectIdPublicKeyFlags KeyFlags, AlgorithmFlags AlgFlags, string strAlgorithmName)
        {
            Type.InvokeMember(nameof(InitializeFromAlgorithmName), System.Reflection.BindingFlags.InvokeMethod, null, _instance, new object[] { GroupId, KeyFlags, AlgFlags, strAlgorithmName });
        }

        public void InitializeFromValue(string strValue)
        {
            Type.InvokeMember(nameof(InitializeFromValue), System.Reflection.BindingFlags.InvokeMethod, null, _instance, new object[] { strValue });
        }
    }

    public class CObjectIdsClass : CertEnrollWrapper
    {
        public CObjectIdsClass() : base() { }

        protected override string TypeName {
            get => "X509Enrollment.CObjectIds";
        }

        public void Add(CObjectIdClass value)
        {
            Type.InvokeMember(nameof(Add), System.Reflection.BindingFlags.InvokeMethod, null, _instance, new object[] { value.Instance });
        }
    }

    public class CX509ExtensionClass : CertEnrollWrapper
    {
        public CX509ExtensionClass() : base() { }

        public CX509ExtensionClass(object instance) : base(instance) { }

        protected override string TypeName {
            get => "X509Enrollment.CX509Extension";
        }

        public void Initialize(CObjectIdsClass pObjectId, string strEncodedData)
        {
            Type.InvokeMember(nameof(Initialize), System.Reflection.BindingFlags.InvokeMethod, null, _instance, new object[] { pObjectId.Instance, strEncodedData });
        }
    }

    public class CX509ExtensionEnhancedKeyUsageClass : CertEnrollWrapper
    {
        public CX509ExtensionEnhancedKeyUsageClass() : base() { }

        protected override string TypeName {
            get => "X509Enrollment.CX509ExtensionEnhancedKeyUsage";
        }

        public void InitializeEncode(CObjectIdsClass value)
        {
            Type.InvokeMember(nameof(InitializeEncode), System.Reflection.BindingFlags.InvokeMethod, null, _instance, new object[] { value.Instance });
        }
    }

    public class CX509ExtensionKeyUsageClass : CertEnrollWrapper
    {
        public CX509ExtensionKeyUsageClass() : base() { }

        protected override string TypeName {
            get => "X509Enrollment.CX509ExtensionKeyUsage";
        }

        public void InitializeEncode(X509KeyUsageFlags UsageFlags)
        {
            Type.InvokeMember(nameof(InitializeEncode), System.Reflection.BindingFlags.InvokeMethod, null, _instance, new object[] { UsageFlags });
        }
    }

    public class CX509ExtensionsClass : CertEnrollWrapper
    {
        public CX509ExtensionsClass() : base() { }

        public CX509ExtensionsClass(object instance) : base(instance) { }

        protected override string TypeName {
            get => "X509Enrollment.CX509Extensions";
        }

        public void Add(CX509ExtensionClass value)
        {
            Type.InvokeMember(nameof(Add), System.Reflection.BindingFlags.InvokeMethod, null, _instance, new object[] { value.Instance });
        }

        public void Add(CX509ExtensionEnhancedKeyUsageClass value)
        {
            Type.InvokeMember(nameof(Add), System.Reflection.BindingFlags.InvokeMethod, null, _instance, new object[] { value.Instance });
        }

        public void Add(CX509ExtensionKeyUsageClass value)
        {
            Type.InvokeMember(nameof(Add), System.Reflection.BindingFlags.InvokeMethod, null, _instance, new object[] { value.Instance });
        }

        public void Add(CX509ExtensionAlternativeNamesClass value)
        {
            Type.InvokeMember(nameof(Add), System.Reflection.BindingFlags.InvokeMethod, null, _instance, new object[] { value.Instance });
        }
    }

    public class CX500DistinguishedNameClass : CertEnrollWrapper
    {
        public CX500DistinguishedNameClass() : base() { }

        public CX500DistinguishedNameClass(object instance) : base(instance) { }

        protected override string TypeName {
            get => "X509Enrollment.CX500DistinguishedName";
        }

        public string Name {
            get {
                return (string)Type.InvokeMember(nameof(Name), System.Reflection.BindingFlags.GetProperty, null, _instance, null);
            }
        }

        public void Encode(string name, X500NameFlags flags)
        {
            Type.InvokeMember(nameof(Encode), System.Reflection.BindingFlags.InvokeMethod, null, _instance, new object[] { name, flags });
        }
    }

    public class CX509PrivateKeyClass : CertEnrollWrapper
    {
        public CX509PrivateKeyClass() : base() { }

        protected override string TypeName {
            get => "X509Enrollment.CX509PrivateKey";
        }

        public int Length {
            get => (int)Type.InvokeMember(nameof(Length), System.Reflection.BindingFlags.GetProperty, null, _instance, null);

            set => Type.InvokeMember(nameof(Length), System.Reflection.BindingFlags.SetProperty, null, _instance, new object[] { value });
        }

        public bool MachineContext {
            get => (bool)Type.InvokeMember(nameof(MachineContext), System.Reflection.BindingFlags.GetProperty, null, _instance, null);

            set => Type.InvokeMember(nameof(MachineContext), System.Reflection.BindingFlags.SetProperty, null, _instance, new object[] { value });
        }

        public string ProviderName {
            get => (string)Type.InvokeMember(nameof(ProviderName), System.Reflection.BindingFlags.GetProperty, null, _instance, null);

            set => Type.InvokeMember(nameof(ProviderName), System.Reflection.BindingFlags.SetProperty, null, _instance, new object[] { value });
        }

        public void Create()
        {
            Type.InvokeMember(nameof(Create), System.Reflection.BindingFlags.InvokeMethod, null, _instance, null);
        }
    }

    public class CX509CertificateRequestCertificateClass : CertEnrollWrapper
    {
        public CX509CertificateRequestCertificateClass() : base() { }

        protected override string TypeName {
            get => "X509Enrollment.CX509CertificateRequestCertificate";
        }

        public CObjectIdClass HashAlgorithm {
            get => new CObjectIdClass(Type.InvokeMember(nameof(HashAlgorithm), System.Reflection.BindingFlags.GetProperty, null, _instance, null));

            set => Type.InvokeMember(nameof(HashAlgorithm), System.Reflection.BindingFlags.SetProperty, null, _instance, new object[] { value.Instance });
        }

        public CX500DistinguishedNameClass Issuer {
            get => new CX500DistinguishedNameClass(Type.InvokeMember(nameof(Issuer), System.Reflection.BindingFlags.GetProperty, null, _instance, null));

            set => Type.InvokeMember(nameof(Issuer), System.Reflection.BindingFlags.SetProperty, null, _instance, new object[] { value.Instance });
        }

        public DateTime NotAfter {
            get => (DateTime)Type.InvokeMember(nameof(NotAfter), System.Reflection.BindingFlags.GetProperty, null, _instance, null);

            set => Type.InvokeMember(nameof(NotAfter), System.Reflection.BindingFlags.SetProperty, null, _instance, new object[] { value });
        }

        public DateTime NotBefore {
            get => (DateTime)Type.InvokeMember(nameof(NotBefore), System.Reflection.BindingFlags.GetProperty, null, _instance, null);

            set => Type.InvokeMember(nameof(NotBefore), System.Reflection.BindingFlags.SetProperty, null, _instance, new object[] { value });
        }

        public CX500DistinguishedNameClass Subject {
            get => new CX500DistinguishedNameClass(Type.InvokeMember(nameof(Subject), System.Reflection.BindingFlags.GetProperty, null, _instance, null));

            set => Type.InvokeMember(nameof(Subject), System.Reflection.BindingFlags.SetProperty, null, _instance, new object[] { value.Instance });
        }

        public CX509ExtensionsClass X509Extensions {
            get => new CX509ExtensionsClass(Type.InvokeMember(nameof(X509Extensions), System.Reflection.BindingFlags.GetProperty, null, _instance, null));

            set => Type.InvokeMember(nameof(X509Extensions), System.Reflection.BindingFlags.SetProperty, null, _instance, new object[] { value.Instance });
        }

        public void Encode()
        {
            Type.InvokeMember(nameof(Encode), System.Reflection.BindingFlags.InvokeMethod, null, _instance, null);
        }

        public void InitializeFromPrivateKey(X509CertificateEnrollmentContext Context, CX509PrivateKeyClass pPrivateKey, string strTemplateName)
        {
            Type.InvokeMember(nameof(InitializeFromPrivateKey), System.Reflection.BindingFlags.InvokeMethod, null, _instance, new object[] { Context, pPrivateKey.Instance, strTemplateName });
        }
    }
}

A prima vista sembra proprio quello di cui ho bisogno: rilascia un certificato macchina e non utente però credo che possa essere facilmente modificato.
Purtroppo ancora non sono riuscito a farlo funzionare, ma ci sto lavorando.
Come al solito ti terrò aggiornato.
Ciao
Christian
Modificato da etrusco.net il 23 settembre 2019 14:41 -
11.867 messaggi dal 09 febbraio 2002
Contributi
Ciao Christian, grazie per aver condiviso queste informazioni.
A una prima occhiata sembra che questo codice serva a produrre un certificato autofirmato (l'emittente è anche il soggetto stesso).

string issuer = subject;


Puoi evidenziare il punto in cui la richiesta di emissione viene inviata alla tua Certification Authority installata su Windows Server?

ciao,
Moreno
Modificato da BrightSoul il 23 settembre 2019 22:01 -

Enjoy learning and just keep making

Torna al forum | Feed RSS

ASPItalia.com non è responsabile per il contenuto dei messaggi presenti su questo servizio, non avendo nessun controllo sui messaggi postati nei propri forum, che rappresentano l'espressione del pensiero degli autori.