Lizenzen, Entwicklerdokumentation

1.Was das leistet, und was nicht

Ein Lizenzschlüssel bindet Ihr Produkt an eine Domain, oder an so viele, wie der Käufer bezahlt hat. Er hilft einem ehrlichen Kunden, in dem zu bleiben, was er gekauft hat, er gibt Ihnen die Zahl Ihrer Installationen, und er macht einen durchgesickerten Schlüssel abschaltbar — der Besitzer erzeugt ihn neu, und der durchgesickerte stirbt. Es ist kein Kopierschutz. Ihr Käufer hat Ihren Quelltext und kann die Prüfung in fünf Minuten entfernen. Wer Ihnen etwas anderes erzählt, will Ihnen etwas verkaufen.

2.Drei Schritte

1. Öffnen Sie Ihr Produkt im Autorenbereich, gehen Sie zu Lizenz und laden Sie die Bibliothek herunter. Sie enthält bereits unseren öffentlichen Schlüssel und Ihre Produktkennung — nichts einzurichten.
2. Fragen Sie den Käufer bei der ersten Installation nach seinem Schlüssel und legen Sie ihn dort ab, wo Ihr Produkt seine Einstellungen speichert. Schreiben Sie ihn nie fest in den Code.
3. Rufen Sie valide() dort auf, wo es zählt. Einmal pro Anfrage genügt — die Bibliothek speichert zwischen und geht nicht bei jeder Seite ins Netz.

3.Ihre Bibliothek ist die von niemandem sonst

Die Datei, die Sie herunterladen, wird für ein Produkt erzeugt. Klasse, Dateiname und Cache-Datei tragen alle einen aus diesem Produkt abgeleiteten Namen, und die aufgerufene Adresse wird zur Laufzeit zusammengesetzt statt als eine Zeichenkette geschrieben. Zwei Ihrer eigenen Produkte teilen keinen einzigen Bezeichner.

Seien wir klar, was das bringt. Wer Ihre Dateien öffnet und liest, findet die Prüfung in zwei Minuten — das hat sich nicht geändert und wird sich nie ändern. Was es stoppt, ist das andere: ein Skript, das in Tausenden Produkten nach einem bekannten Klassennamen sucht und ihn automatisch entfernt. So entstehen genullte Kopien in Serie, und das funktioniert hier nicht mehr. Die Kosten, Ihr Produkt zu raubkopieren, steigen von null auf eine manuelle Durchsicht, Produkt für Produkt.

Die Beispiele auf dieser Seite nennen die Klasse Licence. In Ihrem Download trägt sie ihren echten Namen, angezeigt neben dem Download-Button in Ihrem Autorenbereich.

4.Die Integration, Umgebung für Umgebung

Öffnen Sie den Block, der zu Ihrem Produkt passt. Jeder ist vollständig und zum Einfügen bereit; benennen Sie monmodule um und passen Sie die Ablage des Schlüssels an Ihre eigenen Einstellungen an. Die PHP-Umgebungen nutzen die herunterladbare Bibliothek; die anderen zeigen den kompletten Client, samt Cache und Signaturprüfung.

require_once __DIR__ . '/Licence.php';

$licence = new Licence(
    $config['licence'],
    __DIR__ . '/cache'
);

if (!$licence->valide()) {
    http_response_code(403);
    exit($licence->message());
}

require_once dirname(__FILE__) . '/Licence.php';

class MonModule extends Module
{
    private $licence = null;

    private function licence()
    {
        if ($this->licence === null) {
            $this->licence = new Licence(
                Configuration::get('MONMODULE_LICENCE'),
                _PS_CACHE_DIR_ . 'monmodule'
            );
        }
        return $this->licence;
    }

    public function getContent()
    {
        if (Tools::isSubmit('submitLicence')) {
            Configuration::updateValue('MONMODULE_LICENCE', Tools::getValue('licence'));
        }

        $l = $this->licence();

        if (!$l->valide()) {
            return $this->displayError($l->message()) . $this->formulaireLicence();
        }
        if ($l->essai()) {
            return $this->displayWarning($this->l('Development licence')) . $this->contenu();
        }

        return $this->contenu();
    }

