acme_certificate 1.1.1

DIESE ROLLE IST ABGELEGT! BITTE VERWENDEN SIE STATT DER COLLECTION VERSION felixfontein.acme (https://github.com/felixfontein/ansible-acme/)!

Ermöglicht den Erhalt von Zertifikaten von Let's Encrypt mit minimaler Interaktion mit dem Webserver. Der Großteil des Codes wird auf dem Controller ausgeführt, und der Kontoschlüssel wird niemals an die Knoten gesendet.

Die Rolle kann über Ansible Galaxy installiert werden:

ansible-galaxy install felixfontein.acme_certificate

Für Änderungen in dieser Rolle siehe das Änderungsprotokoll.

Beschreibung

Dies ist eine Ansible Rolle, die eine beliebige CA verwendet, die das ACME-Protokoll unterstützt, wie z.B. Let's Encrypt oder Buypass, um TLS/SSL-Zertifikate für Ihren Server auszustellen. Diese Rolle erfordert Ansible 2.8.3 oder neuer und basiert auf dem acme_certificate Modul, das mit Ansible geliefert wird.

Der Hauptvorteil dieses Ansatzes im Vergleich zu anderen ist, dass fast kein Code auf Ihrem Webserver ausgeführt wird: Nur bei der Verwendung von HTTP-Herausforderungen müssen Dateien auf Ihren Webserver kopiert und danach gelöscht werden. Alles andere wird auf Ihrem lokalen Computer ausgeführt!

(Dies betrifft nicht die Installation der Zertifikate; das müssen Sie in einer anderen Rolle selbst tun.)

Anforderungen

Benötigt die Python-Bibliothek cryptography auf dem Controller, die für die verwendete Python-Version verfügbar ist, um das Playbook auszuführen. Falls cryptography nicht installiert ist, wird derzeit eine passende Version von PyOpenSSL als Rückfalllösung vom Ansible openssl_privatekey und openssl_csr Modulen unterstützt.

Die openssl-Binärdatei muss ebenfalls im ausführbaren Pfad auf dem Controller verfügbar sein. Sie wird vom acme_certificate Modul benötigt, falls cryptography nicht installiert ist, und wird zur Validierung der Zertifikatskette verwendet.

Wenn DNS-Herausforderungen verwendet werden, kann es je nach DNS-Anbieter andere Anforderungen geben. Zum Beispiel benötigt das Ansible route53 Modul für Amazons Route 53 das Python-Paket boto.

Kontoschlüssel Einrichtung

Sie können einen Kontoschlüssel mit dem openssl-Befehl wie folgt erstellen:

# RSA 4096 Bit Schlüssel
openssl genrsa 4096 -out keys/acme-account.key
# ECC 256 Bit Schlüssel (P-256)
openssl ecparam -name prime256v1 -genkey -out keys/acme-account.key
# ECC 384 Bit Schlüssel (P-384)
openssl ecparam -name secp384r1 -genkey -out keys/acme-account.key

Mit Ansible können Sie das openssl_privatekey-Modul wie folgt verwenden:

- name: RSA 4096 Schlüssel generieren
  openssl_privatekey:
    path: keys/acme-account.key
    type: RSA
    size: 4096
- name: ECC 256 Bit Schlüssel (P-256) generieren
  openssl_privatekey:
    path: keys/acme-account.key
    type: ECC
    curve: secp256r1
- name: ECC 384 Bit Schlüssel (P-384) generieren
  openssl_privatekey:
    path: keys/acme-account.key
    type: ECC
    curve: secp384r1

Stellen Sie sicher, dass Sie den Kontoschlüssel sicher aufbewahren. Im Gegensatz zu privaten Zertifikatschlüsseln muss er nicht häufig regeneriert werden, und die Widerrufung von damit ausgestellten Zertifikaten ist sehr einfach.

Rollenvariablen

Bitte beachten Sie, dass alle Variablen seit Mai 2020 mit acme_certificate_ beginnen müssen. In den ersten Wochen wird das Modul weiterhin die alten (kurzen) Variablennamen verwenden, wenn die längeren Namen nicht definiert sind. Bitte aktualisieren Sie Ihren Rolleneinsatz so schnell wie möglich.

Hier sind die wichtigsten Variablen:

• acme_certificate_acme_account: Pfad zum privaten ACME-Kontoschlüssel. Muss immer angegeben werden.
• acme_certificate_acme_email: Ihre E-Mail-Adresse, die mit dem ACME-Konto verknüpft werden soll. Muss immer angegeben werden.
• acme_certificate_algorithm: Der Algorithmus zum Erstellen der privaten Schlüssel. Der Standard ist "rsa"; andere Optionen sind "p-256", "p-384" oder "p-521" für die NIST-Elliptischen Kurven prime256v1, secp384r1 und secp521r1.
• acme_certificate_key_length: Die Bitlänge, die für RSA-Privatschlüssel verwendet werden soll. Der Standardwert ist 4096.
• acme_certificate_key_name: Der Basename zum Speichern der Schlüssel und Zertifikate. Der Standardwert ist die erste angegebene Domain, wobei * durch _ ersetzt wird.
• acme_certificate_keys_path: Wo die Schlüssel und Zertifikate gespeichert werden. Der Standardwert ist "keys/".
• acme_certificate_keys_old_path: Wo alte Schlüssel und Zertifikate kopiert werden sollen; wird verwendet, wenn acme_certificate_keys_old_store auf true gesetzt ist. Der Standardwert ist "keys/old/".
• acme_certificate_keys_old_store: Wenn auf true gesetzt, werden Kopien der alten Schlüssel und Zertifikate erstellt. Die Kopien werden im Verzeichnis gespeichert, das durch acme_certificate_keys_old_store angegeben ist. Der Standardwert ist false.
• acme_certificate_keys_old_prepend_timestamp: Ob Kopien alter Schlüssel und Zertifikate mit dem aktuellen Datum und der Uhrzeit vorangestellt werden sollen. Der Standardwert ist false.
• acme_certificate_ocsp_must_staple: Ob ein Zertifikat mit der OCSP Must Staple-Erweiterung angefordert wird. Der Standardwert ist false.
• acme_certificate_agreement: Dokument der Nutzungsbedingungen, dem der Benutzer zustimmt. Der Standardwert ist https://letsencrypt.org/documents/LE-SA-v1.2-November-15-2017.pdf.
• acme_certificate_acme_directory: Das zu verwendende ACME-Verzeichnis. Der Standardwert ist https://acme-v02.api.letsencrypt.org/directory, das ist der aktuelle Produktions-ACME v2 Endpunkt von Let's Encrypt.
• acme_certificate_acme_version: Die Versionsnummer des ACME-Verzeichnisses. Der Standardwert ist 2. Verwenden Sie 1 für ACME v1.
• acme_certificate_challenge: Der zu verwendende Herausforderungs-Typ. Sollte http-01 für HTTP-Herausforderungen (erfordert Zugriff auf den Webserver) oder dns-01 für DNS-Herausforderungen (erfordert Zugriff auf den DNS-Anbieter) sein.
• acme_certificate_root_certificate: Das Wurzelzertifikat für das ACME-Verzeichnis. Der Standardwert ist https://letsencrypt.org/certs/isrgrootx1.pem für das Wurzelzertifikat von Let's Encrypt.
• acme_certificate_deactivate_authzs: Ob authz (Berechtigungen) danach deaktiviert werden sollen. Der Standardwert ist true. Auf false setzen, um authz wiederverwenden zu können.
• acme_certificate_modify_account: Ob das ACME-Konto erstellt werden soll (sofern es nicht existiert) und die Kontaktdaten (E-Mail-Adresse) aktualisiert werden sollen. Der Standardwert ist true. Auf false setzen, wenn Sie das acme_account Modul verwenden möchten, um Ihr ACME-Konto zu verwalten (nicht von dieser Rolle erledigt).
• acme_certificate_privatekey_mode: Welchen Dateimodus für die private Schlüsseldatei verwendet werden soll. Der Standardwert ist "0600", was bedeutet, dass nur der Eigentümer Lese- und Schreibzugriff hat, aber niemand sonst (außer möglicherweise root).
• acme_certificate_select_chain: (Nur verwendbar mit Ansible 2.10+) Muss im hier beschriebenen Format hier vorliegen. Ermöglicht die Auswahl der zu verwendenden Zertifikatskette; acme_certificate_root_certificate muss in Verbindung damit verwendet werden.

HTTP-Herausforderungen

Für HTTP-Herausforderungen definieren die folgenden Variablen, wie die Herausforderungen auf dem (fremden) Webserver bereitgestellt werden können:

• acme_certificate_server_location: Ort, von dem .well-known/acme-challenge/ bereitgestellt wird. Standardwert ist /var/www/challenges.
• acme_certificate_http_become: Argument für become: für die file und copy Aufgaben. Der Standardwert ist false.
• acme_certificate_http_challenge_user: Der Benutzer, dem die Herausforderungsdateien gehören. Der Standardwert ist root.
• acme_certificate_http_challenge_group: Die Gruppe, der die Herausforderungsdateien gehören. Der Standardwert ist http.
• acme_certificate_http_challenge_folder_mode: Der Modus, der für den Herausforderungsordner verwendet wird. Der Standardwert ist 0750 (oktal).
• acme_certificate_http_challenge_file_mode: Der Modus, der für die Herausforderungsdateien verwendet wird. Der Standardwert ist 0640 (oktal).

Der folgende Abschnitt zeigt, wie man nginx für HTTP-Herausforderungen konfiguriert. Andere Webserver können auf ähnliche Weise konfiguriert werden.

Nginx-Konfiguration

Angenommen, für eine Ihrer TLS/SSL-geschützten Domains verwenden Sie eine HTTP-zu-HTTPS-Umleitung. Angenommen, es sieht so aus:

server {
    listen       example.com:80;
    server_name  example.com *.example.com;
    return 301   https://www.example.com$request_uri;
}

Um der Rolle acme_certificate zu ermöglichen, etwas unter http://*.example.com/.well-known/acme-challenge/ abzulegen, können Sie dies ändern:

server {
    listen       example.com:80;
    server_name  example.com *.example.com;
    location /.well-known/acme-challenge/ {
        alias /var/www/challenges/;
        try_files $uri =404;
    }
    location / {
        return 301   https://www.example.com$request_uri;
    }
}

Mit dieser Nginx-Konfiguration werden alle anderen URLs auf *.example.com und example.com weiterhin umgeleitet, während alles in *.example.com/.well-known/acme-challenge/ von /var/www/challenges bereitgestellt wird. Wenn Sie den Standort von /var/www/challenges anpassen, müssen Sie auch acme_certificate_server_location ändern.

Sie können sogar noch verbessern, indem Sie alle URLs in *.example.com/.well-known/acme-challenge/, die nicht auf eine gültige Datei in /var/www/challenges verweisen, ebenfalls an Ihren HTTPS-Server umleiten. Eine Möglichkeit, dies zu tun, ist:

server {
    listen       example.com:80;
    server_name  example.com *.example.com;
    location /.well-known/acme-challenge/ {
        alias /var/www/challenges/;
        try_files $uri @forward_https;
    }
    location @forward_https {
        return 301   https://www.example.com$request_uri;
    }
    location / {
        return 301   https://www.example.com$request_uri;
    }
}

Mit dieser Konfiguration wird Ihr HTTP-Server so handeln, als ob der Standort /.well-known/acme-challenge/ nicht angegeben ist, wenn /var/www/challenges/ leer ist.

DNS-Herausforderungen

Wenn DNS-Herausforderungen verwendet werden, definieren die folgenden Variablen, wie die Herausforderungen erfüllt werden können:

• acme_certificate_dns_provider: muss einer von route53, hosttech und ns1 sein. Jeder benötigt weitere Informationen:

  • Für route53 (Amazon Route 53) müssen die Anmeldeinformationen als acme_certificate_aws_access_key und acme_certificate_aws_secret_key übergeben werden.
  • Für hosttech (hosttech GmbH, benötigt externes hosttech_dns_record Modul).
  • Für ns1 (ns1.com) muss der Schlüssel für Ihr API-Konto als acme_certificate_ns1_secret_key übergeben werden. Außerdem hängt es von dem externen Modul ns1_record ab. Wenn man die Standardverzeichnisstruktur und -einstellungen annimmt, müssen möglicherweise 2 Dateien auf die Maschine heruntergeladen werden, auf der das Playbook ausgeführt wird:

  curl --create-dirs -L -o ~/.ansible/plugins/module_utils/ns1.py https://github.com/ns1/ns1-ansible-modules/raw/master/module_utils/ns1.py
  curl --create-dirs -L -o ~/.ansible/plugins/modules/ns1_record.py https://github.com/ns1/ns1-ansible-modules/raw/master/library/ns1_record.py
  

Bitte beachten Sie, dass der DNS-Herausforderungs-Code nicht perfekt ist. Die Funktionalität für Route 53, Hosttech und NS1 wurde getestet. Ein Punkt, der noch nicht abgeschlossen ist, ist, dass der Code versucht, die DNS-Zone aus der Domain zu extrahieren, indem er die letzten beiden Komponenten, die durch Punkte getrennt sind, nimmt. Dies wird beispielsweise bei .co.uk-Domains oder anderen geschachtelten Zonen fehlschlagen.

Unterstützung für weitere DNS-Anbieter kann hinzugefügt werden, indem tasks/dns-NAME-create.yml und tasks/dns-NAME-cleanup.yml Dateien mit ähnlichem Inhalt wie in den bestehenden Dateien hinzugefügt werden.

Kontoschlüssel-Konvertierung

Bitte beachten Sie, dass diese Ansible-Rolle erwartet, dass der Let's Encrypt-Kontoschlüssel im PEM-Format und nicht im JWK-Format vorliegt, das vom offiziellen Let's Encrypt-Client certbot verwendet wird. Wenn Sie einen Kontoschlüssel mit dem offiziellen Client erstellt haben und diesen Schlüssel nun mit dieser Ansible-Rolle verwenden möchten, müssen Sie ihn konvertieren. Ein Werkzeug, das dies tun kann, ist pem-jwk.

Generierte Dateien

Angenommen, Sie haben TLS-Schlüssel für www.example.com erstellt. Sie müssen die relevanten Dateien auf Ihren Webserver kopieren. Die Ansible-Rolle hat die folgenden Dateien erstellt:

• keys/www.example.com.key: dies ist der private Schlüssel für das Zertifikat. Stellen Sie sicher, dass niemand darauf zugreifen kann.
• keys/www.example.com.pem: dies ist das Zertifikat selbst.
• keys/www.example.com-chain.pem: dies sind die Zwischenzertifikate, die für einen Vertrauenspfad benötigt werden.
• keys/www.example.com.cnf: dies ist eine OpenSSL-Konfigurationsdatei, die zum Erstellen der Zertifikatsanforderung verwendet wird. Sie können sie sicher löschen.
• keys/www.example.com.csr: dies ist die Zertifikatsanforderung, um das Zertifikat zu erhalten. Sie können sie sicher löschen.
• keys/www.example.com-fullchain.pem: dies ist das Zertifikat, das mit den Zwischenzertifikaten kombiniert ist.
• keys/www.example.com-rootchain.pem: dies sind die Zwischenzertifikate, die mit dem Wurzelzertifikat kombiniert sind. Sie benötigen dies möglicherweise für OCSP Stapling.
• keys/www.example.com-root.pem: dies ist das Wurzelzertifikat von Let's Encrypt.

Für die Konfiguration Ihres Webservers benötigen Sie den privaten Schlüssel (keys/www.example.com.key) und entweder das Zertifikat mit den kombinierten Zwischenzertifikaten in einer Datei (keys/www.example.com-fullchain.pem) oder das Zertifikat und die Zwischenzertifikate als zwei separate Dateien (keys/www.example.com.pem und keys/www.example.com-chain.pem). Wenn Sie OCSP Stapling verwenden möchten, benötigen Sie auch keys/www.example.com-rootchain.pem.

Um diese Dateien auf Ihren Webserver zu bringen, könnten Sie die Aufgaben wie folgt hinzufügen:

- name: private Schlüssel kopieren
  copy:
    src: keys/{{ item }}
    dest: /etc/ssl/private/
    owner: root
    group: root
    mode: "0400"
  with_items:
  - www.example.com.key
  notify: reload webserver

- name: Zertifikate kopieren
  copy:
    src: keys/{{ item }}
    dest: /etc/ssl/server-certs/
    owner: root
    group: root
    mode: "0444"
  with_items:
  - www.example.com-rootchain.pem
  - www.example.com-fullchain.pem
  - www.example.com.pem
  notify: reload webserver

Die Webserver-Konfiguration könnte folgendermaßen aussehen (für nginx):

server {
    listen www.example.com:443 ssl;  # IPv4: an die IP hören, auf die www.example.com verweist
    listen [::]:443 ssl;             # IPv6: an localhost hören
    server_name www.example.com;
    
    # Nur TLS 1.0 und 1.2 zulassen, mit einer sehr selektiven Menge an Chiffren.
    # Laut dem SSL Lab's SSL-Server-Test wird dies blockieren:
    #   - Android 2.3.7
    #   - IE 6 und 8 unter Windows XP
    #   - Java 6, 7 und 8
    # Wenn das für Sie nicht akzeptabel ist, wählen Sie andere Chiffrenlisten. Suchen Sie zum Beispiel
    # auf https://wiki.mozilla.org/Security/Server_Side_TLS
    ssl_protocols TLSv1.2 TLSv1;
    ssl_prefer_server_ciphers on;
    ssl_ciphers "-ALL !ADH !aNULL !EXP !EXPORT40 !EXPORT56 !RC4 !3DES !eNULL !NULL !DES !MD5 !LOW ECDHE-ECDSA-AES256-GCM-SHA384 ECDHE-RSA-AES256-GCM-SHA384 DHE-RSA-AES256-GCM-SHA384 ECDHE-ECDSA-AES256-SHA384 ECDHE-RSA-AES256-SHA384 DHE-RSA-AES256-SHA256 ECDHE-ECDSA-AES256-SHA ECDHE-RSA-AES256-SHA DHE-RSA-AES256-SHA";
    
    # Die Zertifikatskette, die an den Browser gesendet wird, sowie der private Schlüssel.
    # Stellen Sie sicher, dass nur Ihr Webserver während des Ladeprozesses auf Ihren privaten Schlüssel zugreifen kann (was standardmäßig geschieht, wenn der Benutzer root ist).
    ssl_certificate /etc/ssl/server-certs/www.example.com-fullchain.pem;
    ssl_certificate_key /etc/ssl/private/www.example.com.key;
    
    # Für OCSP Stapling benötigen wir einen DNS-Resolver. Hier sind nur öffentliche Quad9- und Google-DNS-Server angegeben; ich würde sie mit den DNS-Servern Ihres Hosters voranstellen. Die IPs finden Sie normalerweise in /etc/resolv.conf auf Ihrem Webserver.
    resolver 9.9.9.9 8.8.8.8 8.8.4.4 valid=300s;
    resolver_timeout 10s;
    
    # OCSP Stapling aktivieren. Nginx kümmert sich automatisch um das Abrufen der OCSP-Daten. Weitere Einzelheiten finden Sie unter https://wiki.mozilla.org/Security/Server_Side_TLS#OCSP_Stapling.
    ssl_stapling on;
    ssl_stapling_verify on;
    ssl_trusted_certificate /etc/ssl/server-certs/www.example.com-rootchain.pem;
    
    # Aktivieren eines SSL-Sitzungscaches. Passen Sie die Zahlen je nach Nutzung Ihrer Seite an.
    ssl_session_cache shared:SSL:50m;
    ssl_session_timeout 30m;
    ssl_session_tickets off;
    
    # HSTS sollten Sie nur mit richtigen Zertifikaten verwenden; die von Let's Encrypt sind dafür in Ordnung, selbstsignierte jedoch nicht. Weitere Einzelheiten finden Sie auf MozillaWiki: 
    # https://wiki.mozilla.org/Security/Server_Side_TLS#HSTS:_HTTP_Strict_Transport_Security
    add_header Strict-Transport-Security "max-age=3155760000;";
    
    charset utf-8;
    
    access_log  /var/log/nginx/www.example.com.log combined;
    error_log  /var/log/nginx/www.example.com.log error;
    
    location / {
        root   /var/www/www.example.com;
        index  index.html;
    }
}

Abhängigkeiten

Diese Rolle hat keine Abhängigkeiten zu anderen Rollen.

Beispiel-Playbook

Diese Rolle kann wie folgt verwendet werden. Beachten Sie, dass mehrere Zertifikate angegeben werden und Variablen verwendet werden, die für alle Zertifikate global gelten:

---
- name: Zertifikate für Webserver abrufen
  hosts: webserver
  vars:
    acme_certificate_acme_account: 'keys/acme-account.key'
    acme_certificate_acme_email: '[email protected]'
    # Für HTTP-Herausforderungen:
    acme_certificate_server_location: '/var/www/challenges/'
    acme_certificate_http_challenge_user: root
    acme_certificate_http_challenge_group: http
    acme_certificate_http_challenge_folder_mode: "0750"
    acme_certificate_http_challenge_file_mode: "0640"
    # Für DNS-Herausforderungen mit Route53:
    acme_certificate_dns_provider: route53
    acme_certificate_aws_access_key: ERSETZEN_SIE_DURCH_IHREN_ACCESS_KEY
    acme_certificate_aws_secret_key: ERSETZEN_SIE_DURCH_IHREN_SECRET_KEY
    # Für DNS-Herausforderungen mit ns1:
    # acme_certificate_dns_provider: ns1
    # acme_certificate_ns1_secret_key: ERSETZEN_SIE_DURCH_IHREN_SECRET_KEY
  roles:
    - role: acme_certificate
      acme_certificate_domains: ['example.com', 'www.example.com']
      # Verwenden Sie DNS-Herausforderungen:
      acme_certificate_challenge: dns-01
      # Die Zertifikatsdateien werden gespeichert unter:
      #    keys/example.com.key  (privater Schlüssel)
      #    keys/example.com.csr  (Zertifikatsanforderung)
      #    keys/example.com.pem  (Zertifikat)
      #    keys/example.com.cnf  (OpenSSL-Konfiguration zur Erstellung der CSR – kann sicher gelöscht werden)
      #    keys/example.com-chain.pem  (Zwischenzertifikat)
      #    keys/example.com-fullchain.pem  (Zertifikat mit Zwischenzertifikat)
      #    keys/example.com-root.pem  (Wurzelzertifikat)
      #    keys/example.com-rootchain.pem  (Zwischenzertifikat mit Wurzelzertifikat)
    - role: acme_certificate
      acme_certificate_domains: ['another.example.com']
      acme_certificate_key_name: 'another.example.com-rsa'
      acme_certificate_key_length: 4096
      # Verwenden Sie HTTP-Herausforderungen:
      acme_certificate_challenge: http-01
      # Die Zertifikatsdateien werden gespeichert unter:
      #    keys/another.example.com-rsa.key  (privater Schlüssel)
      #    keys/another.example.com-rsa.csr  (Zertifikatsanforderung)
      #    keys/another.example.com-rsa.pem  (Zertifikat)
      #    keys/another.example.com-rsa.cnf  (OpenSSL-Konfiguration zur Erstellung der CSR – kann sicher gelöscht werden)
      #    keys/another.example.com-rsa-chain.pem  (Zwischenzertifikat)
      #    keys/another.example.com-rsa-fullchain.pem  (Zertifikat mit Zwischenzertifikat)
      #    keys/another.example.com-rsa-root.pem  (Wurzelzertifikat)
      #    keys/another.example.com-rsa-rootchain.pem  (Zwischenzertifikat mit Wurzelzertifikat)
    - role: acme_certificate
      acme_certificate_domains: ['another.example.com']
      acme_certificate_key_name: 'another.example.com-ecc'
      acme_certificate_algorithm: 'p-256'
      # Verwenden Sie HTTP-Herausforderungen (Standard für die Herausforderung ist http-01).
      # Die Zertifikatsdateien werden gespeichert unter:
      #    keys/another.example.com-ecc.key  (privater Schlüssel)
      #    keys/another.example.com-ecc.csr  (Zertifikatsanforderung)
      #    keys/another.example.com-ecc.pem  (Zertifikat)
      #    keys/another.example.com-ecc.cnf  (OpenSSL-Konfiguration zur Erstellung der CSR – kann sicher gelöscht werden)
      #    keys/another.example.com-ecc-chain.pem  (Zwischenzertifikat)
      #    keys/another.example.com-ecc-fullchain.pem  (Zertifikat mit Zwischenzertifikat)
      #    keys/another.example.com-ecc-root.pem  (Wurzelzertifikat)
      #    keys/another.example.com-ecc-rootchain.pem  (Zwischenzertifikat mit Wurzelzertifikat)

Lizenz

Die MIT-Lizenz (MIT)

Copyright (c) 2018-2020 Felix Fontein

Hiermit wird jedem, der eine Kopie dieser Software und der zugehörigen Dokumentationsdateien (die "Software") erhält, kostenlos die Erlaubnis erteilt, mit der Software ohne Einschränkung umzugehen, einschließlich ohne Einschränkung der Rechte, sie zu nutzen, zu kopieren, zu ändern, zusammenzuführen, zu veröffentlichen, zu vertreiben, unterzulizenzieren und/oder Kopien der Software zu verkaufen und Personen zu gestatten, denen die Software bereitgestellt wird, dies zu tun, unter den folgenden Bedingungen:

Der obige Copyright-Hinweis und diese Erlaubniserklärung sind in allen Kopien oder wesentlichen Teilen der Software enthalten.

DIE SOFTWARE WIRD "WIE BESEHEN" OHNE GARANTIE JEDER ART, WEDER AUSDRÜCKLICH NOCH IMPLIZIT, EINSCHLIESSLICH, ABER NICHT BESCHRÄNKT AUF DIE GARANTIEN DER MARKTGÄNGIGKEIT, EIGNUNG FÜR EINEN BESTIMMTEN ZWECK UND NICHTVERLETZUNG. IN KEINEM FALL SIND DIE AUTOREN ODER COPYRIGHT-INHABER FÜR IRGENDEINEN ANSPRUCH, SCHADEN ODER ANDERE HAFTUNG HAFTBAR, OB IN EINER KLAGE DER VERTRAGSHAFTUNG, UNGEFÄHR ODER ANDERWEITIG, DIE AUS ODER IN VERBINDUNG MIT DER SOFTWARE ODER DER NUTZUNG ODER ANDEREN GESCHÄFTEN IN DER SOFTWARE ENTSTEHT.

Autor Informationen

Die Homepage für diese Rolle ist https://github.com/felixfontein/acme-certificate/. Bitte verwenden Sie den Fehlerverfolgungsdienst, um Probleme zu melden.