VMware ESXi

kalistyan
Messages : 11574
Inscription : ven. 12 janv. 2018 17:44
Localisation : LYON
Contact :

Re: VMware ESXi

Message par kalistyan »

:jap:

dsebire
Messages : 10509
Inscription : ven. 12 janv. 2018 17:44
Localisation : Loiret - au milieu des champs

Re: VMware ESXi

Message par dsebire »

dsebire a écrit :
lun. 3 févr. 2020 14:16
génération automatique d'un certificat Let's encrypt sur un ESXi (6.5/6.7):

prérequis:
-- un FQDN qui pointe vers le serveur
-- une redirection du WAN vers le serveur
-- acme-tiny un peu modifié (script plus bas) https://github.com/dmc31a42/acme-tiny pour le challenge/response vers Let's encrypt
-- un accès SSH a la machine

préparation/paramétrage:
-- créer l'arborescence pour la vérification ACME:
mkdir /usr/lib/vmware/hostd/docroot/.well-known/
mkdir /usr/lib/vmware/hostd/docroot/.well-known/acme-challenge/
-- ouvrir l'accès WEB à partir du serveur (nécessaire pour les requêtes vers Let's encrypt)
esxcli network firewall ruleset set -e true -r httpClient
-- récupérer/modifier le script python acme-tiny.py. la modification est nécessaire, ESXi etant un brin capricieux
/opt/acme-tiny/acme_tiny.py

Code : Tout sélectionner

#!/usr/bin/env python
# Copyright Daniel Roesler, under MIT license, see LICENSE at github.com/diafygi/acme-tiny
import argparse, subprocess, json, os, sys, base64, binascii, time, hashlib, re, copy, textwrap, logging, ssl
try:
    from urllib.request import urlopen, Request # Python 3
except ImportError:
    from urllib2 import urlopen, Request # Python 2

DEFAULT_CA = "https://acme-v02.api.letsencrypt.org" # DEPRECATED! USE DEFAULT_DIRECTORY_URL INSTEAD
DEFAULT_DIRECTORY_URL = "https://acme-v02.api.letsencrypt.org/directory"

LOGGER = logging.getLogger(__name__)
LOGGER.addHandler(logging.StreamHandler())
LOGGER.setLevel(logging.INFO)