    public function hookDisplayHeader()
    {
        if (!$this->licence()->valide()) {
            return '';
        }
        return $this->contenuFront();
    }
}

require_once __DIR__ . '/Licence.php';

function monplug_licence() {
    static $l = null;
    if ($l === null) {
        $l = new Licence(
            get_option('monplug_licence'),
            WP_CONTENT_DIR . '/cache/monplug'
        );
    }
    return $l;
}

add_action('admin_notices', function () {
    $l = monplug_licence();
    if (!$l->valide()) {
        printf('<div class="notice notice-error"><p>%s</p></div>', esc_html($l->message()));
    } elseif ($l->essai()) {
        echo '<div class="notice notice-warning"><p>'
           . esc_html__('Development licence', 'monplug') . '</p></div>';
    }
});

add_action('init', function () {
    if (monplug_licence()->valide()) {
        monplug_demarrer();
    }
});

add_filter('woocommerce_payment_gateways', function ($passerelles) {
    if (monplug_licence()->valide()) {
        $passerelles[] = 'WC_Gateway_MonPlug';
    }
    return $passerelles;
});

add_action('woocommerce_admin_field_monplug_licence', function () {
    $l = monplug_licence();
    if (!$l->valide()) {
        echo '<div class="error inline"><p>' . esc_html($l->message()) . '</p></div>';
    }
});

namespace Editeur\MonModule\Model;

use Magento\Framework\App\Config\ScopeConfigInterface;
use Magento\Framework\App\Filesystem\DirectoryList;

class Licence
{
    private $licence;

    public function __construct(ScopeConfigInterface $config, DirectoryList $dossiers)
    {
        $this->licence = new \Licence(
            (string) $config->getValue('monmodule/general/licence'),
            $dossiers->getPath(DirectoryList::CACHE) . '/monmodule'
        );
    }

    public function valide(): bool
    {
        return $this->licence->valide();
    }

    public function message(): string
    {
        return $this->licence->message();
    }
}

{
  "autoload": {
    "files": [
      "Licence.php"
    ]
  }
}

namespace App\Licence;

use Closure;
use Illuminate\Http\Request;

class VerifieLicence
{
    private $licence;

    public function __construct()
    {
        $this->licence = new \Licence(
            config('monmodule.licence'),
            storage_path('app/monmodule')
        );
    }

    public function handle(Request $requete, Closure $suivant)
    {
        if (!$this->licence->valide()) {
            abort(403, $this->licence->message());
        }

        return $suivant($requete);
    }
}

namespace App\Licence;

use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use Symfony\Component\HttpKernel\Event\RequestEvent;
use Symfony\Component\HttpKernel\Exception\AccessDeniedHttpException;
use Symfony\Component\HttpKernel\KernelEvents;

class LicenceSubscriber implements EventSubscriberInterface
{
    private $licence;

    public function __construct(string $cle, string $dossierCache)
    {
        $this->licence = new \Licence($cle, $dossierCache);
    }

    public function onKernelRequest(RequestEvent $evenement): void
    {
        if (!$evenement->isMainRequest()) {
            return;
        }

        if (!$this->licence->valide()) {
            throw new AccessDeniedHttpException($this->licence->message());
        }
    }

    public static function getSubscribedEvents(): array
    {
        return [KernelEvents::REQUEST => ['onKernelRequest', 16]];
    }
}

import { createPublicKey, verify } from 'node:crypto';
import { readFile, writeFile, mkdir } from 'node:fs/promises';
import { dirname } from 'node:path';

const API = 'https://addonsmarket.com/api/licence';
const PUBLIQUE = '/PTkKQpweo9XCLOS0+b0vgrecx7Ly/SsAuwTiA737Tw=';
const SURSIS = 2592000;

const publique = createPublicKey({
  key: Buffer.concat([Buffer.from('302a300506032b6570032100', 'hex'),
                      Buffer.from(PUBLIQUE, 'base64')]),
  format: 'der',
  type: 'spki',
});

const canonique = (d) =>
  JSON.stringify(Object.fromEntries(Object.keys(d).sort().map((k) => [k, d[k]])));

