CodeMeterAct - Logismarket

CodeMeterAct
Erste Schritte
Version 1.3.
Copyright
Alle Rechte vorbehalten. Diese Dokumentation darf ohne schriftliche Genehmigung von WIBUSYSTEMS AG (auch nicht in Auszügen) vervielfältigt oder veröffentlicht werden, unabhängig
von der Art und Weise oder mit welchen Mitteln, elektronisch oder mechanisch, dieses
geschieht.
Alle in dieser Dokumentation enthaltenen Informationen wurden mit größter Sorgfalt
zusammengestellt. Dennoch können fehlerhafte Angaben nicht völlig ausgeschlossen werden.
WIBU-SYSTEMS AG haftet nicht für eventuelle Fehler oder deren Folgen. WIBU-SYSTEMS AG
behält sich Änderungen am Inhalt der Dokumentation ohne Ankündigung vor.
CodeMeter®, WIBU® und SmartShelter® sind eingetragene Warenzeichen von WIBUSYSTEMS AG. Alle anderen in dieser Dokumentation genannten Marken- und Produktnamen
sind Handelsnamen. Dienste, Warenzeichen und Firmennamen sind in der Regel durch ihren
Inhaber geschützt.
© Copyright 2008-2009 by WIBU-SYSTEMS AG
Rüppurrer Strasse 52-54 | D-76137 Karlsruhe
Tel.: +49-721-93172-0 | Fax: +49-721-93172-22
E-Mail: [email protected]
Firma
WIBU-SYSTEMS AG
Straße
Rüppurrer Straße 52-54
Plz, Ort
76137 Karlsruhe
Land
Deutschland
Autor(en)
Rüdiger Kügler
Wolfgang Völker
Email
[email protected]
[email protected]
Telefon
+49 721 93172 - 0
Version
1.3.
Veröffentlicht
29.01.2010
Status
Veröffentlicht
2 | 37
Inhalt
1
Voraussetzungen .................................................................................................................. 4
1.1
CodeMeter SDK ........................................................................................................... 4
1.2
Freischaltung der FSB.................................................................................................. 4
1.3
Lizenzdateien für CodeMeterAct ................................................................................ 10
2
Schützen einer Anwendung mit AxProtector ...................................................................... 11
3
Erstellen von eigenen CodeMeterAct Lizenzen .................................................................. 15
3.1
Prinzip der Aktivierung ............................................................................................... 15
3.2
Erstellen der Lizenzinformationsdatei ........................................................................ 16
3.3
Erstellen der Lizenzanforderungsdatei (Kundenseite) ............................................... 18
3.4
Erstellen der Lizenzaktualisierungsdatei .................................................................... 20
3.5
Einspielen der Lizenz (Kundenseite).......................................................................... 21
4
Aktualisieren von eigenen CodeMeterAct Lizenzen ........................................................... 23
5
Integration mit dem Softwareschutz-API (WUPI)................................................................ 24
6
5.1
Einleitung .................................................................................................................... 24
5.2
Integration einer einfachen Abfrage ........................................................................... 25
5.3
Verschlüsseln von Code-Fragmenten ........................................................................ 32
5.4
Zusätzliche Optionen.................................................................................................. 36
Das CodeMeter Kern-API für Spezialfälle .......................................................................... 37
3 | 37
1
Voraussetzungen
CodeMeterAct ist ein aktivierungsbasiertes Lizenzierungssystem, das in CodeMeter ab der
Version 4.0 enthalten ist. Um CodeMeterAct zu testen, benötigen Sie:
ein CodeMeter SDK 4.0 oder höher
eine FSB (Firm Security Box) mit Freischaltung für CodeMeterAct
zwei Lizenzdateien für CodeMeterAct
1.1 CodeMeter SDK
CodeMeterAct basiert auf dem seit über 5 Jahren bewährten Konzept von CodeMeter. Im
Gegensatz zu CodeMeter, bei dem die Lizenzen in einer Hardware, dem CmStick, gespeichert
werden, bestehen die Lizenzen bei CodeMeterAct aus Lizenzdateien, die an einen Rechner
gebunden – aktiviert – werden.
Im
Mittelpunkt
von
CodeMeter
und
CodeMeterAct steht dabei der CodeMeter
Runtime
Server
(CodeMeter.exe),
ein
universeller Lizenzmanager, der für Windows,
Mac OS X, Linux und Sun Solaris verfügbar ist.
Der CodeMeter Runtime Server stellt Ihnen die
Lizenzen zur Verfügung, ganz egal ob diese in
einem CmStick oder in einer Lizenzdatei
gespeichert sind.
Lizenzdateien werden dabei wie ein virtueller
CmStick angezeigt. Damit sind alle Features von
CodeMeter automatisch auch für CodeMeterAct
verfügbar. Das CodeMeter SDK 4.0 können Sie
gerne bei uns anfordern bzw. die Software dazu
von unserer Webseite herunterladen.
1.2 Freischaltung der FSB
Um Lizenzen für CodeMeterAct erstellen zu können, benötigen Sie eine FSB (einen speziell
programmierten CmStick, die Firm Security Box). Eine FSB für CodeMeter ist im SDK enthalten,
das Sie als Paket bereits erhalten haben (bzw. bei uns anfordern können). Diese FSB ist bereits
für CodeMeter, aber noch nicht für CodeMeterAct, freigeschaltet. Sollten Sie kein SDK mit einer
FSB besitzen, dann können wir Ihnen die Lizenz für CodeMeterAct in jeden beliebigen CmStick
übertragen und diesen damit zu einer FSB machen.
4 | 37
1.2.1 Erzeugung der Lizenzanforderungsdatei – CodeMeter SDK
Für die Freischaltung schicken Sie uns eine Lizenzanforderungsdatei. Diese erzeugen Sie im
CodeMeter Kontrollzentrum.
Öffnen Sie das CodeMeter Kontrollzentrum. Sollten Sie mehrere CmSticks angeschlossen
haben, dann wählen Sie bitte den gewünschten aus und klicken Sie dann auf
„Lizenzaktualisierung“.
Abbildung 1: Das CodeMeter Kontrollzentrum
Nun öffnet sich der CodeMeter Field Activation Service (CmFAS) Assistent.
Abbildung 2: CodeMeter Field Activation Service (CmFAS)
5 | 37
Wählen Sie „Lizenzanforderung erzeugen“.
Abbildung 3: CmFAS - Lizenzanforderung erzeugen
Wenn Sie einen CmStick verwenden, der bereits eine FSB ist, dann wählen Sie im nächsten
Schritt „Bestehende Lizenz erweitern“. Sie besitzen ja bereits eine CodeMeter Lizenz und
wollen diese um CodeMeterAct erweitern.
Abbildung 4: CmFAS - Bestehende Lizenz erweitern
6 | 37
Im nächsten Dialog wählen Sie den FIRM CODE 99 aus.
Abbildung 5: CmFAS - Auswahl des FIRM CODEs (99)
Bestimmen Sie im nun im Assistenten, wo Ihre Lizenzanforderungsdatei gespeichert werden
soll. Speichern Sie diese und schicken Sie sie bitte per Email an [email protected].
Abbildung 6: CmFAS - Dateinamen der Lizenzanforderungsdatei wählen
7 | 37
1.2.2 Erstellen der Lizenzanforderungsdatei – beliebiger CmStick
Falls Sie einen CmStick verwenden möchten, der noch keine FSB ist, dann wählen Sie im
Dialog „Option für die Lizenzanforderung“ (siehe Abbildung 3: CmFAS - Lizenzanforderung
erzeugen) anstelle „Bestehende Lizenz erweitern“; „Lizenz eines neuen Herstellers hinzufügen“.
Der neue Hersteller ist in diesem Fall die WIBU-SYSTEMS AG.
Abbildung 7: CmFAS - Lizenz eines neuen Herstellers hinzufügen
Geben Sie im nächsten Dialog als FIRM CODE die 99 ein.
Abbildung 8: CmFAS - FIRM CODE eingeben (99)
Bestimmen Sie im nächsten Dialog den Dateinamen und den Speicherort
Lizenzanforderungsdatei
(siehe
Abbildung
6:
CmFAS
Dateinamen
Lizenzanforderungsdatei wählen). Schicken Sie uns diese bitte per Email.
der
der
8 | 37
1.2.3 Einspielen der Lizenzaktualisierungsdatei
Passend für Ihren CmStick, erstellen wir Ihnen eine Lizenzaktualisierungsdatei. Diese schaltet
den CmStick als FSB für CodeMeterAct frei. Speichern Sie die Lizenzaktualisierungsdatei
(*.WibuCmRaU) auf Ihrem PC und starten Sie den CmFAS Assistenten erneut.
Wählen Sie im CmFAS Assistenten „Lizenzaktualisierung einspielen“.
Abbildung 9: CmFAS - Lizenzaktualisierung einspielen
Geben Sie im nächsten Dialog den Speicherort und den Dateinamen der erhaltenen
Lizenzaktualisierungsdatei an.
Abbildung 10: CmFAS - Lizenzaktualisierungsdatei auswählen
Klicken Sie auf „Anwenden“, und Ihr CmStick ist als FSB für CodeMeterAct freigeschaltet.
Mit dem gleichen Verfahren, mit dem wir Ihnen die Lizenz für CodeMeterAct in Ihren CmStick
übertragen haben, können Sie natürlich Ihre CodeMeter und Ihre CodeMeterAct Lizenzen
selbst an Ihre Kunden übertragen.
9 | 37
1.3 Lizenzdateien für CodeMeterAct
Nun benötigen Sie lediglich noch zwei Lizenzdateien für CodeMeterAct, bevor Sie starten
können.
Die „CmActFirm-5010.wbc“ ist die Lizenzdatei zwischen WIBU-SYSTEMS AG und Ihnen.
Diese enthält Ihren FIRM CODE, der in diesem Fall 5010 ist. Diese Datei ist analog zur
„CmFirm.wbc“, die Sie mit dem CodeMeter SDK für den FIRM CODE 10 bereits besitzen.
Die „CmActFI-5010.wbb“ ist eine leere Vorlage der Lizenzdatei, die Sie für Ihren Kunden
erstellen. Diese enthält wiederum den FIRM CODE 5010. Diese Datei gibt es nur bei
CodeMeterAct und nicht bei CodeMeter. Sie entspricht einem leeren CmStick.
Wenn Sie sich nach dem Testen von CodeMeterAct dafür entscheiden, CodeMeterAct zur
Lizenzierung Ihrer Software einzusetzen, dann erhalten Sie einen eigenen FIRM CODE. Der FIRM
CODE 5010 ist zum Testen für alle Kunden verfügbar und bietet Ihnen somit keine Sicherheit.
Jeder Inhaber eines CodeMeter SDKs mit der Freischaltung für CodeMeterAct kann Lizenzen
für den FIRM CODE 5010 erstellen.
Importieren Sie beide Lizenzdateien, indem Sie diese aus der Email auf Ihren PC speichern und
dann per Drag & Drop auf das CodeMeter Kontrollzentrum ziehen.
10 | 37
2
Schützen einer Anwendung mit AxProtector
AxProtector ist ein Werkzeug, das die fertige Anwendung
(Windows Anwendung, Windows Bibliothek, .NET
Assembly, Mac OS X Anwendung oder Java
Anwendung) nachträglich verschlüsselt und Ihnen einen
sicheren Schutz gegen Raubkopien und Reverse
Engineering bietet. Mit AxProtector integrieren Sie den
Schutz einfach – und ohne Programmierkenntnisse – in
Ihre Anwendung.
Sie nehmen einfach die kompilierte Anwendung und
verschlüsseln diese mit AxProtector. AxProtector fügt
selbstständig Code in Ihre Anwendung ein, der die
verschlüsselten Teile zur Laufzeit entschlüsselt.
Neben der Entschlüsselung enthält dieser Code auch
Überprüfungen der Integrität der Anwendung sowie
Erkennungsmechanismen für typische Hacker-Tools. Im Fall des Erkennens von Hacker-Tools
leitet AxProtector sofort Gegenmaßnahmen ein.
AxProtector finden Sie im CodeMeter Licensor Center. Im CodeMeter Licensor Center haben
wir alle Tools, die Sie für die Integration von CodeMeter und CodeMeterAct benötigen
zusammengefasst.
Abbildung 11: CodeMeter Licensor Center
Nach dem Start von AxProtector wählen Sie den Projekt-Typ aus (siehe oben). Dieser ist
abhängig von der Art Ihrer Anwendung.
11 | 37
Im folgenden Eingebefenster geben Sie bitte den Namen der Anwendung ein, die Sie schützen
möchten. Testen Sie dies doch mit einer kleinen eigenen „HelloWorld“-Anwendung oder mit
dem Windows Notepad.
Abbildung 12: AxProtector - Datei auswählen
AxProtector schlägt automatisch vor, die geschützte Anwendung im Unterverzeichnis
„protected“ zu speichern. Wenn Sie die geschützte Datei an einer anderen Stelle ablegen
möchten, dann können Sie dies gerne verändern.
12 | 37
Auf der nächsten Seite können Sie die verwendete Lizenz konfigurieren. AxProtector unterstützt
CodeMeter und CodeMeterAct. Wenn Sie das CodeMeterAct SDK installiert haben, d.h. wenn
Sie die CmActFirm-5010.wbc eingespielt haben, dann finden Sie auf dieser Seite eine
Checkbox für CodeMeterAct. Falls diese Checkbox nicht sichtbar ist, wiederholen Sie bitte das
Einspielen der CmActFirm-5010.wbc (siehe 1.3 Lizenzdateien für CodeMeterAct) und starten
Sie AxProtector erneut.
Abbildung 13: AxProtector - Lizenzkonfiguration
Zum Testen von CodeMeterAct tragen Sie als FIRM CODE 5010 und als PRODUCT CODE 13 ein.
Der FIRM CODE ist ein Code, den WIBU-SYSTEMS Ihnen zuweist. WIBU-SYSTEMS sorgt dabei
dafür, dass Ihr FIRM CODE eindeutig ist. Ihr FIRM CODE wird in Ihrer FSB gespeichert. Der FIRM
CODE 5010 ist ein Testcode für CodeMeterAct.
Den PRODUCT CODE können Sie frei wählen. Mit dem PRODUCT CODE können Sie verschiedene
Produkte oder verschiedene Module innerhalb eines Produktes freischalten. In einem CmStick
können Sie bis zu 3.800 verschiedene PRODUCT CODEs gleichzeitig freischalten, in einer
CodeMeterAct Lizenzdatei beliebig viele.
Falls Sie eine geschützte Anwendung erzeugen möchten, die CodeMeter und CodeMeterAct
gleichzeitig unterstützt, dann kreuzen Sie bitte beide Optionen an. Verwenden Sie in diesem
Fall bei CodeMeter als FIRM CODE 10 und als PRODUCT CODE 13. Eine Lizenz mit diesen
Optionen ist bereits im CmStick aus dem SDK enthalten. Die so geschützte Anwendung läuft
dann wahlweise mit einem Dongle oder mit einer Lizenzdatei.
Aus dem Wissen von FIRM CODE und PRODUCT CODE kann ein Hacker keine Rückschlüsse auf
die Verschlüsselung der Software ziehen. FIRM CODE und PRODUCT CODE sind die sichtbaren
13 | 37
Bestandteile einer CodeMeter bzw. CodeMeterAct Lizenz. Neben diesen enthält eine Lizenz
geheime, nicht auslesbare Schlüssel (im Falle von CodeMeterAct liegen diese Schlüssel
verschlüsselt in einer Lizenzdatei).
Stellen Sie sicher, dass Ihre FSB an den PC angeschlossen ist.
Bestätigen Sie die folgenden Seiten einfach mit „Weiter“ und klicken Sie auf der letzten Seite
auf „Fertigstellen“. Ihre Software ist nun mit CodeMeterAct verschlüsselt.
Auf den übersprungenen Seiten finden Sie Detaileinstellungen für den automatischen Schutz.
Hier können Sie zum Beispiel konfigurieren, ob und wie die Lizenz zur Laufzeit überprüft wird,
ob nach der Lizenz im Netzwerk gesucht werden soll und welche Warn- bzw. Fehlermeldungen
erscheinen sollen. Die Details zu diesen Einstellungen finden Sie im Handbuch.
Die Verschlüsselung der Software benötigt einige Sekunden. Dies liegt daran, dass mittels der
FSB verschiedene (standardmäßig 256) Sequenzen erzeugt werden, von denen zur Laufzeit
eine zufällig ausgewählt wird.
Damit erhöht sich der Schutzlevel, da nicht immer die gleichen Daten abgefragt werden. Da zur
Laufzeit nur eine Sequenz verwendet wird, ist das Starten der geschützten Anwendung
schneller als das Verschlüsseln.
Wechseln Sie mit dem Windows Explorer in das Verzeichnis, in das Sie die geschützte
Anwendung kopiert haben und starten Sie diese. Da noch keine Lizenz für FIRM CODE 5010 und
PRODUCT CODE 13 auf dem Rechner vorhanden ist, erhalten Sie jetzt eine Fehlermeldung.
Abbildung 14: Fehlermeldung "Starten ohne Lizenz"
14 | 37
3
Erstellen von eigenen CodeMeterAct Lizenzen
3.1 Prinzip der Aktivierung
Bei CodeMeterAct wird die Lizenzdatei an einen PC gebunden, sie wird aktiviert. Die
Aktivierung erfolgt über den Austausch von Dateien. Dies kann wahlweise manuell erfolgen
(z.B. per Email) oder automatisiert (z.B. per SOAP über einen Webservice). In diesem
Dokument wird die manuelle Aktivierung gezeigt.
Abbildung 15: Prinzip der Aktivierung
Um eine CodeMeterAct Lizenz an einen PC zu binden werden die folgenden Schritte
durchlaufen:
Sie legen das Bindungs-Schema fest. Zum Beispiel „Binde
Seriennummer“. Dies geschieht in der Lizenzinformationsdatei.
an
Festplatten-
Mittels der Lizenzinformationsdatei erzeugt Ihr Kunde eine Lizenzanforderungsdatei, die
die für das Bindungs-Schema relevanten Daten des PCs enthält. In unserem Beispiel ist
dies eine Kennung aus der Festplatten-Seriennummer.
Sie erstellen eine Lizenzaktualisierungsdatei für diesen Kunden. Diese enthält die Lizenz.
Die Lizenz ist dabei mit den Daten aus den Bindungs-Informationen verschlüsselt und
kann somit nur auf dem passenden PC installiert und verwendet werden.
Ihr Kunde spielt die Lizenzaktualisierungsdatei ein, besitzt damit die Lizenz und kann die
Software starten.
15 | 37
3.2 Erstellen der Lizenzinformationsdatei
Zuerst legen Sie das Bindungs-Schema fest. Dazu erzeugen Sie mit CmBoxPgm eine
Lizenzinformationsdatei.
Geben Sie den FIRM CODE an (in diesem Fall 5010, den Testcode für CodeMeterAct).
Geben Sie einen PRODUCT CODE an. Da wir den PRODUCT CODE 13 bereits in der CodeMeterAct
Demo-Lizenz verwendet haben, nehmen wir hier PRODUCT CODE 14. Den PRODUCT CODE
benötigen wir lediglich zur Unterscheidung auf dem PC des Kunden, ob „keine Lizenz“ oder
„eine nicht aktivierte Lizenz“ vorliegt. D.h. ein Aufruf der Software mit 5010:14 liefert den Fehler
200, wenn keine Lizenzdatei mit PRODUCT CODE 14 vorhanden ist, aber 261 wenn eine
Lizenzinformationsdatei vorliegt. Im zweiten Fall können Sie dann direkt eine Online-Aktivierung
starten.
Geben Sie den Dateinamen
„TemplateDisc.wbb“).
der
Lizenzinformationsdatei
an
(in
unserem
Beispiel
Geben Sie einen Namen für die Lizenzinformationsdatei an (in unserem Beispiel „Leerer
virtueller CmStick“). Dieser Name erscheint im CodeMeter Kontrollzentrum anstelle des
Namens des CmSticks.
Geben Sie eine Product-ID ein (in unserem Beispiel 0001). Über diese können Sie mit dem API
die passende Lizenzinformationsdatei identifizieren.
Wählen Sie ein Bindungs-Schema aus. Dieses kann aus Disk, Network, Bios und CPU
bestehen und gibt an, wie viele der Eigenschaften gleich bleiben müssen. Sonst wird eine
Reaktivierung notwendig. Details und weitere Bindungs-Schemata (None, Serial, …) finden Sie
im WhitePaper „Skalierbarer Softwareschutz“. Im Beispiel verwenden wir „D:1“, „nur an die
Festplatte binden“ und diese eine Eigenschaft darf sich nicht ändern.
Geben Sie an, für welche Betriebssysteme diese Lizenzinformationsdatei verwendet werden
kann. So können sowohl die Betriebsystemfamilien angeben (Linux, Mac OS und Windows), als
auch einzelne spezielle Versionen (z.B. Windows XP). Im Beispiel erstellen wir eine
Lizenzinformationsdatei, die unter Windows verwendet werden kann.
CmBoxPgm /f5010 /p14 /ca /lif:"TemplateDisc.wbb"
/lpn:"Leerer virtueller CmStick" /lpid:0001 /lfs:D:1 /los:win
Kommandozeile 1: Erzeugen einer Lizenzinformationsdatei
Die so erzeugte “TemplateDisc.wbb” liefern Sie nun an Ihren Kunden aus. Entweder geschieht
dies über Ihr Installationsprogramm automatisch, oder Sie schicken dem Kunden diese Datei
per Email. Im Installationsprogramm können Sie die Datei gleich automatisch bei CodeMeter
Runtime Server registrieren.
Im Falle des Versands per Mail spielt der Kunde diese ein, indem er die Datei einfach per Drag
& Drop auf das CodeMeter Kontrollzentrum zieht. Wahlweise kann die Lizenzinformationsdatei
auch im CodeMeter Kontrollzentrum über das Menü „Datei | Lizenz importieren“ eingespielt
werden.
16 | 37
Danach erscheint die Lizenzinformationsdatei als ein deaktivierter virtueller CmStick im
CodeMeter Kontrollzentrum.
Abbildung 16: Lizenzinformationsdatei im CodeMeter Kontrollzentrum
Der leere virtuelle CmStick besitzt eine temporäre Seriennummer. Im CodeMeter WebAdmin
können Sie auch sehen, welche Lizenzen im virtuellen CmStick vorhanden sind. Im Beispiel ist
dies die Lizenz 5010:14. Allerdings ist die Lizenz noch deaktiviert.
Deaktiviert bedeutet, die kryptographischen Schlüssel sind noch nicht vorhanden. Damit ist die
Lizenzinformationsdatei für einen Hacker nutzlos.
Abbildung 17: Deaktivierte Lizenz in einer Lizenzinformationsdatei
17 | 37
3.3 Erstellen der Lizenzanforderungsdatei (Kundenseite)
Über das CodeMeter Kern-API können Sie aus Ihrer Software heraus, bzw. aus der
Fehlermeldungs-DLL, eine Lizenzanforderungsdatei erstellen. Diese wird aus der
Lizenzinformationsdatei erstellt und enthält zusätzlich die Bindungs-Informationen vom PC des
Kunden.
Natürlich kann der Kunde die Lizenzanforderungsdatei auch mit dem CodeMeter
Kontrollzentrum selbst „von Hand“ erstellen. Dies erfolgt analog zur Erstellung einer
Lizenzanforderungsdatei für einen CmStick (siehe 1.2 Freischaltung der FSB).
Wählen Sie im CodeMeter Kontrollzentrum zuerst den virtuellen CmStick, den Sie aktivieren
möchten und klicken Sie auf „Lizenz aktivieren“.
Abbildung 18: Virtuellen CmStick im CodeMeter Kontrollzentrum wählen
Abbildung 19: CmFAS - Willkommen Dialog bei CodeMeterAct
18 | 37
Wählen Sie „Lizenzanforderung erzeugen“.
Abbildung 20: CmFAS - Bestehende Lizenz erweitern
Bestimmen Sie nun, wo Ihre Lizenzanforderungsdatei gespeichert werden soll. In der Regel
wird der Kunde Ihnen diese Datei nun per Email schicken.
Abbildung 21: CmFAS - Dateinamen der Lizenzanforderungsdatei wählen
Im Gegensatz zur Erstellung einer Lizenzanforderungsdatei für einen CmStick umfasst die
Prozedur für CodeMeterAct weniger Dialoge. Dies liegt daran, dass es bei CodeMeterAct nur
einen FIRM CODE pro Lizenzdatei gibt (und damit eine Lizenzdatei pro Softwarehersteller),
während sich mehrere Software-Hersteller einen CmStick teilen können.
19 | 37
3.4 Erstellen der Lizenzaktualisierungsdatei
Aus der erhaltenen Lizenzanforderungsdatei erzeugen Sie nun die Lizenzaktualisierungsdatei,
die die Lizenzen auf den PC des Kunden freischaltet. Die Lizenzaktualisierungsdatei enthält
dabei die Schlüssel für die Lizenz. Diese sind für die Bindungs-Informationen des PCs des
Kunden verschlüsselt und können somit nur auf diesem PC entschlüsselt und verwendet
werden.
Die Lizenzaktualisierungsdatei erstellen Sie wiederum mit CmBoxPgm. Wahlweise können Sie
dies auch mit in Q1/2009 erscheinenden CodeMeter License Central durchführen. Details siehe
Handbuch.
Die Optionen sind zum großen Teil identisch mit denen aus der Lizenzinformationsdatei.
Zwingend gleich sein müssen FIRM CODE (/f…), Product-ID (/lpid:…), Bindungs-Schema
(/lfs:…) und Betriebssysteme (/los:…).
Der FIRM ITEM TEXT (/ft:…) und der Name des virtuellen CmSticks (/lpn:…) können geändert
werden. Mit /laf:… geben Sie die Lizenzanforderungsdatei an und mit Komma getrennt den
Namen der Lizenzaktualisierungsdatei, die Sie erstellen möchten.
Lizenzeinträge und deren Eigenschaften können beliebig hinzugefügt oder geändert werden. Im
Beispiel ist für PRODUCT CODE 14 lediglich der PRODUCT ITEM TEXT ergänzt und die LICENSE
QUANTITY ist auf 1 gesetzt worden. Die LICENSE QUANTITY steht für die Anzahl der gleichzeitig
benutzbaren Lizenzen, speziell auch als Floating Lizenz im Netzwerk.
CmBoxPgm /f5010 /ft:"CodeMeterAct Demo Firm Item" /Cu
/p14 /pt:"Meine Erste CodeMeterAct Lizenz" /plq1 /ca
/laf:"LicenseRequest.WibuCmRaC","Activation.WibuCmRaU"
/lpn:"Meine erste Lizenz" /lpid:0001 /lfs:D:1 /los:win
Kommandozeile 2: Erzeugen einer Lizenzaktualisierungsdatei mit dem PRODUCT CODE 14
Sie könnten aber auch z.B. eine zeitliche Befristung für 30 Tage ab ersten Start einfügen
(/pup:30) oder einen UNIT COUNTER mit 10 Einheiten zum herunterzählen (/puca10). Beides
fügen Sie optional vor dem /ca ein.
CmBoxPgm /f5010 /ft:"CodeMeterAct Demo Firm Item" /Cu
/p14 /pt:"Meine Erste CodeMeterAct Lizenz" /pup:30 /puca30 /plq1 /ca
/laf:"LicenseRequest.WibuCmRaC","Activation.WibuCmRaU"
/lpn:"Meine erste Lizenz" /lpid:0001 /lfs:D:1 /los:win
Kommandozeile 3: Erzeugen einer Lizenzaktualisierungsdatei mit dem PRODUCT CODE 14 und
weiteren Optionen
Falls Sie einen weiteren PRODUCT CODE gleich mit hinzufügen wollen, dann können Sie die
Daten von /p… bis /ca einfach duplizieren.
CmBoxPgm /f5010 /ft:"CodeMeterAct Demo Firm Item" /Cu
/p14 /pt:"Meine Erste CodeMeterAct Lizenz" /plq1 /ca
/p15 /pt:"Meine Zweite CodeMeterAct Lizenz" /plq1 /ca
/laf:"LicenseRequest.WibuCmRaC","Activation.WibuCmRaU"
/lpn:"Meine erste Lizenz" /lpid:0001 /lfs:D:1 /los:win
Kommandozeile 4: Erzeugen einer Lizenzaktualisierungsdatei mit den PRODUCT CODEs 14 und 15
20 | 37
3.5 Einspielen der Lizenz (Kundenseite)
Analog zum Erstellen der Lizenzanforderungsdatei, kann die Lizenzaktualisierungsdatei
entweder per CodeMeter Kern-API oder mit dem CodeMeter Kontrollzentrum eingespielt
werden.
Der Kunde wählt den CmStick aus, klickt auf „Lizenz aktivieren“ und klickt im „WillkommenBildschirm“ auf „Weiter“ (siehe 3.3).
Nun wählen Sie „Lizenzaktualisierung einspielen“.
Abbildung 22: CmFAS - Lizenzaktualisierung einspielen
Wählen Sie im nächsten Dialog den Namen der Lizenzaktualisierungsdatei, die Sie einspielen
wollen.
Abbildung 23: CmFAS - Dateinamen der Lizenzaktualisierungsdatei eingeben
Klicken Sie nun auf „Anwenden“ und die Lizenzaktualisierungsdatei wird eingespielt.
21 | 37
Nach dem erfolgreichen Einspielen der Lizenzaktualisierungsdatei haben Sie die Lizenz
5010:14 in dem virtuellen CmStick „Meine erste Lizenz“ aktiviert. Im CodeMeter Kontrollzentrum
erscheint dies jetzt als ein aktivierter neuer virtueller CmStick.
Abbildung 24: CodeMeter Kontrollzentrum mit aktiviertem virtuellen CmStick
Mit dem CodeMeter WebAdmin können Sie die gesetzten Lizenzoptionen einfach überprüfen.
Abbildung 25: Lizenz 5010:14 im CodeMeter WebAdmin
LICENSE QUANTITY = 1 bedeutet übrigens, dass dies eine Floating Lizenz im Netzwerk ist. Mit
CodeMeterAct können auch Netzwerklizenzen realisiert werden. Wählen Sie bei der Erstellung
der Lizenzaktualisierungsdatei /plq5, um eine 5-er Netzwerklizenz zu erzeugen. Optional
können Sie die LICENSE QUANTITY auch auf 0 setzen. Dann kann die Lizenz nur lokal verwendet
werden, d.h. an dem PC, auf den die Lizenz gebunden ist.
Der virtuelle CmStick hat nun seine endgültige Seriennummer erhalten. Diese wird über einen
Zähler in Ihrer FSB erzeugt, so dass jeder Ihrer Kunden eine andere Seriennummer erhält.
22 | 37
4
Aktualisieren von eigenen CodeMeterAct Lizenzen
Die Aktualisierung (d.h. das Hinzufügen, Ändern und Löschen von Lizenzeinträgen, bzw. deren
Eigenschaften) und die Reaktivierung (die erneute Freischaltung wenn sich die BindungsInformationen geändert haben) erfolgt auf dem gleichen Weg wie die erste Aktivierung der
Lizenz.
Der Kunde erzeugt eine Lizenzanforderungsdatei.
Sie erzeugen daraus eine Lizenzaktualisierungsdatei.
Der Kunde spielt diese ein und kann Ihnen wahlweise eine Quittung zurückschicken.
Die Kommandozeilen-Optionen sind hier analog zur ersten Aktivierung der Lizenz. Sie können
Eigenschaften oder weitere Lizenzeinträge (andere PRODUCT CODEs) wahlweise hinzufügen.
Bitte beachten Sie, dass Sie die Lizenzaktualisierungsdatei bei der Aktualisierung einer Lizenz
nicht auf dem Rechner erstellen können, an den die Lizenz gebunden sein soll. Diese
Einschränkung ist nur beim Testen relevant, da Sie in der Praxis die Lizenz ja für Ihren Kunden
und nicht für sich selbst erzeugen.
23 | 37
5
Integration mit dem Softwareschutz-API (WUPI)
5.1 Einleitung
Mit unserem Softwareschutz-API WUPI (Wibu Universal Protection Interface) bieten wir Ihnen
ein mächtiges Werkzeug, um Ihre Software individuell gegen Raubkopien zu schützen.
Sie können mit WUPI die folgenden Anwendungsfälle abbilden:
Gleichzeitige einfache Verwendung von CodeMeter (Dongles) und CodeMeterAct
(Aktivierung).
Freischalten von einzelnen Modulen in einer Anwendung
Integration von Lizenzabfragen, ohne dass Sie sich mit den kryptographischen
Grundlagen beschäftigen müssen
Ständige Verbesserung des Schutzes bei jedem neuen Release Ihrer Software
Verschlüsseln von Code-Fragmenten zur Erhöhung des Schutzlevels
Implementierung von Pay-Per-Use Funktionalitäten (Herunterzählen eines Zählers bei
einer bestimmten Aktion)
Implementierung von Anti-Debug-Maßnahmen
Zugriff auf die Lizenz, die von AxProtector belegt wurde
Um dies zu erzielen, integrieren Sie die WUPI Funktionen in Ihre Software. Diese liegen in der
WupiEngine32.dll. Dies ist eine Dummy-DLL, die keine Funktionalität zur Verfügung stellt.
Vor der Auslieferung bearbeiten Sie die zu schützende Anwendung dann noch mit IxProtector.
IxProtector ist in AxProtector integriert.
Abbildung 26: Nachbearbeiten der zu schützenden Software mit AxProtector / IxProtector
24 | 37
IxProtector führt die folgenden Schritte durch:
Austausch der WupiEngine32.dll gegen eine statische Bibliothek (dies erhöht die
Sicherheit des Schutzes)
Hinzufügen von kryptographischen Abfragen in Ihre Software (Mit jeder neuen Version
von AxProtector werden hier Änderungen und Verbesserungen vorgenommen. Damit
müssen Sie die Software einfach nur mit AxProtector neu verschlüsseln, um den Schutz
zu verbessern. Sie müssen nicht neu kompilieren.)
Verschlüsselung der Code-Fragmente
Implementierung der eigentlichen Lizenzierungsoptionen (FIRM CODE und PRODUCT
CODE)
Wenn Sie IxProtector und AxProtector gleichzeitig verwenden, werden zusätzlich die folgenden
Schritte durchgeführt:
Verschlüsselung der kompletten Anwendung
Hinzufügen einer periodischen Überprüfung der Lizenz (Runtime-Check)
5.2 Integration einer einfachen Abfrage
Im Folgenden wird die Integration anhand einer kleinen Delphi-Anwendung gezeigt.
Die Anwendung umfasst einen Button. Dieser ruft die Funktion „Funtcion1“ auf, die wir separat
schützen möchten.
// Hier steht die eigentliche Funktionalität
procedure Function1;
begin
ShowMessage('Ich bin Funktion 1');
end;
// Hier wird die eigentliche Funktionalität aufgerufen
procedure TfrmMain.btnFunction1Click(Sender: TObject);
begin
Function1;
end;
Quellcode 1: Originale Anwendung ohne Schutz
Eine einfache Abfrage realisieren Sie mit WupiCheckLicense. Um die WupiEngine32.dll
einzubinden muss die Unit „WupiIxapId“ eingebunden werden. Unter C/C++ verwenden Sie
bitte die wibuixap.h. Für Visual Basic (6.0) steht Ihnen eine WibuIxap.bas zur Verfügung. Zur
Integration unter weiteren Programmiersprachen kontaktieren Sie bitte unseren Support
([email protected]).
Nun wird vor dem Aufruf der zu schützenden Funktion WupiCheckLicense aufgerufen. Der
Rückgabewert von WupiCheckLicense ist 1, wenn die Lizenz vorhanden ist und 0, wenn die
Lizenz nicht vorhanden ist. In diesem Fall geben wir eine Fehlermeldung aus (siehe Quellcode
„ShowError“).
Als Parameter erwartet WupiCheckLicense eine Zahl. Diese Zahl ist ein Platzhalter für die
Lizenzoptionen (FIRM CODE und PRODUCT CODE), der später vom IxProtector durch eine
Lizenzliste ersetzt wird. Im Beispiel verwenden wir die „1“.
25 | 37
uses WupiIxapId;
// Fehlerausgabe
procedure ShowError;
begin
ShowMessage('FEHLER: Lizenz nicht vorhanden!');
end;
// Hier steht die eigentliche Funktionalität
procedure Function1;
begin
ShowMessage('Ich bin Funktion 1');
end;
// Hier wird die eigentliche Funktionalität aufgerufen
procedure TfrmMain.btnFunction1Click(Sender: TObject);
begin
// Überprüfen ob die Lizenz mit ID = 1 verfügbar ist
if (WupiCheckLicense(1) = 1) then begin
Function1;
end else begin
ShowError;
end;
end;
Quellcode 2: Integration einer einfachen Lizenzabfrage
Nach dem Kompilieren der Anwendung läuft die Funktion „Function1“, denn die eigentliche
Funktionalität, d.h. die Abfrage, muss erst noch von IxProtector hinzugefügt werden.
Wir starten dazu AxProtector und wählen als Projekttyp „Nur IxProtector“ auf der Seite
„Erweitert“.
Abbildung 27: Projekttyp "Nur IxProtector"
In diesem Fall fügt AxProtector die für WUPI benötigte Funktionalität zu Ihrer Software hinzu,
verschlüsselt die gesamte Anwendung aber nicht zusätzlich.
26 | 37
Sie können auch ein normales Projekt von der Standardseite verwenden (Windows 32-bit
Anwendung). Dann implementiert AxProtector automatisch die WUPI Funktionen und fügt die
Verschlüsselung der ganzen Anwendung zusätzlich noch hinzu. AxEngine (die Runtime von
AxProtector) belegt dann die entsprechende Lizenz beim Starten der geschützten Software und
entschlüsselt damit die ganze Anwendung.
Für höchste Sicherheit verwenden Sie bitte beides, WUPI und die automatische
Verschlüsselung der ganzen Anwendung. Zum Testen bleiben wir bei „Nur IxProtector“.
Wählen Sie nun im ersten Eingabefenster die kompilierte Anwendung aus.
Abbildung 28: Nur IxProtector - Datei auswählen
27 | 37
Auf der folgenden Seite bestimmen Sie, wie Fehler verarbeitet werden.
Abbildung 29: Nur IxProtector - Fehlermeldungen
Wenn Sie hier „Unterdrücke IxProtector Fehlermeldungen“ wählen, dann kümmern Sie sich
selbst in Ihrer Software um das Fehlerhandling. Wenn Sie diese Option nicht setzen, dann
kommt im Falle eines fehlgeschlagenen WUPI Aufrufs die Fehlermeldung aus AxEngine.
28 | 37
Stellen Sie bitte auf der nächsten Seite sicher, dass „IxProtector aktivieren“ angekreuzt ist.
Diese Funktion sorgt dafür, dass AxProtector die WupiEngine32.dll ersetzt und die WUPI
Funktionalität hinzufügt.
Abbildung 30: Nur IxProtector - Erweiterte Optionen
29 | 37
Auf der nächsten Seite definieren Sie, was die Platzhalter (in unserem Falle die „1“) bedeuten
sollen. Wenn Sie ein Projekt mit der Verschlüsselung der ganzen Anwendung wählen, dann
erscheinen als ID = 0 die Lizenzoptionen, die AxEngine beim Starten der Anwendung
verwendet. Mit dem Platzhalter 0, können Sie dann in Ihrer Software auch auf die von AxEngine
belegte Lizenz zugreifen.
Im Falle eines „Nur IxProtector“ Projektes steht Ihnen der Platzhalter 0 nicht zur Verfügung. Die
AxEngine belegt beim Starten der geschützten Software ja keine Lizenz.
Abbildung 31: Nur IxProtector - Lizenzlisten
Klicken Sie hier auf „Hinzufügen“, um einen neuen Platzhalter zu erstellen.
30 | 37
Im Dialog „Lizenzliste bearbeiten“ weisen Sie dem Platzhalter ID = 1 nun die entsprechenden
Lizenzen zu. Dabei können einem Platzhalter mehrere Lizenzen zugewiesen werden. Dies
bezeichnen wir als Lizenzliste.
Abbildung 32: Lizenzliste 1 erstellen
AxEngine geht dann alle Lizenzen von oben nach unten durch und verwendet die erste, die
verfügbar ist. Ist keine Lizenz aus der Liste verfügbar, dann liefert AxEngine einen Fehler
zurück.
Durch dieses Verhalten können Sie auf einfache Art und Weise eine Anwendung erzeugen, die
sowohl die Hardware (CodeMeter) als auch die Aktivierung (CodeMeterAct) unterstützt. Sie
können dies sogar noch nachträglich nach dem Kompilieren ändern.
In unserem Beispiel definieren wir als ID = 1 eine Lizenzliste aus CodeMeter mit 10:16 und
CodeMeterAct mit 5010:16.
Bestätigen Sie den Dialog mit „Ok“.
Sie gelangen nun zur Seite „IxProtector Optionen“. Diesen Dialog überspringen wir in unserem
Beispiel und klicken auf der letzten Seite auf „Fertigstellen“.
Starten Sie nun die geschützte Anwendung. Da weder die Lizenz CodeMeter 10:16, noch die
Lizenz CodeMeterAct 5010:16 vorhanden ist, liefert der Aufruf der Funktion einen Fehler. In
unserem Delphi-Beispiel ist dies unsere MessageBox.
Abbildung 33: Fehlermeldung
Erzeugen Sie sich nun einer der beiden möglichen Lizenzen (10:16 oder 5010:16) und starten
Sie die Funktion noch einmal. Sobald die Lizenz vorhanden ist, läuft die Funktion.
31 | 37
5.3 Verschlüsseln von Code-Fragmenten
Mehr Sicherheit als eine einfache Abfrage bietet natürlich das Entschlüsseln von Funktionen zur
Laufzeit.
Dazu ändern wir unseren Quelltext wie folgt:
Vor dem Aufruf der Funktion „Function1“ entschlüsseln wir die Funktion mit
WupiDecryptCode. Dabei wird wiederum ein Platzhalter (die „1“) verwendet. Nach dem
Aufruf der geschützten Funktion wird diese mit WupiEncryptCode wieder verschlüsselt.
Damit AxProtector die Funktion „Function1“ finden kann, müssen Sie diese noch
exportieren. AxProtector findet die Funktion dann über die Exporttabelle.
Natürlich löscht AxProtector die Funktion nach dem Verschlüsseln des passenden CodeFragments wieder aus der Exporttabelle.
uses WupiIxapId;
// Fehlerausgabe
procedure ShowError;
begin
ShowMessage('FEHLER: Lizenz nicht vorhanden!');
end;
// Hier steht die eigentliche Funktionalität
procedure Function1;
begin
ShowMessage('Ich bin Funktion 1');
end;
// Hier wird die eigentliche Funktionalität aufgerufen
procedure TfrmMain.btnFunction1Click(Sender: TObject);
begin
// Entschlüsseln der Funktion mit ID = 1
if (WupiDecryptCode(1) = 1) then begin
// Aufruf der entschlüsselten Funktion
Function1;
// Wieder verschlüsseln
WupiEncryptCode(1);
end else begin
ShowError;
end;
end;
// Exportieren, damit AxProtector die Funktion findet
exports
Function1;
Quellcode 3: Verschlüsselung von Code-Fragmenten
32 | 37
Zur Kontrolle, ob die Funktion „Function1“ wirklich exportiert wurde können wir uns dies im
„Dependency Walker“ (ein kostenloses Tool zum freien Download) anschauen. Neben der
Deklaration der Funktion „Function1“ als Export kann man im Dependency Walker auch sehen,
dass die geschützte Anwendung die WupiEngine32.dll importiert.
Abbildung 34: Dependency Walker - Exportierte Funktion "Function1", Import der WupiEngine32.dll
Nach dem Kompilieren der Anwendung wechseln Sie zu AxProtector. Übernehmen Sie alle
Einstellungen aus dem vorherigen Projekt und gehen jetzt auf die Seite „IxProtector Optionen“.
Klicken Sie auf „Hinzufügen“.
Im Dialog „Funktion hinzufügen“ geben Sie jetzt den Namen der zu verschlüsselnden Funktion
ein, so wie er exportiert wurde.
AxProtector disassembliert Ihre Anwendung und erkennt die Länge der Funktion automatisch.
Wenn Sie 100% als Länge angeben, wird die Funktion komplett verschlüsselt. Falls Sie eine
Zahl ohne das „%“-Zeichen eingeben, dann verschlüsselt AxProtector genau diese Anzahl an
Bytes. Wenn Sie die Anzahl an Bytes direkt eingeben, dann sollten Sie sicherstellen, dass die
Funktion nicht kürzer ist als Sie angegeben haben.
Hier definieren Sie auch den Platzhalter (ID = 1). Beachten Sie, dass es IDs für Lizenzlisten und
IDs für Funktionen gibt. Bei WupiCheckLicense wird eine Lizenzliste als Platzhalter erwartet,
bei WupiDecryptCode eine Funktion. Eine komplette Aufstellung der Parameter aller WUPI
Funktionen finden Sie in der Hilfe.
Weisen Sie als letztes der Funktion „Function1“ die Lizenzliste „1“ zu. Damit geben Sie an, mit
welchem FIRM CODE(s) und PRODUCT CODE(s) diese Funktion verschlüsselt werden soll.
Abbildung 35: Funktion hinzufügen
33 | 37
Bestätigen Sie den Dialog mit „OK“. Die IxProtector Seite sollte nun wie folgt aussehen.
Abbildung 36: Funktionsverschlüsselung mit dem IxProtector
Verschlüsseln Sie nun die Anwendung und starten Sie diese.
Wenn die passende Lizenz vorhanden ist, dann wird die Funktion „Function1“ zuerst
entschlüsselt, dann ausgeführt und danach wieder verschlüsselt.
Abbildung 37: Funktion „Function1“ geht
Für einen guten Softwareschutz sollten Sie dies mit vielen Funktionen an vielen verschiedenen
Stellen realisieren.
Sie können den unterschiedlichen Funktionen dabei auch unterschiedliche Lizenzlisten
zuweisen. Somit setzen Sie einen modularen Softwareschutz um.
Wenn Sie nur die Sicherheit verbessern möchten, aber keine zusätzlichen Module verwenden,
dann nutzen Sie einfach die Lizenzliste „0“. Diese wurde von AxProtector für die
Verschlüsselung der kompletten Anwendung definiert und kann von Ihnen mittels WUPI
„mitbenutzt“ werden.
34 | 37
5.3.1 Hinter die Kulissen geschaut – Verschlüsselung im Detail
Mit einem Hex-Editor können Sie vergleichen, was verschlüsselt wurde.
Abbildung 38: Verschlüsselte Funktion im Hex-Editor
Diesen Vergleich kann der Hacker natürlich nicht durchführen:
Er besitzt die unverschlüsselte Anwendung nicht.
Wenn Sie AxProtector zusätzlich um die Anwendung gelegt haben, dann ist auch der
Rest der Anwendung verschlüsselt und damit unterschiedlich zum unverschlüsselten
Original.
Die exportierte Funktion „Function1“ wurde aus der Export-Tabelle gelöscht und gibt
damit keinen Hinweis auf die verschlüsselten Funktionen.
Da die Funktion „Function1“ sehr klein und überschaubar ist, ist auch nur wenig Code
verschlüsselt. Das Original beginnt mit B8 xx xx xx xx. Der Wert xx xx xx xx wird in Register
EAX geschrieben. Dieser Wert ist eine Adresse, die vom Windows-Loader relokiert werden
kann. D.h. diese Adresse wird von Windows beim Laden der Anwendung verändert falls die
Anwendung an eine andere Startadresse geladen wird. Dies tritt vor allem bei Bibliotheken
(DLLs) auf. Daher wird diese Stelle vom Verschlüsseln ausgenommen.
Der nächste Befehl E8 xx xx xx xx ruft die MessageBox Funktion auf. Der letzte Befehl C3 ist
das Return, mit welchem die Funktion „Function1“ beendet wird. Die Funktion ist also genau 11
Bytes lang. Im Binärvergleich sehen wir, dass alle nicht relokierbaren Stellen (7 Bytes) der
Funktion „Function1“ damit verschlüsselt sind.
35 | 37
Ein Blick in den Dependency Walker zeigt, dass die Funktion „Function1“ nicht mehr in der
Exporttabelle steht. Auch der Verweis auf die WupiEgine32.dll wurde von AxProtector gelöscht.
Anstelle der DLL wird nun die statisch gelinkte Bibliothek verwendet.
Abbildung 39: Dependency Walker - Geschützte Anwendung
5.4 Zusätzliche Optionen
WUPI bietet Ihnen neben einfachen Abfragen und der Verschlüsslung von Code-Fragmenten
weitere nützliche Funktionen. Details dazu finden Sie im Handbuch und in der Online Hilfe des
Softwareschutz-APIs.
Funktionen zur Lizenzverwaltung:
WupiAllocateLicense
WupiCheckLicense
WupiFreeLicense
Funktion um Informationen abzufragen:
WupiQueryInfo
Funktionen zur Verschlüsselung von Code-Fragmenten:
WupiDecryptCode
WupiEncryptCode
Debugger-Check aus AxProtector:
WupiCheckDebugger
Herunterzählen von Zählern:
WupiDecreaseUnitCounter
Übergang zum CodeMeter Kern-API (Core-API):
WupiGetHandle
36 | 37
6
Das CodeMeter Kern-API für Spezialfälle
Mit AxProtector und WUPI (inklusive der Verschlüsselung von Code-Fragmenten durch
IxProtector) können Sie einen sicheren Softwareschutz realisieren. Das CodeMeter Kern-API
benötigen Sie nur in Ausnahmefällen.
Das Kern-API ist für CodeMeter und CodeMeterAct nahezu gleich. Sie verwenden für
CodeMeterAct lediglich einen anderen FIRM CODE als für CodeMeter. Da der FIRM CODE aber in
die Verschlüsselung eingeht, ist klar, dass CodeMeter und CodeMeterAct keine kompatible
Verschlüsselung haben. D.h. wenn Sie beides gleichzeitig unterstützen möchten und Daten
(oder Code-Fragmente) verschlüsselt in der Software ablegen wollen, müssen Sie dies zweimal
machen, einmal für CodeMeter und einmal für CodeMeterAct. Je nachdem, welche Lizenz Sie
zur Laufzeit finden, verwenden Sie dann die einen oder die anderen verschlüsselten Daten.
Genau diese Verwaltung erledigt WUPI automatisch für Sie.
Der Einsatz des Kern-API ist zum Beispiel sinnvoll, wenn Sie weitere Informationen (den
PRODUCT ITEM TEXT) aus der Lizenz auslesen wollen. Dann holen Sie sich mit WupiGetHandle
ein Handle auf das Kern-API und lesen mit CmGetInfo den Text aus.
Weitere Details zum Einsatz des Kern-API finden Sie im Handbuch und in der Online Hilfe.
37 | 37