<\/p>\n
Wenn Sie eine Anwendung programmieren und später als Lösung verkaufen möchten, müssen Sie auf irgendeine Weise sicherstellen, dass nur der jeweilige Käufer damit arbeiten kann. Anderenfalls passiert es leicht, dass dieser die Anwendung an andere Nutzer weitergibt – vielleicht sogar ohne das Bewusstsein, dass er den Hersteller der Software um seinen Lohn bringt. In diesem Beitrag stellen wir Ihnen eine Lösung vor, mit der Sie Ihre Anwendungen vor der Weitergabe an Dritte schützen – und das sogar mit zeitlicher Begrenzung.<\/b><\/p>\n
Bei der in diesem Beitrag beschriebenen Lösung gehen wir zunächst davon aus, dass der Benutzer sich eine Anwendung aus dem Internet herunterlädt oder diese per E-Mail von Ihnen erhält.<\/p>\n
Nach der Installation soll die Anwendung beim ersten Start prüfen, ob der Benutzer einen Satz von Registrierungsdaten eingegeben hat, die aus einem Benutzernamen und einem Registrierungsschlüssel bestehen.<\/p>\n
Ist dies geschehen und sind die Registrierungsdaten gültig, sollen diese Daten irgendwo in der Anwendung gespeichert werden und die Anwendung starten.<\/p>\n
Bei jedem folgenden Aufruf liest die Anwendung die gespeicherten Registrierungsdaten automatisch aus und bricht den Start entweder ab oder führt die Anwendung aus – je nachdem, ob die Registrierungsdaten noch gültig sind.<\/p>\n
Bindung des Registrierungsschlüssels an den Benutzernamen<\/p>\n
Damit der Registrierungsschlüssel nicht von beliebigen Benutzern verwendet werden kann, wird dieser mindestens auf Basis des Benutzernamens erstellt. Für die Verschlüsselung des Namens und somit die Erstellung des Registrierungsschlüssels verwenden wir die in der Klasse clsCrypt <\/b>enthaltenen Algorithmen etwa zum Berechnen eines SHA1<\/b>-verschlüsselten Ausdrucks (Quellenangabe siehe Beispieldatenbank).<\/p>\n
SHA<\/b> steht für Secure Hash Algorithm<\/b>. Dieser Algorithmus soll einen eindeutigen Prüfwert etwa für eine Zeichenkette liefern, also einen Wert, der vom Inhalt der Zeichenkette abhängt.<\/p>\n
Wenn Sie also sicherstellen möchten, dass die Anwendung nur von einem Benutzer verwendet wird, der als Benutzername seinen Namen und als Registrierungsschlüssel den Hash-Wert einsetzt, brauchen Sie nur einen solchen Wert zu berechnen und später beim Start der Anwendung zu prüfen, ob die Kombination dieser beiden Werte zusammenpasst.<\/p>\n
Den Aufruf der Methode GetSHA1 <\/b>dieser Klasse haben wir wie in Listing 1<\/a><\/span> im Modul mdlTools <\/b>gekapselt.<\/p>\n Listing 1: Aufruf der Verschlüsselungsfunktionen der Klasse clsCrypt<\/p>\n Im Direktfenster testen Sie diese Funktion etwa so:<\/p>\n Angenommen, Sie hätten einem Klaus Müller diese Kombination aus Benutzername und Registrierungsschlüssel geschickt, muss er diese beim ersten Start einer Anwendung eingeben.<\/p>\n Die Kombination wird dann irgendwo in der Datenbank gespeichert, damit der Benutzer diese beim nächsten Start nicht erneut eingeben muss. Dies könnte beispielsweise in einer eigens dafür eingerichteten Tabelle geschehen. Diese nennen Sie tblRegistrierung <\/b>und legen die beiden Felder Benutzername <\/b>und Registrierungsschluessel <\/b>an, sodass die Tabelle wie in Bild 1 aussieht.<\/p>\n Bild 1: Tabelle zum Speichern der Benutzerdaten<\/span><\/b><\/p>\n Formular beim Öffnen anzeigen<\/b><\/p>\n Nach dieser Vorbereitung benötigen wir einen Ort, an dem wir die Prüfung der Benutzerdaten durchführen – sofern diese überhaupt bereits vorliegen. Dafür legen Sie ein Formular an, das an die Tabelle tblRegistrierung <\/b>gebunden ist und den Namen frmStart <\/b>erhält. Legen Sie dieses Formular in den Access-Optionen als Startformular fest, sodass dieses gleich nach dem Start der Anmeldung erscheint.<\/p>\n Das Formular enthält vier Steuerelemente: zwei Textfelder namens txtBenutzername <\/b>und txtRegistrierungsschluessel<\/b>, die an die beiden Felder der Datenherkunft gebunden sind, sowie zwei Schaltflächen namens cmdOK <\/b>und cmdAbbrechen<\/b> (s. Bild 2).<\/p>\n Bild 2: Formular zur Eingabe der Benutzerdaten<\/span><\/b><\/p>\n Die Schaltfläche cmdAbbrechen <\/b>soll die Eingabe der Benutzerdaten abbrechen und die Anwendung schließen. Dafür hinterlegen Sie für diese Schaltfläche die folgende Prozedur:<\/p>\n Stellen Sie außerdem die Eigenschaft Abbrechen <\/b>der Schaltfläche auf den Wert Ja <\/b>ein. Dies sorgt dafür, dass die Anwendung auch beim Betätigen der Escape<\/b>-Taste geschlossen wird. Das Prüfen der Benutzerdaten erledigt eine kleine Funktion namens BenutzerdatenPruefen<\/b> (s. Listing 2<\/a><\/span>).<\/p>\n Listing 2: Prüfung der Benutzerdaten<\/p>\n Die Funktion ermittelt den Hash-Wert des Benutzernamens und vergleicht diesen mit dem für den Registrierungsschlüssel angegebenen Wert. Stimmen beide überein, liefert die Funktion den Wert True <\/b>zurück.<\/p>\n Beim Öffnen des Formulars wird diese Funktion erstmalig aufgerufen. Dazu legen Sie für das Ereignis Beim Laden <\/b>des Formulars die folgende Prozedur an:<\/p>\n War die Prüfung erfolgreich, schließt die Prozedur einfach das aktuelle Formular und öffnet ein weiteres Formular namens frmMain<\/b>, das beispielsweise dem Hauptformular der Anwendung entspricht. Sie können natürlich auch einfach das Formular schließen und die verfügbaren Funktionen in der Menüleiste oder im Ribbon anzeigen.<\/p>\n Stimmen der Hash-Wert des Benutzernamens und der Registrierungsschlüssel nicht überein, bleibt das Formular einfach geöffnet. Der Benutzer hat dann die Gelegenheit, die Benutzerdaten einzugeben. Die Eingabe beendet der Benutzer mit einem Klick auf die Schaltfläche OK<\/b>, was die folgende Prozedur auslöst:<\/p>\n Hier erfolgt die gleiche Prüfung wie beim Laden des Formulars. Im Erfolgsfall wird das Formular geschlossen und frmMain <\/b>geöffnet. Stimmt die Kombination aus Benutzername und Registrierungsschlüssel nicht, erscheint eine Meldung mit dem Text Falsche Benutzerdaten<\/b>. Der Benutzer kann dann erneut seine Daten eingeben oder mit einem Klick auf Abbrechen <\/b>die Anwendung beenden (s. Bild 3).<\/p>\n Bild 4: Prinzipieller Ablauf beim Prüfen und Eingeben der Registrierungsdaten<\/span><\/b><\/p>\n <\/p>\n Bild 4 zeigt den prinzipiellen Ablauf beim Eingeben und Prüfen der Registrierungsdaten.<\/p>\n Bild 3: Beim Eingeben falscher Benutzerdaten erscheint eine Meldung.<\/span><\/b><\/p>\n Anwendung schützen<\/b><\/p>\n Die bisherigen Bemühungen helfen nun natürlich nicht weiter, wenn Sie den Benutzer nicht vom Einsehen des Quellcodes abhalten. Dazu erstellen Sie aus der .mdb<\/b>– oder .accdb<\/b>-Anwendung eine .mde<\/b>– oder .accde<\/b>-Datenbank mit geschütztem Code und mit gesperrten Entwurfsansichten.<\/p>\n Der Benutzer kann den Mechanismus zum Prüfen der Benutzerdaten dann nicht einsehen und diesen nicht einfach reproduzieren, um selbst Zugangsdaten zu erzeugen.<\/p>\n Umgehen der Registrierung verhindern<\/b><\/p>\n Natürlich könnte der Benutzer einfach direkt auf die übrigen Formulare der Anwendung zugreifen, indem er diese über das Datenbankfenster oder den Navigationsbereich öffnet. Die Anzeige dieser Bereiche lässt sich zwar auch unterbinden, aber ein erfahrener Access-Entwickler kann diese dennoch anzeigen. Außerdem wäre hierfür der Einsatz des Sicherheitssystems erforderlich, was aber ab Access 2007 offiziell nicht mehr unterstützt wird.<\/p>\n Da wir den Entwurf und den Code von Formularen, Berichten und Modulen aber ohnehin schützen, können wir auch gleich einen Mechanismus in die Formulare einbauen, der vor dem Öffnen die Benutzerdaten prüft. Dies erreichen Sie beispielsweise durch eine ähnliche Prüfung wie im Startformular. Damit das Formular nicht geöffnet wird, wenn keine gültigen Benutzerdaten vorliegen, legen Sie die folgende Prozedur für das Ereignis Beim Öffnen <\/b>des Formulars an:<\/p>\n Die Prüfung der Benutzerdaten haben wir derweil in eine eigene Funktion ausgegliedert, die sich im Modul mdlTools <\/b>befindet (s. Listing 3<\/a><\/span>).<\/p>\n Listing 3: Abgleich von Benutzername und Registrierungsschlüssel<\/p>\n Die Prozedur Form_Open <\/b>prüft nun mithilfe der Funktion BenutzerdatenGueltig<\/b>, ob die Tabelle tblBenutzerdaten <\/b>einen gültigen Satz von Benutzerdaten enthält. Falls nicht, liefert BenutzerdatenGueltig <\/b>den Wert False <\/b>zurück, der gleich dem Parameter Cancel <\/b>der Prozedur Form_Open <\/b>übergeben wird. Dies bedeutet, dass der Öffnen-Vorgang des Formulars gleich unterbrochen und das Formular nicht geöffnet wird. Eine solche Prüfung müssten Sie zumindest den wichtigsten Formularen zuweisen, um die Anwendung ohne gültige Benutzerdaten unbenutzbar zu machen.<\/p>\n Zeitliche Komponente<\/b><\/p>\n Wie eingangs erwähnt, möchten Sie unter Umständen eine zeitliche Begrenzung der Nutzbarkeit der Anwendung mit den angegebenen Benutzerdaten erreichen. In diesem Fall müssten Sie ein Verfallsdatum erstellen oder mitgeben. Hier gibt es grundsätzlich zwei verschiedene Ansätze:<\/p>\n Die erste Variante ist einfach: Sie brauchen dazu nur das Enddatum in den Registrierungsschlüssel zu integrieren und diesen entweder beim ersten Aufruf oder bei jedem Aufruf zu prüfen. Das hört sich auf den ersten Blick kompliziert an, ist es aber nicht.<\/p>\n Nehmen wir an, Sie erstellen den Registrierungsschlüssel nicht nur auf Basis des Benutzernamens, sondern fügen noch das Datum hinzu – beispielsweise im Format yyyymmdd<\/b>. Dies erledigt etwa die Funktion aus Listing 4<\/a><\/span>. <\/p>\n Listing 4: Registrierungsschlüssel mit zusätzlichem Datum<\/p>\n Ein Aufruf über das Direktfenster sieht etwa so aus:<\/p>\n Wie aber ermitteln Sie beim Eingeben dieses Registrierungsschlüssels in der Anwendung das Enddatum, wenn dieses verschlüsselt im Registrierungsschlüssel steckt – der eigentlich nicht umkehrbar sein soll<\/p>\n Ganz einfach: Sie durchlaufen einfach alle Daten vom heutigen Datum bis zu einem Datum, das der maximalen Laufzeit entspricht (also etwa 366 Tage für ein Jahr Laufzeit), und ermitteln so das passende Datum.<\/p>\n Diese Aufgabe erledigt die Funktion EnddatumErmitteln<\/b>. Sie erwartet den Benutzernamen und den Registrierungsschlüssel als Parameter und durchläuft in einer Schleife alle Datumsangaben zwischen dem heutigen Datum und dem Datum in 366 Tagen.<\/p>\n Dabei erledigt sie für jeden Tag die gleiche Aufgabe wie beim Erzeugen des Registrierungsschlüssels: Sie setzt den Benutzernamen und das formatierte Datum zusammen, ermittelt den Hash-Wert für das jeweilige Datum und vergleicht diesen schließlich mit dem richtigen Hash-Wert. Wenn beide Hash-Werte übereinstimmen, wurde das Gültigkeitsdatum gefunden.<\/p>\n Immer prüfen oder nur einmal<\/b><\/p>\n Sie können diese Prüfung nun zu jedem Start durchführen oder aber nur bei der ersten Registrierung. Sie würden dann das Datum ebenfalls in der Tabelle tblBenutzerdaten <\/b>speichern und könnten dann direkt prüfen, ob die richtige Kombination aus Benutzername, Datum und Registrierungsschlüssel angegeben wurde. Die Tabelle tblBenutzerdaten<\/b> würden Sie dann wie in Bild 5 erweitern.<\/p>\n Bild 5: Erweiterung der Tabelle tblBenutzerdaten um ein Datumsfeld<\/span><\/b><\/p>\n In diesem Fall ändern Sie die Funktion BenutzerdatenPruefen<\/b>, die beim Öffnen des Formulars frmStart <\/b>ausgeführt wird, wie in Listing 5<\/a><\/span>.<\/p>\n Listing 6: Enddatum für die aktuellen Registrierungsdaten ermitteln<\/p>\n Diese Funktion prüft zunächst, ob das Feld Enddatum <\/b>der Tabelle tblBenutzerdaten <\/b>bereits einen Wert enthält. Falls ja, wird die Kombination aus Benutzername, Registrierungsschlüssel und Enddatum mithilfe der Funktion RegistrierungsschluesselMitDatum <\/b>geprüft. Verläuft diese Prüfung positiv, liefert die Funktion BenutzerdatenPruefen <\/b>den Wert True <\/b>zurück.<\/p>\n Ist das Feld Enddatum <\/b>der Tabelle tblBenutzerdaten <\/b>noch nicht gefüllt, ruft die Routine zunächst die Funktion EnddatumErmitteln <\/b>auf, um das für diese Kombination aus Benutzername und Registrierungsschlüssel gültige Enddatum zu ermitteln (s. Listing 6<\/a><\/span>). Verläuft dies erfolgreich, wird das Enddatum in die Tabelle tblBenutzerdaten <\/b>eingetragen und der Wert True <\/b>als Funktionswert zurückgeliefert.<\/p>\n Zwischenfazit<\/b><\/p>\n Damit haben Sie bereits einen großen Teil der Arbeit erledigt: Unter dem angegebenen Benutzernamen kann die Anwendung nur noch bis zu einem bestimmten Datum verwendet werden.<\/p>\n Nun gibt es noch zwei Baustellen: Die Anwendung kann leicht auf mehreren Rechnern gleichzeitig eingesetzt werden – auch wenn dies unter ein und demselben Benutzernamen geschieht.<\/p>\n Und außerdem kann der Benutzer die Systemzeit seines Rechners zurückstellen und somit die Nutzungsdauer der Anwendung ins Unendliche verlängern.<\/p>\n Einschränkung der registrierten Kopien<\/b><\/p>\n Wenn Sie verhindern möchten, dass der Benutzer Ihre Anwendung auf Arbeitsplätzen in seiner gesamten Firma bereitstellt oder diese gar an Dritte weitergibt, sollten Sie die Registrierungsdaten zum Zeitpunkt der Registrierung einmalig an einen Webserver übermitteln.<\/p>\n Dort speichern Sie in einer Datenbank die Anzahl der Registrierungsvorgänge mit den gleichen Registrierungsdaten.<\/p>\n Beim Überschreiten einer bestimmten Anzahl können Sie dafür sorgen, dass der Benutzer sich bei Ihnen meldet. Wie Sie den Zugriff auf den Webserver erledigen, erfahren Sie im Beitrag Webservice light <\/b>(www.access-im-unternehmen.de\/798<\/b>).<\/p>\n Zurückdrehen der Systemzeit erkennen<\/b><\/p>\n Um zu erkennen, ob der Benutzer die Systemzeit zurückgedreht hat, müssen Sie jeweils beim Start das aktuelle Datum speichern. Sollte die Systemzeit dann bei einem späteren Start vor dem gespeicherten Datum liegen, wäre ein Anhaltspunkt für eine Benutzung der Anwendung bei manipulierter Systemzeit gegeben.<\/p>\n Das kann allerdings auch durch Manipulation der Systemzeit in Richtung Zukunft ausgelöst werden: Angenommen, der Benutzer experimentiert gerade mit einer Technik, um die Nutzung seiner Anwendungen durch Benutzerdaten zeitlich einzuschränken.<\/p>\n Dieser könnte die Systemzeit auf ein Datum in der Zukunft einstellen, um zu prüfen, ob die Anwendung nach dem angegebenen Verfallsdatum noch funktioniert.<\/p>\n Wenn er nun genau zu diesem Zeitpunkt mit Ihrer Anwendung arbeitet, diese das in der Zukunft liegende Systemdatum speichert und der Benutzer dann die Systemzeit wieder zurückstellt, erhalten Sie den gleichen Effekt, als wenn der Benutzer die Anwendung zunächst regulär verwendet und dann für einen weiteren Einsatz nach Ablauf des Verfallsdatums die Systemzeit zurückdreht.<\/p>\n Und genauso kann es natürlich vorkommen, dass die Systemzeit gerade ein in der Zukunft liegendes Datum enthält und der Benutzer zufälligerweise genau dann die Anwendung installiert.<\/p>\n Wenn Sie es wirklich ernst meinen und die zeitliche Beschränkung der Nutzung durchsetzen möchten, bleibt Ihnen nichts anderes übrig, als das aktuelle Systemdatum zumindest einmal via Internet etwa von Ihrem eigenen Server einzulesen. Somit können Sie zumindest sicherstellen, dass beim Installieren das aktuelle Datum gespeichert wurde.<\/p>\n Zusammenfassung und Ausblick<\/b><\/p>\n Mit den hier vorgestellten Techniken erhalten Sie das Handwerkzeug, um die uneingeschränkte Weitergabe und Benutzung einer Anwendung zu unterbinden. Grundsätzlich ist dies zwar möglich, aber es würde wohl kaum jemand eine Anwendung mit seinen Registrierungsdaten weitergeben, wenn sein Name damit verbunden ist.<\/p>\n Listing 5: Datumsabhängige Registrierungsschlüssel prüfen<\/p>\n<\/td>\n<\/tr>\n Enthaltene Beispieldateien:<\/p>\n Registrierung.mdb<\/p>\nPublic Function GetSHA1(strKey As String) As String\r\n Dim objCrypt As New clsCrypt\r\n Dim strSHA1 As String\r\n strSHA1 = objCrypt.GetSHA1(strKey)\r\n GetSHA1 = strSHA1\r\n Set objCrypt = Nothing\r\nEnd Function<\/pre>\n
GetSHA1("Klaus Müller")\r\n04538C3BBD1B721D87F6570B577D1D0A3E7390AD<\/pre>\n![\"pic001.png\"](\"..\/fileadmin\/_temp_\/2011_05\/Registrierung-web-images\/pic001.png\")
<\/p>\n![\"pic002.png\"](\"..\/fileadmin\/_temp_\/2011_05\/Registrierung-web-images\/pic002.png\")
<\/p>\nPrivate Sub cmdAbbrechen_Click()\r\n DoCmd.Quit\r\n End Sub<\/pre>\n
Private Function BenutzerdatenPruefen() As Boolean\r\n BenutzerdatenPruefen = (GetSHA1(Nz(Me!txtBenutzername)) = Nz(Me!txtRegistrierungsschluessel))\r\nEnd Function<\/pre>\n
Private Sub Form_Load()\r\n If BenutzerdatenPruefen Then\r\n DoCmd.Close acForm, Me.Name\r\n DoCmd.OpenForm "frmMain"\r\n End If\r\n End Sub<\/pre>\n
Private Sub cmdOK_Click()\r\n If BenutzerdatenPruefen Then\r\n DoCmd.Close acForm, Me.Name\r\n DoCmd.OpenForm "frmMain"\r\n Else\r\n MsgBox "Falsche Benutzerdaten."\r\n End If\r\n End Sub<\/pre>\n
![\"pic005.png\"](\"..\/fileadmin\/_temp_\/2011_05\/Registrierung-web-images\/pic005.png\")
<\/p>\n![\"pic003.png\"](\"..\/fileadmin\/_temp_\/2011_05\/Registrierung-web-images\/pic003.png\")
<\/p>\nPrivate Sub Form_Open(Cancel As Integer)\r\n Cancel = BenutzerdatenGueltig\r\n End Sub<\/pre>\n
Public Function BenutzerdatenGueltig() As Boolean\r\n Dim strBenutzername As String\r\n Dim strRegistrierungsschluessel As String\r\n strBenutzername = Nz(DLookup("Benutzername", "tblBenutzerdaten"))\r\n strRegistrierungsschluessel = Nz(DLookup("Registrierungsschluessel", "tblBenutzerdaten"))\r\n If Not GetSHA1(strBenutzername) = strRegistrierungsschluessel Then\r\n BenutzerdatenGueltig = True\r\n End If\r\nEnd Function<\/pre>\n\n
Public Function RegistrierungsschluesselMitDatum(strBenutzer As String, datEnde As Date) As String\r\n Dim strEnddatum As String\r\n strEnddatum = Format(datEnde, "yyyymmdd")\r\n RegistrierungsschluesselMitDatum = GetSHA1(strBenutzer & strEnddatum)\r\nEnd Function<\/pre>\n
RegistrierungsschluesselMitDatum("André Minhorst", "1.10.2011")\r\nB9B555D12CB51D8F77C215CCE2402AF532545630<\/pre>\n![\"pic004.png\"](\"..\/fileadmin\/_temp_\/2011_05\/Registrierung-web-images\/pic004.png\")
<\/p>\nPublic Function EnddatumErmitteln(strBenutzer As String, strRegistrierungsschluessel As String) As Date\r\n Dim datAktuell As Date\r\n Dim strEnddatum As String\r\n For datAktuell = Date To Date + 366\r\n strEnddatum = Format(datAktuell, "yyyymmdd")\r\n If GetSHA1(strBenutzer & strEnddatum) = strRegistrierungsschluessel Then\r\n EnddatumErmitteln = datAktuell\r\n Exit Function\r\n End If\r\n Next datAktuell\r\nEnd Function<\/pre>\n
\n\n
\n \n \n \n Private Function BenutzerdatenPruefen() As Boolean\r\n Dim datEnddatum As Date\r\n If IsNull(Me!enddatum) Then\r\n datEnddatum = EnddatumErmitteln(Me!txtBenutzername, Me!txtRegistrierungsschluessel)\r\n If Not datEnddatum = 0 Then\r\n Me!enddatum = datEnddatum\r\n BenutzerdatenPruefen = True\r\n End If\r\n Else\r\n If RegistrierungsschluesselMitDatum(Me!txtBenutzername, Me!enddatum) = Me!txtRegistrierungsschluessel Then\r\n BenutzerdatenPruefen = True\r\n End If\r\n End If\r\nEnd Function<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Downloads zu diesem Beitrag<\/h3>\n