const signee = (rep, hote) =>
  rep && rep.donnees && rep.signature
  && rep.donnees.hote === hote
  && verify(null, Buffer.from(canonique(rep.donnees), 'utf8'), publique,
            Buffer.from(rep.signature, 'base64'));

export async function etat(cle, hote, fichierCache) {
  const maintenant = Math.floor(Date.now() / 1000);
  let cache = null;

  try {
    const lu = JSON.parse(await readFile(fichierCache, 'utf8'));
    if (signee(lu, hote)) cache = lu;
  } catch {}

  if (cache && cache.donnees.revalider > maintenant) return cache.donnees;

  try {
    const r = await fetch(API, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json', 'User-Agent': 'MonProduit/1.0' },
      body: JSON.stringify({ cle, url: hote }),
      signal: AbortSignal.timeout(6000),
    });
    if (!r.ok) throw new Error(String(r.status));

    const rep = await r.json();
    if (!signee(rep, hote)) throw new Error('signature');

    await mkdir(dirname(fichierCache), { recursive: true });
    await writeFile(fichierCache, JSON.stringify(rep));
    return rep.donnees;
  } catch {
    if (cache && cache.donnees.emis + SURSIS > maintenant) return cache.donnees;
    return { ok: false, motif: 'reseau' };
  }
}

import { etat } from './licence.mjs';

const d = await etat(process.env.LICENCE, req.hostname, './var/licence.json');

if (!d.ok && d.motif !== 'reseau') {
  return res.status(403).json({ erreur: d.motif });
}

app.get('/api/etat', async (req, res) => {
  const d = await etat(process.env.LICENCE, req.hostname, './var/licence.json');
  res.json({ actif: d.ok, essai: d.essai });
});

const [actif, setActif] = useState(null);

useEffect(() => {
  fetch('/api/etat')
    .then((r) => r.json())
    .then((d) => setActif(d.actif));
}, []);

if (actif === false) {
  return <Bandeau>Licence inactive</Bandeau>;
}

import base64, json, time, urllib.request
from pathlib import Path
from cryptography.exceptions import InvalidSignature
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey

API = 'https://addonsmarket.com/api/licence'
PUBLIQUE = '/PTkKQpweo9XCLOS0+b0vgrecx7Ly/SsAuwTiA737Tw='
SURSIS = 2592000

_publique = Ed25519PublicKey.from_public_bytes(base64.b64decode(PUBLIQUE))


def _canonique(d):
    return json.dumps(d, sort_keys=True, separators=(',', ':'), ensure_ascii=False)


def _signee(rep, hote):
    try:
        if rep['donnees']['hote'] != hote:
            return False
        _publique.verify(base64.b64decode(rep['signature']),
                         _canonique(rep['donnees']).encode('utf-8'))
        return True
    except (KeyError, TypeError, ValueError, InvalidSignature):
        return False


def etat(cle, hote, fichier_cache):
    maintenant = int(time.time())
    chemin = Path(fichier_cache)
    cache = None

    try:
        lu = json.loads(chemin.read_text(encoding='utf-8'))
        if _signee(lu, hote):
            cache = lu
    except (OSError, ValueError):
        pass

    if cache and cache['donnees']['revalider'] > maintenant:
        return cache['donnees']

    try:
        corps = json.dumps({'cle': cle, 'url': hote}).encode('utf-8')
        requete = urllib.request.Request(API, data=corps, headers={
            'Content-Type': 'application/json',
            'User-Agent': 'MonProduit/1.0',
        })
        with urllib.request.urlopen(requete, timeout=6) as r:
            rep = json.loads(r.read().decode('utf-8'))

        if not _signee(rep, hote):
            raise ValueError('signature')

        chemin.parent.mkdir(parents=True, exist_ok=True)
        chemin.write_text(json.dumps(rep), encoding='utf-8')
        return rep['donnees']

    except Exception:
        if cache and cache['donnees']['emis'] + SURSIS > maintenant:
            return cache['donnees']
        return {'ok': False, 'motif': 'reseau'}