def get_crt(account_key, csr, acme_dir, log=LOGGER, CA=DEFAULT_CA, disable_check=False, directory_url=DEFAULT_DIRECTORY_URL, contact=None):
    directory, acct_headers, alg, jwk = None, None, None, None # global variables

    # helper functions - base64 encode for jose spec
    def _b64(b):
        return base64.urlsafe_b64encode(b).decode('utf8').replace("=", "")

    # helper function - run external commands
    def _cmd(cmd_list, stdin=None, cmd_input=None, err_msg="Command Line Error"):
        proc = subprocess.Popen(cmd_list, stdin=stdin, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        out, err = proc.communicate(cmd_input)
        if proc.returncode != 0:
            raise IOError("{0}\n{1}".format(err_msg, err))
        return out

    # helper function - make request and automatically parse json response
    def _do_request(url, data=None, err_msg="Error", depth=0):
        ctx = ssl._create_unverified_context()
        try:
            resp = urlopen(Request(url, data=data, headers={"Content-Type": "application/jose+json", "User-Agent": "acme-tiny"}), context=ctx)
            resp_data, code, headers = resp.read().decode("utf8"), resp.getcode(), resp.headers
        except IOError as e:
            resp_data = e.read().decode("utf8") if hasattr(e, "read") else str(e)
            code, headers = getattr(e, "code", None), {}
        try:
            resp_data = json.loads(resp_data) # try to parse json results
        except ValueError:
            pass # ignore json parsing errors
        if depth < 100 and code == 400 and resp_data['type'] == "urn:ietf:params:acme:error:badNonce":
            raise IndexError(resp_data) # allow 100 retrys for bad nonces
        if code not in [200, 201, 204]:
            raise ValueError("{0}:\nUrl: {1}\nData: {2}\nResponse Code: {3}\nResponse: {4}".format(err_msg, url, data, code, resp_data))
        return resp_data, code, headers

    # helper function - make signed requests
    def _send_signed_request(url, payload, err_msg, depth=0):
        payload64 = "" if payload is None else _b64(json.dumps(payload).encode('utf8'))
        new_nonce = _do_request(directory['newNonce'])[2]['Replay-Nonce']
        protected = {"url": url, "alg": alg, "nonce": new_nonce}
        protected.update({"jwk": jwk} if acct_headers is None else {"kid": acct_headers['Location']})
        protected64 = _b64(json.dumps(protected).encode('utf8'))
        protected_input = "{0}.{1}".format(protected64, payload64).encode('utf8')
        out = _cmd(["openssl", "dgst", "-sha256", "-sign", account_key], stdin=subprocess.PIPE, cmd_input=protected_input, err_msg="OpenSSL Error")
        data = json.dumps({"protected": protected64, "payload": payload64, "signature": _b64(out)})
        try:
            return _do_request(url, data=data.encode('utf8'), err_msg=err_msg, depth=depth)
        except IndexError: # retry bad nonces (they raise IndexError)
            return _send_signed_request(url, payload, err_msg, depth=(depth + 1))

    # helper function - poll until complete
    def _poll_until_not(url, pending_statuses, err_msg):
        result, t0 = None, time.time()
        while result is None or result['status'] in pending_statuses:
            assert (time.time() - t0 < 3600), "Polling timeout" # 1 hour timeout
            time.sleep(0 if result is None else 2)
            result, _, _ = _send_signed_request(url, None, err_msg)
        return result

    # parse account key to get public key
    log.info("Parsing account key...")
    out = _cmd(["openssl", "rsa", "-in", account_key, "-noout", "-text"], err_msg="OpenSSL Error")
    pub_pattern = r"modulus:[\s]+?00:([a-f0-9\:\s]+?)\npublicExponent: ([0-9]+)"
    pub_hex, pub_exp = re.search(pub_pattern, out.decode('utf8'), re.MULTILINE|re.DOTALL).groups()
    pub_exp = "{0:x}".format(int(pub_exp))
    pub_exp = "0{0}".format(pub_exp) if len(pub_exp) % 2 else pub_exp
    alg = "RS256"
    jwk = {
        "e": _b64(binascii.unhexlify(pub_exp.encode("utf-8"))),
        "kty": "RSA",
        "n": _b64(binascii.unhexlify(re.sub(r"(\s|:)", "", pub_hex).encode("utf-8"))),
    }
    accountkey_json = json.dumps(jwk, sort_keys=True, separators=(',', ':'))
    thumbprint = _b64(hashlib.sha256(accountkey_json.encode('utf8')).digest())

    # find domains
    log.info("Parsing CSR...")
    out = _cmd(["openssl", "req", "-in", csr, "-noout", "-text"], err_msg="Error loading {0}".format(csr))
    domains = set([])
    common_name = re.search(r"Subject:.*? CN\s?=\s?([^\s,;/]+)", out.decode('utf8'))
    if common_name is not None:
        domains.add(common_name.group(1))
    subject_alt_names = re.search(r"X509v3 Subject Alternative Name: (?:critical)?\n +([^\n]+)\n", out.decode('utf8'), re.MULTILINE|re.DOTALL)
    if subject_alt_names is not None:
        for san in subject_alt_names.group(1).split(", "):
            if san.startswith("DNS:"):
                domains.add(san[4:])
    log.info("Found domains: {0}".format(", ".join(domains)))

    # get the ACME directory of urls
    log.info("Getting directory...")
    directory_url = CA + "/directory" if CA != DEFAULT_CA else directory_url # backwards compatibility with deprecated CA kwarg
    directory, _, _ = _do_request(directory_url, err_msg="Error getting directory")
    log.info("Directory found!")

    # create account, update contact details (if any), and set the global key identifier
    log.info("Registering account...")
    reg_payload = {"termsOfServiceAgreed": True}
    account, code, acct_headers = _send_signed_request(directory['newAccount'], reg_payload, "Error registering")
    log.info("Registered!" if code == 201 else "Already registered!")
    if contact is not None:
        account, _, _ = _send_signed_request(acct_headers['Location'], {"contact": contact}, "Error updating contact details")
        log.info("Updated contact details:\n{0}".format("\n".join(account['contact'])))

    # create a new order
    log.info("Creating new order...")
    order_payload = {"identifiers": [{"type": "dns", "value": d} for d in domains]}
    order, _, order_headers = _send_signed_request(directory['newOrder'], order_payload, "Error creating new order")
    log.info("Order created!")

    # get the authorizations that need to be completed
    for auth_url in order['authorizations']:
        authorization, _, _ = _send_signed_request(auth_url, None, "Error getting challenges")
        domain = authorization['identifier']['value']
        log.info("Verifying {0}...".format(domain))

        # find the http-01 challenge and write the challenge file
        challenge = [c for c in authorization['challenges'] if c['type'] == "http-01"][0]
        token = re.sub(r"[^A-Za-z0-9_\-]", "_", challenge['token'])
        keyauthorization = "{0}.{1}".format(token, thumbprint)
        wellknown_path = os.path.join(acme_dir, token)
        with open(wellknown_path, "w") as wellknown_file:
            wellknown_file.write(keyauthorization)

        # check that the file is in place
        try:
            wellknown_url = "http://{0}/.well-known/acme-challenge/{1}".format(domain, token)
            assert (disable_check or _do_request(wellknown_url)[0] == keyauthorization)
        except (AssertionError, ValueError) as e:
            raise ValueError("Wrote file to {0}, but couldn't download {1}: {2}".format(wellknown_path, wellknown_url, e))

        # say the challenge is done
        _send_signed_request(challenge['url'], {}, "Error submitting challenges: {0}".format(domain))
        authorization = _poll_until_not(auth_url, ["pending"], "Error checking challenge status for {0}".format(domain))
        if authorization['status'] != "valid":
            raise ValueError("Challenge did not pass for {0}: {1}".format(domain, authorization))
        os.remove(wellknown_path)
        log.info("{0} verified!".format(domain))

    # finalize the order with the csr
    log.info("Signing certificate...")
    csr_der = _cmd(["openssl", "req", "-in", csr, "-outform", "DER"], err_msg="DER Export Error")
    _send_signed_request(order['finalize'], {"csr": _b64(csr_der)}, "Error finalizing order")

    # poll the order to monitor when it's done
    order = _poll_until_not(order_headers['Location'], ["pending", "processing"], "Error checking order status")
    if order['status'] != "valid":
        raise ValueError("Order failed: {0}".format(order))

    # download the certificate
    certificate_pem, _, _ = _send_signed_request(order['certificate'], None, "Certificate download failed")
    log.info("Certificate signed!")
    return certificate_pem

def main(argv=None):
    parser = argparse.ArgumentParser(
        formatter_class=argparse.RawDescriptionHelpFormatter,
        description=textwrap.dedent("""\
            This script automates the process of getting a signed TLS certificate from Let's Encrypt using
            the ACME protocol. It will need to be run on your server and have access to your private
            account key, so PLEASE READ THROUGH IT! It's only ~200 lines, so it won't take long.

            Example Usage:
            python acme_tiny.py --account-key ./account.key --csr ./domain.csr --acme-dir /usr/share/nginx/html/.well-known/acme-challenge/ > signed_chain.crt

            Example Crontab Renewal (once per month):
            0 0 1 * * python /path/to/acme_tiny.py --account-key /path/to/account.key --csr /path/to/domain.csr --acme-dir /usr/share/nginx/html/.well-known/acme-challenge/ > /path/to/signed_chain.crt 2>> /var/log/acme_tiny.log
            """)
    )
    parser.add_argument("--account-key", required=True, help="path to your Let's Encrypt account private key")
    parser.add_argument("--csr", required=True, help="path to your certificate signing request")
    parser.add_argument("--acme-dir", required=True, help="path to the .well-known/acme-challenge/ directory")
    parser.add_argument("--quiet", action="store_const", const=logging.ERROR, help="suppress output except for errors")
    parser.add_argument("--disable-check", default=False, action="store_true", help="disable checking if the challenge file is hosted correctly before telling the CA")
    parser.add_argument("--directory-url", default=DEFAULT_DIRECTORY_URL, help="certificate authority directory url, default is Let's Encrypt")
    parser.add_argument("--ca", default=DEFAULT_CA, help="DEPRECATED! USE --directory-url INSTEAD!")
    parser.add_argument("--contact", metavar="CONTACT", default=None, nargs="*", help="Contact details (e.g. mailto:aaa@bbb.com) for your account-key")

    args = parser.parse_args(argv)
    LOGGER.setLevel(args.quiet or LOGGER.level)
    signed_crt = get_crt(args.account_key, args.csr, args.acme_dir, log=LOGGER, CA=args.ca, disable_check=args.disable_check, directory_url=args.directory_url, contact=args.contact)
    sys.stdout.write(signed_crt)

if __name__ == "__main__": # pragma: no cover
    main(sys.argv[1:])
la modification consiste a désactiver la vérification du certificat du site let's encrypt qui n'est pas reconnu (uniquement par python, un wget passe, ce n'est donc pas un soucis de CA) !
évidement c'est loin d'être optimal, vu qu'on autorise un MIM au moment de réclamer un certificat mais c'est toujours mieux que rien.
à faire donc uniquement quand on est a peu près sur de l'environnement.
vers la ligne 40 (le code mis au dessus contiens déjà la modif !)

Code : Tout sélectionner

ctx = ssl._create_unverified_context()
et 2 lignes en dessous

Code : Tout sélectionner

resp = urlopen(Request(url, data=data, headers={"Content-Type": "application/jose+json", "User-Agent": "acme-tiny"}), context=ctx)
-- se placer dans le bon répertoire
cd /etc/vmware/ssl/
-- générer la clef d'authentification Let's encrypt
openssl genrsa 4096 > account.key
-- créer la clef du certificat
openssl genrsa 4096 > letsencrypt.key
-- créer le fichier de conf pour openssl pour la génération du csr (il est impossible de modifier le fichier de conf par défaut sous esxi)
/etc/vmware/ssl/openssl_LE.cnf
(mettre à jour le nom/société/fqdn)

Code : Tout sélectionner

#
# OpenSSL example configuration file.
#

# This definition stops the following lines choking if HOME isn't
# defined.
HOME                    = .
RANDFILE                = $ENV::HOME/.rnd

####################################################################
[ req ]
default_bits            = 4096
default_md              = sha256
default_keyfile         = letsencrypt.key
distinguished_name      = req_distinguished_name
extensions             = v3_ca
req_extensions = v3_ca
[ v3_ca ]
basicConstraints       = critical, CA:TRUE, pathlen:0
subjectKeyIdentifier   = hash
##authorityKeyIdentifier = keyid:always, issuer:always
keyUsage               = keyCertSign, cRLSign
nsCertType             = sslCA, emailCA, objCA
[req_distinguished_name ]
countryName                     = FR
countryName_default             = FR
countryName_min                 = 2
countryName_max                 = 2
# write company name
organizationName              = VOTRE NOM
organizationName_default      = VOTRE SOCIETE
# write department
#organizationalUnitName          = department
#organizationalUnitName_default  = department
# write domain name which you service
commonName                      = machine.votredomainde.tld
commonName_default             = lesstif’s Self Signed CA
commonName_max                  = 64
-- générer le csr en lui même (avec votre FQDN!)
openssl req -new -sha256 -key letsencrypt.key -config "/etc/vmware/ssl/openssl_LE.cnf" -subj "/CN=machine.votredomainde.tld" > letsencrypt.csr
à partir de la, la configuration est en place. je vous conseille de faire du coup un backup des différents fichiers (clef, csr etc...)

génération du certificat/automatisation:
-- créer le script qui va recupérer le certificat et le copier au bon endroit + redemarrer le serveur web sur l'esx
/vmfs/volumes/path_to/letsencrypt_renewal.sh

Code : Tout sélectionner

#!/usr/bin/sh
/opt/acme-tiny/acme_tiny.py --account-key /etc/vmware/ssl/account.key --csr /etc/vmware/ssl/letsencrypt.csr --acme-dir /usr/lib/vmware/hostd/docroot/.well-known/acme-challenge > /etc/vmware/ssl/letsencrypt.crt

if [ -s "/etc/vmware/ssl/orig.rui.key" ]; then
echo "backup cert already exist"
else
cp -f /etc/vmware/ssl/rui.key /etc/vmware/ssl/orig.rui.key
cp -f /etc/vmware/ssl/rui.crt /etc/vmware/ssl/orig.rui.crt
fi
if [ -s "/etc/vmware/ssl/letsencrypt.crt" ]; then
cp -f /etc/vmware/ssl/letsencrypt.key /etc/vmware/ssl/rui.key
cp -f /etc/vmware/ssl/letsencrypt.crt /etc/vmware/ssl/rui.crt
/etc/init.d/hostd restart
/etc/init.d/vpxa restart
/etc/init.d/vpxa start
else
echo "letsencrypt.crt file is not correct"
fi
-- lancer le script à la main une première fois et verifier qu'il n'y a pas d'erreurs
-- ouvrir l'ui web vers le serveur (evidement en utilisant le fqdn rentré dans les fichiers de conf), normalement il n'y a plus l'erreur de certificat

il ne reste plus qu'a rendre le renouvellement automatique avec une crontab
-- ajouter (avant le exit 0 !!!) les lignes suivantes dans
/etc/rc.local.d/local.sh

Code : Tout sélectionner

/bin/kill $(cat /var/run/crond.pid) # Gets the cron service pid and simply kills it.
# The next line writes a typical cron line to the crontab
/bin/echo "0 0 1 * * /vmfs/volumes/path_to/letsencrypt_renewal.sh" >> /var/spool/cron/crontabs/root
# Finally we start the cron service again
/usr/lib/vmware/busybox/bin/busybox crond
-- lancer les mêmes lignes directement dans un terminal pour ajouter la commande a la crontab sans avoir à redémarrer


voila.. normalement ça survit a un reboot :D
ça génère un bug avec les derniers patchs esxi ! (depuis celui du 20/08/2020, non corrigé depuis)
le démon sfcb qui permet d'attaquer le CIM a distance pour avoir l'état matériel de la machine se vautre au démarrage si un certificat let's encrypt est installé.
le daemon focntionne avec un certificat autosigné.
en attendant que ça soit corrigé (a priori je suis pas le seul a avoir remarqué), le workaround est d'utiliser un autosigné pour le demon et le let's encrypt pour le Web UI
donc la partie au dessus ne change pas, mais on va regenerer un autosigné pour sfcb:

Code : Tout sélectionner

cd /etc/vmware/ssl
mv rui.crt orig.rui.crt
mv rui.key orig.rui.key
/sbin/generate-certificates
cp rui.crt sfcb.crt
cp rui.key sfcb.key
mv orig.rui.crt rui.crt
mv orig.rui.key rui.key
editer /etc/sfcb/sfcb.cfg pour pointer sur les fichiers sfcb.key et sfcb.crt (lignes a la fin)
redemarre le daemon & tester

Code : Tout sélectionner

/etc/init.d/sfcbd-watchdog restart
la commande esxcli network ip connection list | grep sfcb doit alors retourner 2 lignes, une en http (port 5988) sur l'ip locale 127.0.0.1 et une en https (port 5989) sur toutes les IP (0.0.0.0)

Avatar de l’utilisateur
Dodo29
Messages : 610
Inscription : mer. 24 janv. 2018 19:10
Localisation : Toulouse

Re: VMware ESXi

Message par Dodo29 »

Autant l’idée est bonne autant j’irais pas modifier autant mon esxi. En plus si ça conflicts avec des patch VMware.

Ma solution a été de monter ma PKI avec un ejbca et de signer moi-même les certificats et de valider la CA dans les navigateurs/applications qui l’utilisent.

C’est pas une meilleure méthode que la tienne mais ça me convient mieux de pas trop toucher le moteur de l’esxi.
Et comme ça par la même occasion, tous mes certifs internes sont signés par moi, trustés.

Est-ce que letsencrypt viendra un jour nativement dans esxi ? J’ai cru en entendre parler en version 7.0 mais pas pu la tester (serveurs trop vieux :D )

dsebire
Messages : 10509
Inscription : ven. 12 janv. 2018 17:44
Localisation : Loiret - au milieu des champs

Re: VMware ESXi

Message par dsebire »

ya rien de modifié dans l'esx, ce ne sont que des scripts ajoutés ;)

et la le bug, c'est qu'il digère pas le certificat let's encrypt. pour une raison inconnue.
ya même des chances que tu ai le même soucis avec ta PKI ;)

Avatar de l’utilisateur
Dodo29
Messages : 610
Inscription : mer. 24 janv. 2018 19:10
Localisation : Toulouse

Re: VMware ESXi

Message par Dodo29 »

Pour le moment j’ai pas de bug, mais j’utilise peut être pas le composant en question

Je me souviens plus, il est chez un hébergeur ou chez toi ton esx ?

dsebire
Messages : 10509
Inscription : ven. 12 janv. 2018 17:44
Localisation : Loiret - au milieu des champs

Re: VMware ESXi

Message par dsebire »

ceux sur lesquels j'ai mis un certificat sont hébergés.

morissisback
Messages : 39
Inscription : mar. 19 mai 2020 17:36

Re: VMware ESXi

Message par morissisback »

Salut, j'espère que je me trompe pas, c'est bien un TU ?

j'ai une question, sur mon esxi, l'option "Ajouter un disque => nouveau disque brut" est grisé,

Vous savez pourquoi ? et surtout comment la réactiver ?
merci

Répondre