{"id":55001126,"date":"2018-04-01T00:00:00","date_gmt":"2020-05-13T21:19:07","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=1126"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Software_freischalten_per_Schluessel","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/Software_freischalten_per_Schluessel\/","title":{"rendered":"Software freischalten per Schlüssel"},"content":{"rendered":"

\"\"<\/p>\n

Wenn Sie eine Software weitergeben, wollen Sie natürlich sicherstellen, dass diese nur von Kunden genutzt wird, die auch für die Software bezahlt haben. Wie können Sie das sicherstellen Eine Möglichkeit ist es, in Abhängigkeit von einem Benutzernamen einen Freischaltungsschlüssel zu erzeugen, den der Benutzer in die Anwendung eingeben muss, damit diese funktioniert. Auf diese Weise sorgen Sie nicht nur dafür, dass der Benutzer diesen Schlüssel erwerben muss, wenn er die Anwendung nutzen will. Damit ist gleichzeitig sichergestellt, dass Sie – wenn ein Benutzer die Anwendung weitergibt oder diese sogar in einem Portal zum Download bereitstellt – herausfinden, welcher Kunde die Software weitergegeben hat. Dieser Beitrag liefert die technischen Grundlagen für den Schutz einer Software mit Freischaltungsschlüssel.<\/b><\/p>\n

Voraussetzung<\/h2>\n

Voraussetzung für den Schutz der Software mit einem Freischaltungsschlüssel ist natürlich, dass Sie diese nur als .mde<\/b>– oder .accde<\/b>-Datei weitergeben. Anderenfalls kann der Benutzer ja einfach in den Code schauen und die Schutzmaßnahme aushebeln.<\/p>\n

Startformular<\/h2>\n

Die Abfrage der Daten für die Freischaltung, also der E-Mail-Adresse und des Freischaltungsschlüssels, soll in einem Startformular erfolgen. Dieses heißt frmStart <\/b>und sieht wie in Bild 1 aus. Für das Formular stellen wir die Eigenschaften Bildlaufleisten<\/b>, Navigationsschaltflächen<\/b>, Datensatzmarkierer <\/b>und Trennlinien <\/b>auf Nein <\/b>und Automatisch zentrieren <\/b>auf Ja <\/b>ein. Außerdem soll das Formular als Popup geöffnet werden, also so, dass der Benutzer keine weiteren Aktionen ausführen kann, wenn dieses Formular nicht geschlossen wurde. Dazu stellen wir die Eigenschaft Popup <\/b>auf Ja <\/b>ein.<\/p>\n

\"Formular<\/p>\n

Bild 1: Formular zum Freischalten der Anwendung<\/span><\/b><\/p>\n

Um die vom Benutzer in die beiden Textfelder txtEMail <\/b>und txtSchluessel <\/b>eingegebenen Daten zu speichern, arbeiten wir mit einer Tabelle namens tblOptionen<\/b>. Diese ist wie in Bild 2 aufgebaut und enthält die drei Felder ID<\/b>, EMail <\/b>und Schluessel<\/b>. Im Auflieferungszustand soll die Tabelle einen leeren Datensatz enthalten.<\/p>\n

\"Tabelle<\/p>\n

Bild 2: Tabelle zum Speichern der Freischaltungsdaten<\/span><\/b><\/p>\n

Damit der Benutzer die Daten über das Formular frmStart <\/b>eingeben kann, binden wir das Formular ausnahmsweise nicht über die Eigenschaft Datenherkunft <\/b>an die Tabelle tblOptionen<\/b>. Wir wollen die eingegebenen Daten ja nur dann speichern, wenn der Benutzer ein passendes Paar von E-Mail und Schlüssel eingegeben hat. In diesem Fall soll das Formular frmStart <\/b>gar nicht mehr erscheinen, sondern direkt das erste Formular der Anwendung angezeigt werden.<\/p>\n

Startformular einrichten<\/h2>\n

Damit das Formular frmStart<\/b> direkt beim öffnen der Anwendung angezeigt wird, stellen wir in den Access-Optionen, die Sie über den Eintrag Optionen <\/b>unter dem Ribbon-Tab Datei <\/b>öffnen, im Bereich Aktuelle Datenbank <\/b>unter Anwendungsoptionen <\/b>die Eigenschaft Formular anzeigen <\/b>auf das Formular frmStart <\/b>ein (siehe Bild 3).<\/p>\n

\"Einstellen<\/p>\n

Bild 3: Einstellen des Formulars frmStart als Startformular<\/span><\/b><\/p>\n

Wenn wir die Anwendung nun neu starten, um das Formular frmStart <\/b>direkt beim Start anzuzeigen, gelingt das auf den ersten Blick wie gewünscht. Allerdings kann man trotz des Modus als Popup noch direkt auf die Elemente des Navigationsbereichs oder des Ribbons zugreifen. Um dies zu verhindern, müssen wir auch noch die Eigenschaft Modal <\/b>auf True <\/b>einstellen. Dies gelingt allerdings nicht über das Eigenschaftsfenster, sodass wir die entsprechende Zuweisung in einer Prozedur unterbringen, die durch das Ereignis Beim Laden <\/b>des Formulars ausgelöst wird. Diese Prozedur sieht wie folgt aus:<\/p>\n

Private Sub <\/span>Form_Load()\r\n     Me.Modal = True<\/span>\r\nEnd Sub<\/span><\/pre>\n
Nun zeigt das Formular allerdings immer noch die Titelleiste sowie die Schaltflächen zum Schließen, Minimieren und Maximieren an (siehe Bild 4). Dies ändern wir noch, indem wir die Eigenschaft Rahmenart <\/b>auf Keine <\/b>einstellen. Dadurch erscheint das Formular etwa unter Access 2016, wo der Hintergrund weiß ist, wie in Bild 5. Das sind jedoch Spielereien – wichtig ist, dass der Benutzer nicht um den Aufruf dieses Formulars herumkommt.<\/p>\n
\"Anzeige<\/p>\n
Bild 4: Anzeige des Startformulars<\/span><\/b><\/p>\n
\"Formular<\/p>\n
Bild 5: Formular als Popup öffnen<\/span><\/b><\/p>\n
übrigens: Wenn Sie das Formular auf diese Art geöffnet haben, können Sie es nicht über die herkömmlichen Elemente der Benutzeroberfläche wieder schließen – auch nicht mit der Tastenkombination Strg + F4 <\/b>oder durch einen Wechsel in die Entwurfsansicht mit der Tastenkombination Strg + Komma <\/b>(,<\/b>).<\/p>\n
Allerdings führt der Versuch, die Anwendung mit Alt + F4 <\/b>zu schließen, zunächst zum Schließen des Formulars und dann bei erneuter Betätigung zum Schließen der Anwendung. Diesen Weg müssten wir also noch blockieren. Dazu hinterlegen wir eine Prozedur für die Ereignis-eigenschaft Bei Taste ab <\/b>des Formulars selbst, die wir wie folgt füllen:<\/p>\n
Private Sub <\/span>Form_KeyDown(KeyCode As Integer<\/span>,  Shift As Integer<\/span>)\r\n     Select Case KeyCode\r\n         Case <\/span>115\r\n             Select Case Shift\r\n                 Case <\/span>acAltMask\r\n                     KeyCode = 0\r\n             End Select<\/span>\r\n     End Select<\/span>\r\nEnd Sub<\/span><\/pre>\n
Damit diese Prozedur auch dann feuert, wenn eines der Steuerelemente des Formulars den Fokus hat, stellen wir noch die Eigenschaft Tastenvorschau <\/b>auf Ja <\/b>ein.<\/p>\n
Wie können wir das Formular aber nun beim Entwickeln noch schließen, ohne direkt die komplette Anwendung schließen zu müssen Der einzige Weg, der übrig bleibt, ist der über den Direktbereich des VBA-Fensters. Diesen rufen Sie mit der Tastenkombination Strg + G <\/b>auf und geben dort die folgende Anweisung ein:<\/p>\n
DoCmd.Close acForm, \"frmStart\"<\/pre>\n
Eingabe des Freigabeschlüssels<\/h2>\n
Damit kommen wir zum Freigabeschlüssel selbst. Diesen soll der Benutzer neben der E-Mail-Adresse in das entsprechende Textfeld eingeben. Dann soll er den Schlüssel durch Betätigen der OK<\/b>-Schaltfläche bestätigen. Ist die Kombination aus E-Mail und Freigabeschlüssel korrekt, sollen die beiden Informationen in der Tabelle tblOptionen <\/b>gespeichert werden. Beim nächsten Aufruf der Anwendung sollen diese beiden Werte dann beim Aufruf des Formulars frmStart <\/b>geprüft werden. Passen diese zusammen, setzt die Anwendung den Startvorgang fort und zeigt das gewünschte Element der Benutzeroberfläche an. Anderenfalls wird der Benutzer gebeten, die korrekten Daten zur Freischaltung anzugeben.<\/p>\n
Nachfolgend schauen wir uns mehrere Varianten an, wie wir die E-Mail-Adresse und den Schlüssel erstellen und prüfen können. Die erste Variante ist die zeitlich unbegrenzte, die zweite ist eine, mit der Sie eine Software befristet bis zu einem bestimmten Datum freischalten lassen können.<\/p>\n
Einfache Variante: E-Mail und Schlüssel müssen passen<\/h2>\n
Um die Schlüssel zu generieren, verwenden wir eine Klasse namens clsCrypt <\/b>des Autors Tim Braun (siehe Modul im VBA-Projekt). Diese bietet vor allen die für uns interessante Funktion namens GetSHA1 <\/b>an, die eine als Parameter übergebene Zeichenkette in einen Schlüssel umwandelt.<\/p>\n
Diese Funktion können wir nach der Initialisierung eines Objekts auf Basis der Klasse clsCrypt<\/b> wie in der folgenden Prozedur testen:<\/p>\n
Public Sub <\/span>Test_GetSHA1()\r\n     Dim <\/span>objCrypt As <\/span>clsCrypt\r\n     Set<\/span> objCrypt = New<\/span> clsCrypt\r\n     Debug.Print<\/span> objCrypt.GetSHA1(\"André Minhorst\")\r\nEnd Sub<\/span><\/pre>\n
Das Ergebnis lautet dann:<\/p>\n
B431123435AE6C58E661FBCA736FAEF739BE6F2F<\/pre>\n
Der Benutzer wird Probleme haben, daraus zu ermitteln, auf welche Weise der Schlüssel produziert wird. Es sollte natürlich nicht allzu einfach sein – wenn Sie also einfach nur die E-Mail-Adresse verschlüsseln und als Schlüssel zum Freischalten der Anwendung nutzen, besteht die Gefahr, dass der Benutzer sich seine eigenen Schlüssel erstellt.<\/p>\n
Zum Erstellen eines einfachen Schlüssels verwenden wir nun die E-Mail-Adresse und hängen eine einfache Zeichenfolge wie etwa xxx <\/b>an (diese darf natürlich ebenfalls etwas komplizierter ausfallen). Der zu kodierende Ausdruck heißt dann im Falle meiner eigenen E-Mail-Adresse etwa so: andre@minhorst.comxxx<\/b><\/p>\n
Der verschlüsselte Ausdruck heißt dann:<\/p>\n
D382469636E463CE93079D0F9714212EFC4D54A6<\/pre>\n
Wir wollen uns eine kleine Funktion bauen, um die Schlüssel einfacher herstellen zu können. Diese sieht so aus:<\/p>\n
Public Function <\/span>Verschluesseln(strAusdruck As String<\/span>)  As String<\/span>\r\n     Dim <\/span>objCrypt As <\/span>clsCrypt\r\n     Dim <\/span>strVerschluesselt As String<\/span>\r\n     Set<\/span> objCrypt = New<\/span> clsCrypt\r\n     strVerschluesselt = objCrypt.GetSHA1(strAusdruck)\r\n     Verschluesseln = strVerschluesselt\r\nEnd Function<\/span><\/pre>\n
Im Direktfenster setzen Sie die Funktion wie folgt ein:<\/p>\n
  Verschluesseln(\"andre@minhorst.comxxx\")\r\nD382469636E463CE93079D0F9714212EFC4D54A6<\/pre>\n
Eingabe des Schlüssels<\/h2>\n
Nun, wo wir eine Methode zum Erzeugen der Schlüssel programmiert haben, wollen wir uns um das Formular zur Eingabe der E-Mail-Adresse und des Schlüssels kümmern. Dazu fügen wir der Schaltfläche cmdOK <\/b>den Code aus Listing 1 hinzu.<\/p>\n
Private Sub <\/span>cmdOK_Click()\r\n     Dim <\/span>strEMail As String<\/span>\r\n     Dim <\/span>strSchluessel As String<\/span>\r\n     strEMail = Me!txtEMail\r\n     strSchluessel = Me!txtSchluessel\r\n     If <\/span>Verschluesseln(strEMail & \"xxx\") = strSchluessel Then<\/span>\r\n         SchluesselSchreiben strEMail, strSchluessel\r\n         MsgBox<\/span> \"Die Anwendung wurde erfolgreich freigeschaltet.\"\r\n         DoCmd.Close acForm, Me.Name\r\n     Else<\/span>\r\n         MsgBox<\/span> \"E-Mail-Adresse und\/oder Schlüssel sind nicht korrekt.\"\r\n     End If<\/span>\r\nEnd Sub<\/span><\/pre>\n
Listing 1: Prüfung des Schlüssels<\/span><\/b><\/p>\n
Die Ereignisprozedur cmdOK_Click <\/b>trägt die Werte der beiden Textfelder txtEMail <\/b>und txtSchluessel <\/b>in die beiden Variablen strEMail <\/b>und strSchluessel <\/b>ein. Dann prüft sie in einer If…Then<\/b>-Bedingung, ob der verschlüsselte Wert der E-Mails-Adresse plus der angehängten Zeichenkette xxx mit der vom Benutzer eingegebenen Schlüssel-Zeichenfolge übereinstimmt. Ist dies der Fall, ruft die Prozedur die Funktion SchluesselSchreiben <\/b>auf und übergibt die E-Mail und den Schlüssel an diese Funktion. Es erscheint eine Meldung, welche die erfolgreiche Freischaltung bestätigt und das Formular wird geschlossen.<\/p>\n
Hat der Benutzer nicht die richtige Kombination aus E-Mail-Adresse und Schlüssel eingegeben, erscheint ebenfalls eine Meldung und das Start-Formular bleibt geöffnet. Er kann es nun erneut probieren oder aber mit einem Klick auf die Schaltfläche cmdBeenden <\/b>die Anwendung schließen.<\/p>\n
Schreiben von E-Mail und Schlüssel<\/h2>\n
Die von der oben beschriebenen Prozedur aufgerufene Funktion SchluesselSchreiben<\/b> erwartet die E-Mail-Adresse sowie den Schlüssel als Parameter (siehe Listing 2). Die Funktion prüft, ob sich bereits ein Datensatz in der Tabelle tblOptionen <\/b>befindet. Falls nicht, fügt sie einen neuen Datensatz hinzu und trägt die beiden Werte aus den Parametern strEMail <\/b>und strSchluessel <\/b>in die beiden Felder der Tabelle ein. Ist bereits ein Datensatz vorhanden, werden die Inhalte der beiden Felder durch die neuen Werte ersetzt.<\/p>\n
Private Sub <\/span>SchluesselSchreiben(strEMail As String<\/span>, strSchluessel As String<\/span>)\r\n     Dim <\/span>db As <\/span>DAO.Database\r\n     Dim <\/span>rst As <\/span>DAO.Recordset\r\n     Set<\/span> db = CurrentDb\r\n     Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblOptionen\", dbOpenDynaset)\r\n     If <\/span>rst.EOF Then<\/span>\r\n         rst.AddNew<\/span>\r\n         rst!EMail = strEMail\r\n         rst!Schluessel = strSchluessel\r\n         rst.Update\r\n     Else<\/span>\r\n         rst.Edit\r\n         rst!EMail = strEMail\r\n         rst!Schluessel = strSchluessel\r\n         rst.Update\r\n     End If<\/span>\r\nEnd Sub<\/span><\/pre>\n
Listing 2: Schreiben des Schlüssels<\/span><\/b><\/p>\n
Die Tabelle sieht danach etwa wie in Bild 6 aus.<\/p>\n
\"Tabelle<\/p>\n
Bild 6: Tabelle mit den Freischaltungsdaten<\/span><\/b><\/p>\n
Inhalt der Tabelle beim öffnen prüfen<\/h2>\n
Nun haben wir allerdings nur den Fall abgedeckt, dass der Benutzer die Anwendung zum ersten Mal öffnet. Wenn er nun eine gültige Kombination aus E-Mail-Adresse und Schlüssel angegeben hat, soll er ja nicht bei jedem erneuten öffnen der Anwendung erneut die Daten eingeben müssen. Also wollen wir die Prozedur cmdOK_Click <\/b>so erweitern, dass diese zunächst prüft, ob bereits gültige Daten in der Tabelle tblOptionen <\/b>vorliegen.<\/p>\n
Dazu fügen wir der Ereignisprozedur, die durch das Ereignis Beim öffnen <\/b>ausgelöst wird, die folgenden Anweisungen hinzu:<\/p>\n
Private Sub <\/span>Form_Open(Cancel As Integer<\/span>)\r\n     If <\/span>SchluesselPruefen = True<\/span> Then<\/span>\r\n         Cancel = True<\/span>\r\n     End If<\/span>\r\nEnd Sub<\/span><\/pre>\n
Wenn die Funktion SchluesselPruefen <\/b>den Wert True zurückliefert, stellt die Prozedur den Wert des Parameters Cancel <\/b>auf True <\/b>ein. Dies führt dazu, dass das Formular frmStart <\/b>direkt wieder geschlossen wird.<\/p>\n
Es fehlt nun noch die Funktion SchluesselPruefen<\/b>. Diese Funktion finden Sie in Listing 3. Die Funktion erwartet keine Parameter, da sie die zu prüfenden Werte direkt aus der Tabelle tblOptionen <\/b>einliest. Auch hier kann es wieder sein, dass noch gar kein Datensatz in der Tabelle gespeichert ist. Dies prüft die Prozedur gleich in der ersten If…Then<\/b>-Bedingung mit dem Ausdruck rst.EOF<\/b>. Liefert dies True<\/b>, enthält die Tabelle noch keinen Datensatz. In diesem Fall soll die Funktion den Wert False <\/b>zurückliefern.<\/p>\n
Private Function <\/span>SchluesselPruefen()\r\n     Dim <\/span>db As <\/span>DAO.Database\r\n     Dim <\/span>rst As <\/span>DAO.Recordset\r\n     Dim <\/span>strEMail As String<\/span>\r\n     Dim <\/span>strSchluessel As String<\/span>\r\n     Dim <\/span>bolSchluesselPruefen  As Boolean<\/span>\r\n     Set<\/span> db = CurrentDb\r\n     Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblOptionen\", dbOpenDynaset)\r\n     If <\/span>Not<\/span> rst.EOF Then<\/span>\r\n         strEMail = rst!EMail\r\n         strSchluessel = rst!Schluessel\r\n         If <\/span>Verschluesseln(strEMail & \"xxx\") = strSchluessel Then<\/span>\r\n             bolSchluesselPruefen = True<\/span>\r\n         Else<\/span>\r\n             bolSchluesselPruefen = False<\/span>\r\n         End If<\/span>\r\n     Else<\/span>\r\n         bolSchluesselPruefen = False<\/span>\r\n     End If<\/span>\r\n     SchluesselPruefen = bolSchluesselPruefen\r\nEnd Function<\/span><\/pre>\n
<\/p>\n
Listing 3: Prüfen, ob der in der Tabelle tblOptionen gespeicherte Schlüssel korrekt ist<\/span><\/b><\/p>\n
Ist hingegen bereits ein Datensatz vorhanden, liest die Prozedur die beiden Werte der Felder EMail <\/b>und Schluessel <\/b>in die Variablen strEMail <\/b>und strSchluessel <\/b>ein.<\/p>\n
In einer weiteren If…Then<\/b>-Bedingung prüft die Funktion dann, ob der mit der Funktion Verschluesseln <\/b>verschlüsselte Ausdruck aus der E-Mail-Adresse und der Zeichenkette xxx <\/b>dem Schlüssel aus strSchluessel <\/b>entspricht. Ist dies der Fall, erhält die Variable bolSchluesselPruefen <\/b>den Wert True<\/b>, anderenfalls den Wert False<\/b>.<\/p>\n
Wenn der Benutzer nun einmalig die richtige Kombination aus E-Mail-Adresse und Schlüssel eingegeben hat, wird das Formular frmStart <\/b>erst gar nicht geöffnet – der Vorgang endet bereits in der Prozedur, die durch das Ereignis Beim öffnen <\/b>ausgelöst wird.<\/p>\n
Weitere Bedingung mit dem Schlüssel übergeben<\/h2>\n
Dies war die einfachste Variante für das Freischalten der Software durch die Angabe einer E-Mail-Adresse und einen Schlüssel. Es kann aber sein, dass Sie weitergehende Anforderungen haben, die über die Angabe von E-Mail-Adresse und Registrierungsschlüssel übermittelt werden.<\/p>\n
Zum Beispiel könnte es sein, dass die Anwendung verschiedene Funktionen bereitstellt, von denen je nach erworbener Lizenz nur eine oder mehrere Funktionen freigeschaltet sein sollen. Wir wollen dies im Folgenden so nachbilden, dass im Anschluss an das Formular frmStart <\/b>das Formular frmAnwendung<\/b> geöffnet wird, von dem abhängig vom vorliegenden Schlüssel eine oder mehrere Schaltflächen aktiviert oder auch nicht aktiviert sind.<\/p>\n
Das Formular frmStart <\/b>soll also grundsätzlich direkt wieder verschwinden, wenn der Benutzer einen der gültigen Schlüssel erhalten hat.<\/p>\n
Die einzelnen Funktionen wollen wir durch verschiedene Zusätze codieren, die wir in Form einer Zahl an die E-Mail-Adresse und die Zeichenfolge xxx <\/b>anhängen. Wir wollen drei Funktionen vereinbaren, die wir in einer binären Zahl als nutzbar oder nicht nutzbar kodieren. Wenn alle drei Funktionen verfügbar sind, soll die binäre Zahl also 111 <\/b>lauten und als 7 <\/b>an die zu verschlüsselnde Zeichenfolge angehängt werden. Wenn nur die letzte Funktion verfügbar sein soll, verwenden wir den Code 001<\/b>, also 1<\/b>, wenn nur die erste Funktion verfügbar ist, den Code 100<\/b>, also 4<\/b>.<\/p>\n
Achtung: Diese Version der Lösung finden Sie unter dem Dateinamen Freischaltungsschluessel_II.accdb<\/b>.<\/p>\n
Die Funktion VerschluesselnMitFunktion<\/b>, die wir ausschließlich zum Erstellen der Schlüssel verwenden, erwartet neben der Angabe der E-Mail-Adresse noch drei Boolean<\/b>-Werte für die Parameter bolFunktion1<\/b>, bolFunktion2 <\/b>und bolFunktion3<\/b>, die angeben, ob die Funktionen 1, 2 oder 3 freigeschaltet werden sollen (siehe Listing 4). Die drei Boolean-Variablen werden mit den Werten -4<\/b>, -2<\/b> oder -1<\/b> multipliziert und addiert. Da die Boolean-Parameter im Falle von True <\/b>den Wert -1<\/b> aufweisen, erhalten wir auf diese Weise Werte von 0 <\/b>bis 7 <\/b>für diese Berechnung. Der Rest der Funktion funktioniert wie die bisher bekannte Variante, fügt allerdings auch die Zeichenkette xxx <\/b>noch automatisch hinzu.<\/p>\n
Public Function <\/span>VerschluesselnMitFunktion(strMail As String<\/span>, bolFunktion1 As Boolean<\/span>, bolFunktion2 As Boolean<\/span>, _\r\n         bolFunktion3 As Boolean<\/span>) As String<\/span>\r\n     Dim <\/span>objCrypt As <\/span>clsCrypt\r\n     Dim <\/span>strVerschluesselt As String<\/span>\r\n     Dim <\/span>strAusdruck As String<\/span>\r\n     Set<\/span> objCrypt = New<\/span> clsCrypt\r\n     strAusdruck = strMail & \"xxx\" & bolFunktion1 * -4 + bolFunktion2 * -2 + bolFunktion3 * -1\r\n     Debug.Print<\/span> strAusdruck\r\n     strVerschluesselt = objCrypt.GetSHA1(strAusdruck)\r\n     Verschluesseln = strVerschluesselt\r\nEnd Function<\/span><\/pre>\n
Listing 4: Neue Version der Funktion Verschluesseln namens VerschluesselnMItFunktion, die weitere Eigenschaften berücksichtigt<\/span><\/b><\/p>\n
Dadurch ergibt sich auch eine neue Version der Ereignisprozedur, die durch die Schaltfläche cmdOK<\/b> ausgelöst wird. Diese sieht wie in Listing 5 aus und enthält eine zusätzliche Variable namens i<\/b>. Diese dient als Variable in einer For…Next<\/b>-Schleife, die alle Zahlen von 0 bis 7 durchläuft – also alle Werte, die für die verschiedenen Kombinationen der freigeschalteten Funktionen der Anwendung vorkommen können. Innerhalb der Schleife haben wir eine If…Then<\/b>-Bedingung, die prüft, ob der verschlüsselte Wert der E-Mail plus der Zeichenkette xxx<\/b> plus dem aktuellen Wert von i<\/b> dem vom Benutzer angegebenen Wert des Schlüssels entspricht. Falls ja, ruft die Routine wiederum die Prozedur SchluesselSchreiben <\/b>auf und übergibt die E-Mail-Adresse und den Schlüssel.<\/p>\n
Private Sub <\/span>cmdOK_Click()\r\n     Dim <\/span>strEMail As String<\/span>\r\n     Dim <\/span>strSchluessel As String<\/span>\r\n     Dim <\/span>i As Integer<\/span>\r\n     strEMail = Me!txtEMail\r\n     strSchluessel = Me!txtSchluessel\r\n     For i = 0 To 7\r\n         If <\/span>Verschluesseln(strEMail & \"xxx\" & i) = strSchluessel Then<\/span>\r\n             SchluesselSchreiben strEMail, strSchluessel\r\n             MsgBox<\/span> \"Die Anwendung wurde erfolgreich freigeschaltet.\"\r\n             DoCmd.Close acForm, Me.Name\r\n             Exit Sub<\/span>\r\n         End If<\/span>\r\n     Next<\/span> i\r\n     MsgBox<\/span> \"E-Mail-Adresse und\/oder Schlüssel sind nicht korrekt.\"\r\nEnd Sub<\/span><\/pre>\n
Listing 5: Neue Version der Ereignisprozedur, die durch die Schaltfläche cmdOK ausgelöst wird.<\/span><\/b><\/p>\n
Es fehlt noch die Funktion SchluesselPruefen<\/b>, die ebenfalls um die Schleife erweitert werden muss (siehe Listing 6). Diese nutzt nach der Ermittlung von E-Mail-Adresse und Schlüssel aus der Tabelle tblOptionen <\/b>wiederum eine For…Next<\/b>-Schleife, die alle Zahlen von 0 <\/b>bis 7 <\/b>durchläuft und mit der Funktion Verschluesseln<\/b> testet, ob der Wert aus strSchluessel <\/b>einem der acht durchlaufenen verschlüsselten Werte entspricht.<\/p>\n
Private Function <\/span>SchluesselPruefen() As Integer<\/span>\r\n     Dim <\/span>db As <\/span>DAO.Database\r\n     Dim <\/span>rst As <\/span>DAO.Recordset\r\n     Dim <\/span>strEMail As String<\/span>\r\n     Dim <\/span>strSchluessel As String<\/span>\r\n     Dim <\/span>bolSchluesselPruefen  As Boolean<\/span>\r\n     Dim <\/span>i As Integer<\/span>\r\n     Set<\/span> db = CurrentDb\r\n     Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblOptionen\", dbOpenDynaset)\r\n     If <\/span>Not<\/span> rst.EOF Then<\/span>\r\n         strEMail = rst!EMail\r\n         strSchluessel = rst!Schluessel\r\n         For i = 0 To 7\r\n             If <\/span>Verschluesseln(strEMail & \"xxx\" & i) = strSchluessel Then<\/span>\r\n                 bolSchluesselPruefen = True<\/span>\r\n                 Exit For<\/span>\r\n             Else<\/span>\r\n                 bolSchluesselPruefen = False<\/span>\r\n             End If<\/span>\r\n         Next<\/span> i\r\n     Else<\/span>\r\n         bolSchluesselPruefen = False<\/span>\r\n     End If<\/span>\r\n     SchluesselPruefen = i\r\nEnd Function<\/span><\/pre>\n
Listing 6: Neue Version der Funktion SchluesselPruefen<\/span><\/b><\/p>\n
Der neuen Version der Methode Form_Open<\/b>, welche beim öffnen des Formulars das Vorhandensein eines gültigen Schlüssels prüft, fügen wir eine MsgBox<\/b>-Anweisung hinzu, welche den gefundenen Wert von i<\/b> ausgibt. Auf diese Weise erfahren wir auch gleich, welcher Funktionsumfang für den aktuellen Schlüssel freigeschaltet wurde. Den Wert speichert die Prozedur in der Variablen intFunktionen<\/b>. Ist der Wert größer 0<\/b>, ruft die Prozedur außerdem das Formular frmAnwendung <\/b>auf und übergibt den Wert von intFunktionen <\/b>als öffnungsparameter. Die neue Version der Prozedur sieht wie folgt aus:<\/p>\n
Private Sub <\/span>Form_Open(Cancel As Integer<\/span>)\r\n     Dim <\/span>intFunktionen As Integer<\/span>\r\n     intFunktionen = SchluesselPruefen\r\n     If <\/span>intFunktionen > 0 Then<\/span>\r\n         MsgBox<\/span> \"Funktionsumfang: \" & intFunktionen\r\n        DoCmd.OpenForm \"frmAnwendung\", _\r\n            OpenArgs:=intFunktionen\r\n         Cancel = True<\/span>\r\n     End If<\/span>\r\nEnd Sub<\/span><\/pre>\n
Praktisches Beispiel für die Aktivierung von Funktionen<\/h2>\n
Nun wissen wir, dass der Wert 7 <\/b>für intFunktionen <\/b>alle drei Funktionen freischaltet, 4 <\/b>schaltet nur die dritte Funktion frei, 1 <\/b>nur die erste oder 5 <\/b>die erste und die dritte.<\/p>\n
Wie aber können wir dies umsetzen, wenn es tatsächlich daran geht, bestimmte Funktionen ein- oder auszuschalten Wir zeigen dies anhand eines Formulars, das drei Schaltflächen zum Ausführen der drei genannten Funktionen enthält und das im Entwurf wie in Bild 7 aussieht.<\/p>\n
\"Formular<\/p>\n
Bild 7: Formular mit Beispielfunktionsaufrufen<\/span><\/b><\/p>\n
Für das Ereignis Beim Laden <\/b>des Formulars hinterlegen wir nun die folgende Ereignisprozedur:<\/p>\n
Private Sub <\/span>Form_Load()\r\n     Dim <\/span>intFunktionen As Integer<\/span>\r\n     intFunktionen = Me.OpenArgs\r\n     If <\/span>Not<\/span> (intFunktionen And 1) = 1 Then<\/span>\r\n         Me!cmdFunktion1.Enabled = False<\/span>\r\n     End If<\/span>\r\n     If <\/span>Not<\/span> (intFunktionen And 2) = 2 Then<\/span>\r\n         Me!cmdFunktion2.Enabled = False<\/span>\r\n     End If<\/span>\r\n     If <\/span>Not<\/span> (intFunktionen And 4) = 4 Then<\/span>\r\n         Me!cmdFunktion3.Enabled = False<\/span>\r\n     End If<\/span>\r\nEnd Sub<\/span><\/pre>\n
Diese schreibt zunächst den vom aufrufenden Formular frmStart <\/b>übergebenen Wert aus dem öffnungsargument in die Variable intFunktionen<\/b>. Dann nutzt sie den binären Vergleich mit dem And<\/b>-Operator, um zu prüfen, ob der Wert 1<\/b>, 2 <\/b>oder 4 <\/b>in dem in intFunktionen <\/b>enthaltenen Wert enthalten sind. In unserem Fall lautete der Wert 4<\/b>, was das Ergebnis aus Bild 8 lieferte.<\/p>\n
\"Formular<\/p>\n
Bild 8: Formular mit einer freigeschalteten Funktion<\/span><\/b><\/p>\n
Den Wert von intFunktionen<\/b> können Sie auch in einer globalen Variablen oder in einer TempVar <\/b>speichern und dann von allen Stellen, an denen geprüft werden soll, ob eine Funktion freigeschaltet ist, abrufen. Damit lassen sich beispielsweise auch Ribbon-Schaltflächen aktivieren oder deaktivieren (mehr dazu im Beitrag Ribbon-Elemente aktivieren und deaktivieren<\/b>, www.access-im-unternehmen.de\/1122<\/b>).<\/p>\n
Zeitliche Limitierung der Freischaltung<\/h2>\n
Kommen wir zur letzten Aufgabe – der zeitlichen Limitierung der durch einen Freischaltschlüssel freigeschalteten Funktionen. Sie können beispielsweise eine zeitlich begrenzte Version einer Software herausgeben, damit der Benutzer diese etwa für einen Monat testen kann. Oder Sie verkaufen dem Benutzer nur eine zeitlich limitierte Lizenz für ein Programm, das einen neuen Registrierungsschlüssel benötigt, wenn der Nutzungszeitraum abgelaufen ist.<\/p>\n
Dazu schauen wir uns zwei Varianten an:<\/p>\n