curl -X POST https://addonsmarket.com/api/licence \
     -H 'Content-Type: application/json' \
     -H 'User-Agent: MonProduit/1.0' \
     -d '{"cle":"VOTRE_CLE","url":"boutique.exemple.fr"}'

5.Es sagen, statt es kaputtzumachen

Bei einem Theme oder Skript, das an jemanden verkauft wird, der kein Entwickler ist, ist es der falsche Zug, bei einer unlizenzierten Kopie die Seite abzuschalten: Es trifft meist den Käufer, der seinen Schlüssel falsch abgetippt hat, und Ihr Support-Postfach zahlt dafür. banniere() liefert stattdessen einen kleinen festen Hinweis — sonst ändert sich auf der Seite nichts.

require_once __DIR__ . '/Licence.php';

$reglages = @include __DIR__ . '/licence.php';

$licence = new Licence(
    is_array($reglages) ? $reglages['cle'] : '',
    __DIR__ . '/cache'
);

register_shutdown_function(function () use ($licence) {
    echo $licence->banniere('My theme');
});

Der Käufer wird ihn los, indem er seinen Schlüssel in eine Datei neben der Bibliothek einträgt. Diese Datei ist das Einzige, was er anfassen muss.

<?php

return array(
    'cle' => '',
);

Sie gibt eine leere Zeichenkette zurück, wenn die Lizenz gültig ist, und ebenso, wenn das Netz ausgefallen ist — ein Besucher sieht nie einen Hinweis, weil unser Server eine schlechte Nacht hatte. Bei einem Entwicklungsschlüssel sagt sie es dezent, und genau das wollen Sie beim Bauen.

6.Produkte ohne Server: HTML-Themes, Vorlagen, Grafiken

Ein HTML-Theme, eine Figma-Datei, ein Icon-Set, eine Schrift: nichts davon läuft auf einem Server, den Sie abfragen können. Alles, was Sie ausliefern, wird von dem gelesen, geändert und weitergegeben, der die Dateien hat. Es gibt keine Prüfung zum Einbauen, und keine Fassung dieser Seite, in der sich das ändert.

Tun Sie nicht so als ob. Ein verschleiertes Skript, das aus einer statischen Seite heraus nach Hause telefoniert, ein verstecktes Canvas-Fingerprinting, ein Build, der nach dreißig Tagen kaputtgeht: all das entfernt die eine Person, die Sie ohnehin raubkopiert hätte, an einem Nachmittag, und all das landet als Support-Ticket bei den fünfzig, die bezahlt haben. Sie würden Ihre Glaubwürdigkeit ausgeben, um nichts zu schützen.

Was es stattdessen gibt, wirkt bei der Auslieferung, nicht zur Laufzeit. Jeder Download wird für den Käufer neu verpackt, der ihn angefordert hat, und trägt drei Dinge:

• Eine Lizenzdatei im Wurzelverzeichnis des Archivs, die Bestellung, Inhaber und Umfang der Lizenz nennt.
• Einen Fingerabdruck, in dieser Datei und im Archivkommentar — zwanzig Zeichen, abgeleitet aus Lizenz und Produkt, die genau diesen einen Download kennzeichnen und keinen anderen.
• Einen Satz in zwei Sprachen, der sagt, was die Weitergabe kostet: die Nutzungsrechte und die Updates, ohne Erstattung.

Das ist Rückverfolgbarkeit, keine Verhinderung, und wir verkaufen es Ihnen nicht als etwas anderes: Ein Käufer, der die Datei löscht und den Kommentar leert, geht mit einer sauberen Kopie. Was es Ihnen gibt, ist ein Name, wenn eine Kopie dort auftaucht, wo sie nicht sein sollte, ein Grund für diesen Käufer, es sich zweimal zu überlegen, und die zwei Dinge, die eine Raubkopie nie bekommt — die Updates und Ihren Support.

Eine Unterscheidung zählt hier. Enthält Ihr Theme überhaupt PHP — ein Kontaktformular, eine Konfigurationsdatei, ein Include —, dann läuft es auf einem Server, die obige Prüfung ist echt und der Hinweis funktioniert. Nur im vollständig statischen Fall, HTML und CSS und sonst nichts, gibt es zur Laufzeit keine Prüfung.

7.Die Bibliothek

Eine einzige PHP-Datei, keine Abhängigkeit, kompatibel bis hinunter zu PHP 5.6, damit sie auf den alten Installationen läuft, die Ihre Käufer noch haben. Vier Methoden reichen.

8.Die wichtigste Regel

Lassen Sie nie ein Netzwerkproblem den Shop Ihres Käufers abschalten. Die Bibliothek regelt das bereits, und Sie sollten es nicht umgehen: ein frisches Urteil wird 24 Stunden wiederverwendet; antwortet unser Server nicht, bleibt das letzte bekannte Urteil 30 Tage gültig und das Produkt läuft weiter; nur eine signierte Ablehnung stoppt es, und zwar sofort. Hat unser Server eine schlechte Nacht, geht kein Shop aus. Wird ein Schlüssel übertragen, hört die alte Seite binnen 24 Stunden auf.

9.Domains

Eine Lizenz bindet an die registrierbare Domain. Ein Schlüssel auf beispiel.de deckt www.beispiel.de, shop.beispiel.de und jede andere Subdomain ab — Ihr Käufer schreibt Ihnen nicht wegen einer fehlenden Weiterleitung. Test- und Staging-Adressen verbrauchen nie eine Lizenz: localhost, .local, .test sowie die üblichen Präfixe dev., staging., preprod. funktionieren, ohne etwas zu verbrauchen.

10.Die API, wenn Sie lieber selbst aufrufen

Die Bibliothek ist nur eine dünne Hülle um einen einzigen Endpunkt. Rufen Sie ihn direkt auf, wenn Sie außerhalb von PHP arbeiten — dann müssen Sie die obigen Cache-Regeln allerdings selbst umsetzen und die Signatur prüfen.

Endpunkt

POST https://addonsmarket.com/api/licence

Anfrage

POST /api/licence HTTP/1.1
Host: addonsmarket.com
Content-Type: application/json
User-Agent: MonProduit/1.0

{
  "cle": "VOTRE_CLE",
  "url": "boutique.exemple.fr"
}

Was Sie senden

Antwort

{
  "donnees": {
    "ok": true,
    "motif": "",
    "domaine": "exemple.fr",
    "essai": false,
    "quand": "",
    "emis": 1790687453,
    "revalider": 1790773853,
    "sursis": 2592000,
    "hote": "boutique.exemple.fr"
  },
  "signature": "4p9JXJRfcB5R/LNEQwr/cwnVv1M5R1OdCNcU…"
}

Felder der Antwort

HTTP-Codes

Dreißig Aufrufe pro Minute und IP-Adresse. Werden die Cache-Regeln eingehalten, ruft ein Shop einmal am Tag auf; dieses Limit erreichen Sie also nur aus einem Lasttest oder einer Schleife, die ihren Cache vergessen hat.

Senden Sie einen User-Agent, der Ihr Produkt nennt. Einige Standard-Agenten von HTTP-Bibliotheken — der von urllib in Python etwa — werden gefiltert, bevor sie uns erreichen, und bekommen ein 403. Jede eigene Zeichenkette vermeidet das.

11.Warum die Antwort signiert ist

Ohne Signatur genügt eine Zeile in der hosts-Datei eines Servers, um an unserer Stelle „Lizenz gültig“ zu antworten. Jede Antwort trägt eine Ed25519-Signatur über die kanonische Form der Daten — Schlüssel sortiert, kompaktes JSON. Prüfen Sie sie, bevor Sie irgendetwas glauben. Die Bibliothek tut das für Sie, auch bei der Kopie im Cache, die ihrerseits an ihren Host gebunden ist und sich deshalb nicht von einer Seite auf eine andere kopieren lässt.

12.Die Signatur selbst prüfen

Nur nötig, wenn Sie die API direkt aufrufen. Bauen Sie die kanonische Form aus dem geparsten Objekt neu auf — nie aus den empfangenen Rohbytes, die abweichen können — und prüfen Sie dann die abgetrennte Ed25519-Signatur gegen unseren öffentlichen Schlüssel.

Unser öffentlicher Schlüssel

Ed25519, 32 rohe Bytes in base64. Er ist für jeden Autor und jedes Produkt derselbe.

/PTkKQpweo9XCLOS0+b0vgrecx7Ly/SsAuwTiA737Tw=

Die kanonische Form

Die Signatur deckt das Objekt donnees ab, serialisiert nach diesen vier Regeln, und nichts sonst. Eine davon falsch, und jede Signatur wirkt ungültig.

1. Schlüssel aufsteigend sortiert.
2. Keine Leerzeichen: weder nach den Doppelpunkten noch nach den Kommas.
3. Schrägstriche werden nicht maskiert.
4. Nicht-ASCII-Zeichen bleiben UTF-8, ohne Backslash-u-Maskierung.

Für die obige Antwort die genau signierten Bytes:

{"domaine":"exemple.fr","emis":1790687453,"essai":false,"hote":"boutique.exemple.fr","motif":"","ok":true,"quand":"","revalider":1790773853,"sursis":2592000}

function signature_valide(array $donnees, $signature, $publique)
{
    ksort($donnees);
    $corps = json_encode($donnees, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE);

    return sodium_crypto_sign_verify_detached(
        base64_decode($signature, true),
        $corps,
        base64_decode($publique, true)
    );
}

import { createPublicKey, verify } from 'node:crypto';

const publique = createPublicKey({
  key: Buffer.concat([Buffer.from('302a300506032b6570032100', 'hex'),
                      Buffer.from('/PTkKQpweo9XCLOS0+b0vgrecx7Ly/SsAuwTiA737Tw=', 'base64')]),
  format: 'der',
  type: 'spki',
});

const canonique = (d) =>
  JSON.stringify(Object.fromEntries(Object.keys(d).sort().map((k) => [k, d[k]])));

const valide = verify(null, Buffer.from(canonique(rep.donnees), 'utf8'),
                      publique, Buffer.from(rep.signature, 'base64'));

import base64, json
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey

publique = Ed25519PublicKey.from_public_bytes(base64.b64decode('/PTkKQpweo9XCLOS0+b0vgrecx7Ly/SsAuwTiA737Tw='))

canonique = json.dumps(rep['donnees'], sort_keys=True,
                       separators=(',', ':'), ensure_ascii=False)

publique.verify(base64.b64decode(rep['signature']), canonique.encode('utf-8'))

13.Gründe für eine Ablehnung

14.Testen, bevor Sie verkaufen

Ihr Autorenbereich gibt Ihnen für jedes Ihrer Produkte einen Entwicklungsschlüssel. Er funktioniert auf jeder Domain, öffnet nur Ihre eigenen Produkte und meldet immer essai — eine damit laufende Installation zeigt also einen Entwicklungshinweis und kann nie für eine verkaufte Kopie gehalten werden.

Um zu sehen, wie sich Ihr Produkt bei einer Ablehnung verhält, senden Sie einen Schlüssel, den es nicht gibt. Sie bekommen eine echte signierte Ablehnung, genau wie bei einem widerrufenen Schlüssel — so prüfen Sie Ihren Fehlerbildschirm, ohne irgendetwas zu widerrufen.

curl -X POST https://addonsmarket.com/api/licence \
     -H 'Content-Type: application/json' \
     -H 'User-Agent: MonProduit/1.0' \
     -d '{"cle":"cettecleNexistePas000000","url":"boutique.exemple.fr"}'

{"donnees":{"ok":false,"motif":"inconnue", …},"signature":"…"}

15.Was Sie Ihrem Käufer sagen müssen

Ihr Produkt sendet die Domain, auf der es läuft, an unseren Server. Das ist eine Verarbeitung personenbezogener Daten nach europäischem Recht, und Ihr Käufer muss davon wissen. Sagen Sie es in Ihrer Produktbeschreibung und in Ihrer eigenen Dokumentation. Wir bewahren die Domain auf, und die IP zwölf Monate lang, um Streitfälle zu klären; sonst nichts, und wir verkaufen nichts davon.