<\/p>\n
Im Beitrag „SQL Server: Vollsicherung und Wiederherstellung“ haben wir uns angesehen, wie wir eine Sicherung einer SQL Server-Datenbank durchführen können. Wenn wir uns eine solche Sicherungsdatei im Texteditor ansehen, stellen wir schnell fest, dass in einem Backup, wie wir es in diesem Beitrag vorgestellt haben, die Daten unverschlüsselt gespeichert sind. Liegen solche Daten im heimischen Server, der durch das Windows-Sicherheitssystem vor Zugriffen Fremder gesichert ist, mag das praktikabel sein. Sollen jedoch Kopien von diesen Daten angelegt werden, die nicht auf diese Weise gesichert sind, ist eine zusätzliche Verschlüsselung nötig. Das verschlüsselte Sichern einer SQL Server-Datenbank ist wesentlich aufwendiger als die einfache Sicherung. Deshalb schauen wir uns dies Schritt für Schritt im vorliegenden Beitrag an.<\/b><\/p>\n
Im Beitrag SQL Server: Vollsicherung und Wiederherstellung <\/b>(www.access-im-unternehmen.de\/14<\/b>) haben wir uns bereits angesehen, wie wir unter dem SQL Server eine einfache Vollsicherung einer Datenbank durchführen können. Dort haben wir außerdem gezeigt, wie wir diese Sicherung zeitlich gesteuert automatisiert durchführen lassen können.<\/p>\n
In einem weiteren Beitrag mit dem Titel Zertifikate und Kennwörter mit Keepass speichern <\/b>(www.access-im-unternehmen.de\/1451<\/b>) haben wir das Tool Keepass vorgestellt, mit dem wir Daten wie Kennwörter oder Zertifikate speichern können. Dieses Tool werden wir in der folgenden Abhandlung nutzen, um die für die Wiederherstellung benötigten Daten sicher zu speichern. Denn was hilft eine verschlüsselte Kopie einer Datenbank, wenn die zum Entschlüsseln nötigen Informationen irgendwo auf der Festplatte herumliegen – oder noch besser auf einem Zettel an der Pinnwand?<\/p>\nSchlüssel und Zertifikat als Voraussetzung<\/h2>\n
Für das Verschlüsseln des Backups einer Datenbank benötigen wir einen Schlüssel und für diesen Schlüssel ein Zertifikat. Diese werden zum Verschlüsseln verwendet und auch zum Entschlüsseln, wenn eine Datenbank auf Basis einer verschlüsselten Datenbank wiederhergestellt werden soll. Dieses erstellen wir direkt im SQL Server Management Studio.<\/p>\n
Den Schlüssel und das Zertifikat legen wir über T-SQL-Abfragen an, die wir im Kontext der Master<\/b>-Datenbank des SQL Servers ausführen. Dazu öffnen wir im Objekt-Explorer des SQL Server Management Studios das Element Databases||System Databases<\/b> und klicken mit der rechten Maustaste auf den Eintrag Master<\/b>. Im Kontextmenü führen wir den Befehl New Query <\/b>aus (siehe Bild 1).<\/p>\n
![\"Neue](\"..\/fileadmin\/_temp_\/2023_05\/pic_1450_001.png\")
<\/p>\n
Bild 1: Neue Abfrage für die Master-Datenbank<\/span><\/b><\/p>\n Als Erstes legen wir über eine T-SQL-Abfrage den sogenannten Master-Key für die Master-Datenbank an. Dazu nutzen wir den folgenden Befehl, mit dem wir den zu erstellenden Key angeben:<\/p>\n Der CREATE MASTER KEY<\/b>-Befehl erstellt einen Master-Key, der für die Verschlüsselung von Daten innerhalb der Datenbank verwendet wird. Der Schlüssel wird durch das angegebene Kennwort geschützt.<\/p>\n Das N<\/b>-Präfix vor dem Kennwort gibt an, dass es sich um eine Unicode-Zeichenkette handelt.<\/p>\n Damit das Kennwort nicht leicht erraten werden kann, wollen wir es nicht wie im obigen Beispiel selbst vergeben, sondern das im oben angegebenen Beitrag Zertifikate und Kennwörter mit Keepass speichern <\/b>verwendete Tool Keepass <\/b>nutzen.<\/p>\n Nachdem wir dieses geöffnet haben, fügen wir als Erstes einen neuen Unterordner unter Database <\/b>namens SQLServer <\/b>hinzu. Hier sollen alle Elemente gespeichert werden, die mit dem SQL Server in Verbindung stehen. Dazu markieren wir den zuvor angelegten Ordner SQLServer <\/b>und wählen aus dem Menü den Befehl Eintrag hinzufügen <\/b>aus (siehe Bild 2).<\/p>\n Bild 2: Einfügen eines neuen Eintrags in KeePass<\/span><\/b><\/p>\n Danach öffnet sich der Dialog Eintrag hinzufügen<\/b>. Hier geben wir als Titel beispielsweise Masterkey für Datenbank Master <\/b>an. Außerdem lassen wir uns durch einen Klick auf die Schaltfläche mit den drei Punkten das bereits automatisch generierte Kennwort anzeigen (siehe Bild 3). Das ist notwendig, da wir es ja noch kopieren und in unser T-SQL-Skript einfügen wollen. Wenn Sie das Kennwort neu generieren lassen möchten, können Sie dazu die Schaltfläche Ein Passwort generieren <\/b>nutzen, das rechts neben dem Feld Passwort-Wdh. <\/b>angezeigt wird. Das Kennwort kopieren wir nun in die Zwischenablage.<\/p>\n Bild 3: Erstellen eines neuen Kennworts<\/span><\/b><\/p>\n Nun folgt ein wichtiger Schritt – das Speichern des Kennworts in KeePass<\/b>. Dazu schließen Sie den Dialog Eintrag hinzufügen <\/b>und finden im Hauptfenster von KeePass <\/b>den neuen Eintrag aus Bild 4 vor.<\/p>\n Bild 4: Der gespeicherte Schlüssel in KeePass<\/span><\/b><\/p>\n Das Kennwort aus der Zwischenablage fügen wir nun wie folgt an Stelle des bisher verwendeten Kennworts DiesIstDerSchluessel <\/b>in der CREATE MASTER KEY<\/b>-Anweisung ein:<\/p>\n Diesen Befehl können wir nun mit F5<\/b> ausführen und erhalten die Meldung aus Bild 5 als Ergebnis.<\/p>\n Bild 5: Anlegen eines Schlüssels für die Master-Datenbank<\/span><\/b><\/p>\n Nun wollen wir ein Zertifikat anlegen, das mit dem soeben erstellten Master-Key verschlüsselt wird. Dazu erstellen wir mit der folgenden Anweisung im gleichen Abfragefenster ein Zertifikat:<\/p>\n Der CREATE CERTIFICATE<\/b>-Befehl erstellt ein Zertifikat mit dem angegebenen Namen. Das Zertifikat wird verwendet, um Sicherungen der angegebenen Datenbank zu verschlüsseln. Das Zertifikat hat eine Beschreibung (N“Zertifikat zum Verschlüsseln der Sicherung der Datenbank Experimente“<\/b>) und ein Ablaufdatum (N“20401231“<\/b>).<\/p>\n Auch diesen Befehl führen wir nun aus. Damit der Befehl zum Erstellen des Schlüssels nicht ebenfalls ausgeführt wird, markieren wir nur den auszuführenden Befehl und betätigen anschließend die Taste F5<\/b>, um diesen auszuführen.<\/p>\n Damit haben wir das Zertifikat erstellt und es ist nun im Objekt-Explorer der master<\/b>-Datenbank unter Security|Certificates <\/b>zu finden (siehe Bild 6).<\/p>\n Bild 6: Das Zertifikat im Objekt-Explorer<\/span><\/b><\/p>\n Dieses Zertifikat können wir nun zur Verschlüsselung des Backups und zum Entschlüsseln beim Wiederherstellen des Backups verwenden. Der Haken ist jedoch: Wenn tatsächlich der komplette Rechner beschädigt wird und wir nicht mehr auf die SQL Server-Instanz zugreifen können, lässt sich auch die Sicherung der Datenbank nicht wiederherstellen.<\/p>\n Also müssen wir auch das Zertifikat sichern. Dazu nutzen wir einen weiteren T-SQL-Befehl, der wie in Listing 1 aussieht.<\/p>\n Listing 1: T-SQL-Skript zum Sichern des Zertifikats<\/span><\/b><\/p>\n Durch Ausführen dieses Skripts wird eine Sicherung des Zertifikats certBackup_Experimente<\/b> erstellt, die aus der Zertifikatsdatei und der privaten Schlüsseldatei besteht.<\/p>\n Diese Dateien werden auf den angegebenen Speicherorten auf der Festplatte gespeichert. Die Sicherung kann später verwendet werden, um das Zertifikat und den privaten Schlüssel wiederherzustellen, falls dies erforderlich ist.<\/p>\n Der BACKUP CERTIFICATE<\/b>-Befehl erstellt eine Sicherungskopie des Zertifikats mit dem Namen certBackup_Experimente<\/b>. Das Zertifikat wird in zwei separate Dateien gesichert.<\/p>\n [<\/p>\n Die Zertifikatsdatei (.cer<\/b>) wird angegeben durch den Parameter TO FILE <\/b>mit dem Pfad “C:\\…\\certBackup_Experimente.cer“<\/b>. Hier wird das Zertifikat im Zertifikatstransferformat gespeichert.<\/p>\n Die private Schlüsseldatei (.pvk<\/b>) wird angegeben durch den Parameter WITH PRIVATE KEY <\/b>mit dem Schlüssel ENCRYPTION BY PASSWORD = N“Zertifikatskennwort“ <\/b>und dem Dateinamen mit FILE = N“C:\\…\\certBackup_Experimente.pvk“<\/b>. <\/p>\n Statt der drei Punkte in den beispielhaften Pfadangaben geben Sie ein Verzeichnis an, in dem die Dateien gesichert werden sollen. Aus diesem übertragen wir die Dateien später in KeePass<\/b>. Es kann sein, dass dies einen Fehler liefert. Der Grund ist meist, dass der SQL Server keine Berechtigungen hat, in das angegebene Verzeichnis zu schreiben.<\/p>\n Um dies zu umgehen, ohne diese Berechtigungen entsprechend setzen zu müssen, verwenden wir ein Verzeichnis, in das der SQL Server auf jeden Fall schreiben kann – nämlich das Verzeichnis, in dem sich auch die Datenbankdateien befinden. Dieser Pfad lautet beispielsweise wie folgt:<\/p>\n Statt des hier verwendeten Kennwort-Platzhalters Zertifikatskennwort <\/b>geben Sie ein neues Kennwort an, dass sie wieder mit Keepass erstellen. Dieses versehen wir wieder mit einem aussagekräftigen Titel, hier Key für Zertifikat der Datenbank „Experimente“ <\/b>(siehe Bild 7). Bevor wir dieses Kennwort durch Schließen des Dialogs speichern, kopieren wir es wieder in die Zwischenablage. <\/p>\n Bild 7: Anlegen eines privaten Schlüssels<\/span><\/b><\/p>\n KeePass enthält nun zwei Einträge wie in Bild 8. Das Kennwort aus der Zwischenablage fügen wir für den Parameter DECRYPTION BY PASSWORD <\/b>in den T-SQL-Befehl ein. Achten Sie beim Einfügen darauf, dass Sie nicht Leerzeichen oder andere nicht erwünschte Elemente zwischen den Hochkommata einfügen.<\/p>\n Bild 8: Der private Schlüssel für das Zertifikat in KeePass<\/span><\/b><\/p>\n Den Befehl fügen wir wieder im Abfragefenster für die Datenbank master <\/b>ein, markieren diesen und führen ihm mit F5<\/b> aus, was wie in Bild 9 aussieht.<\/p>\n Bild 9: Sichern des Zertifikats auf der Festplatte<\/span><\/b><\/p>\n Nach dem Ausführen landen die beiden Dateien in dem angegebenen Verzeichnis – hier der Einfachheit halber c:\\Keepass <\/b>genannt (siehe Bild 10).<\/p>\n Bild 10: Das Zertifikat und die Schlüsseldatei auf der Festplatte<\/span><\/b><\/p>\n Nochmal zur Sicherheit: Diese Dateien dürfen nicht verloren gehen, denn sonst können Sie ein damit verschlüsseltes Backup einer Datenbank nicht wieder entschlüsseln.<\/p>\n Die Zertifikatsdatei und den Schlüssel haben wir zwar nun im Dateisystem gespeichert, allerdings hilft uns das auch nicht weiter, wenn der Rechner nicht mehr funktioniert oder anderweitig nicht mehr zugreifbar ist.<\/p>\n Also müssen wir diese auch noch separat sichern, und zwar so, dass diese Sicherung auch nach einem Verlust des Rechners noch wiederhergestellt werden kann.<\/p>\n In diesem Fall nutzen wir KeePass gleich noch ein zweites Mal: Wir öffnen wieder den Eintrag Key für Zertifikat der Datenbank „Experimente“ <\/b>und wechseln dort zur Registerseite Erweitert<\/b>. Hier klicken wir unter Dateianhänge auf Anhängen und fügen die .cer <\/b>und die .pvk<\/b>-Datei ein (siehe Bild 11). Danach schließen wir den Dialog Eintrag bearbeiten <\/b>wieder.<\/p>\n Bild 11: Sichern der Zertifikatsdatei und der Schlüsseldatei in KeePass<\/span><\/b><\/p>\n Damit sind die Vorbereitungen abgeschlossen und wir können uns dem eigentlichen Backup zuwenden. Dazu klicken wir im SQL Server Management Studio mit der rechten Maustaste auf die zu sichernde Datenbank und wählen den Befehl Tasks|Backup… <\/b>aus. Dies öffnet den Dialog Backup Database – Experimente<\/b>.<\/p>\n Die Einstellungen auf der ersten Seite können wir beibehalten – wir wollen ein volles Backup erstellen und SIMPLE <\/b>als Recovery Model <\/b>nutzen (siehe Bild 12).<\/p>\n Bild 12: Einstellungen des Backups bearbeiten<\/span><\/b><\/p>\n Dann wechseln wir zum Bereich Media Options. Hier wählen wir die Option Back up to a new media set, and erase all existing backups sets <\/b>aus.<\/p>\n Diesem geben wir eine Bezeichnung, die Sie frei wählen können – es wird nur festgelegt, welcher Sicherungssatz überhaupt verschlüsselt werden soll. Wir nutzen zum Beispiel Experimente_MediaSet<\/b> (siehe Bild 13).<\/p>\n Bild 13: Definieren eines neuen Media Sets<\/span><\/b><\/p>\n Auf der dritten Seite mit dem Titel Backup options <\/b>stellen wir nun ein, dass wir das Backup verschlüsseln wollen. Dazu aktivieren wir unter Encryption <\/b>die Option Encrypt backup<\/b>. Unter Algorithm können wir einen der verfügbaren Verschlüsselungs-Algorithmen auswählen.<\/p>\n Und für Certificate or Asymmetric key<\/b> wählen wir unser Zertifikat certBackup_Experimente <\/b>aus (siehe Bild 14).<\/p>\n Bild 14: Verschlüsselungseinstellungen<\/span><\/b><\/p>\n Achtung: Wir wollen weder jetzt noch gleich im Anschluss die OK<\/b>-Schaltfläche betätigen, da dies sonst direkt das Backup erstellt. Wir schreiben lediglich das Skript zum Erstellen des Backups, das wir dann einem Job zuweisen, den wir wiederum zeitlich gesteuert ausführen können.<\/p>\n Damit erstellen wir nun ein T-SQL-Skript in einem neuen Job. Dazu wählen wir oben unter Script den Eintrag Script Action to Job <\/b>aus. Dies öffnet den Dialog New Job<\/b>, in dem wir erst einmal nur den Namen anpassen. Anschließend schließen und speichern wir den Job mit einem Klick auf die OK<\/b>-Schaltfläche (siehe Bild 15).<\/p>\n Bild 15: Neuer Job<\/span><\/b><\/p>\n Das noch geöffnete Fenster Back Up Database – Experimente <\/b>schließen wir hingegen mit einem Klick auf die Abbrechen<\/b>-Schaltfläche.<\/p>\n Nun wechseln wir im Objekt-Explorer zum Bereich SQL Server Agent|Jobs <\/b>und klicken dort mit der rechten Maustaste auf den Eintrag Back Up Database – Experimente<\/b> und wählen aus dem Kontextmenü den Eintrag Properties <\/b>aus.<\/p>\n Dies öffnet den Dialog Job Properties <\/b>zu diesem Job.<\/p>\n Wechseln wir hier zum Bereich Steps<\/b>, sehen wir den einzigen Schritt dieses Jobs (siehe Bild 16).<\/p>\n Bild 16: Anzeige der Schritte des Jobs<\/span><\/b><\/p>\n Markieren wir diesen und betätigen dann die Schaltfläche Edit<\/b>, sehen wir das auszuführende Skript.<\/p>\n Dieses haben wir in Listing 2 abgebildet.<\/p>\n Listing 2: T-SQL-Skript zum Sichern der Datenbank mit Verschlüsselung<\/span><\/b><\/p>\n Hier sehen wir, dass neben den üblichen Informationen auch Schlüsselwort ENCRYPTION <\/b>angegeben wird mit dem zu verwendenden Algorithmus und dem Zertifikat.<\/p>\n Wir haben im Beitrag SQL Server: Vollsicherung und Wiederherstellung <\/b>(www.access-im-unternehmen.de\/14<\/b>) bereits eine unverschlüsselte Sicherung einer Beispieldatenbank erstellt.<\/p>\n Wenn wir den Inhalt dieser gesicherten Datei in einem Texteditor öffnen, sehen wir einige Informationen im Klartext (siehe Bild 17).<\/p>\n Bild 17: Unverschlüsseltes Backup einer Datenbank<\/span><\/b><\/p>\n Die Daten sind zwar nicht direkt durchsuchbar, weil zwischen zwei Zeichen beispielsweise aus den Daten einer Tabelle Zeichen wie vbNullString <\/b>enthalten sind. Aber mit einem Texteditor, der reguläre Ausdrücke unterstützt, lässt sich dennoch nach den gewünschten Texten suchen.<\/p>\n Das Backup einer Datenbank mit sensiblen Informationen wie beispielsweise Kundendaten sollte man nicht auf diese Weise anlegen<\/p>\n Anders hingegen sieht es mit einem verschlüsselten Backup aus. Um uns dies anzusehen, starten wir den Job, den wir soeben angelegt haben und rufen den Kontextmenü-Eintrag Start Job at Step… <\/b>des Jobs im Objekt-Explorer auf. Dies startet den Job und liefert das Ergebnis aus Bild 18.<\/p>\n Bild 18: Ausführen des Jobs zum Erstellen eines verschlüsselten Backups<\/span><\/b><\/p>\n Schauen wir uns die erzeugte Backup-Datei dann im Texteditor an, finden wir nur noch einen verschlüsselten und damit für das menschliche Auge unlesbaren Text vor (siehe Bild 19).<\/p>\n Bild 19: Verschlüsseltes Backup einer Datenbank<\/span><\/b><\/p>\n Wenn Sie einfach nur ein verschlüsseltes Backup wiederherstellen wollen, um beispielsweise zu einem älteren Stand zurückzukehren, gelingt das recht einfach. Dazu klicken wir mit der rechten Maustaste auf die Datenbank im Objekt-Explorer und wählen den Befehl Tasks|Restore|Database <\/b>aus. Im folgenden Dialog Restore Database <\/b>wählen wir, soweit vorhanden, den Namen der wiederherzustellenden Datenbank aus der Liste des Feldes Database <\/b>aus (siehe Bild 20). Alternativ selektieren wir hier die Option Device <\/b>und wählen das Medium mit dem Backup aus.<\/p>\n Bild 20: Wiederherstellen einer Datenbank<\/span><\/b><\/p>\n Etwas aufwendiger ist es, wenn wir den Rechner beziehungsweise die Festplatte verlieren und die Datenbank auf einem neuen Rechner wiederherstellen müssen. Dann übertragen wir die folgenden Dateien auf diesen Rechner:<\/p>\n Dann erstellen wir den Master Key für den neuen SQL Server, sofern dieser noch nicht existiert. Anschließend erstellen wir das Zertifikat, das wir zuvor gesichert haben, auf dem neuen Rechner. Danach können wir schließlich die Sicherung wiederherstellen.<\/p>\n Dazu öffnen wir wieder eine Abfrage für die Datenbank Master. Um das zu erledigen, klicken wir mit der rechten Maustaste auf den Eintrag Datenbanken|Systemdatenbanken|master <\/b>und wählen aus dem Kontextmenü den Eintrag Neue Abfrage <\/b>aus (siehe Bild 21).<\/p>\n Bild 21: Neue Abfrage zum Erstellen des neuen Master Keys<\/span><\/b><\/p>\n Ob der Master Key gegebenenfalls bereits vorhanden ist, können wir mit der folgenden Abfrage prüfen:<\/p>\n Finden wir hier nicht wie in Bild 22 einen Eintrag mit dem Wert master <\/b>im Feld name <\/b>und dem Wert 1 <\/b>im Feld is_master_key_encrypted_by_server <\/b>vor, geben wir den gleichen Befehl nochmal ein, den wir bereits eingangs verwendet haben:<\/p>\n Bild 22: Abfrage zum Ermitteln der Master Keys<\/span><\/b><\/p>\n Danach erstellen wir das Zertifikat aufgrund der zuvor gesicherten Dateien certBackup_Experimente.cer <\/b>und certBackup_Experimente.pvk<\/b>. Auch hier können wir zuvor prüfen, ob dieses bereits im Zertifikatsspeicher des SQL Servers enthalten ist. <\/p>\n Das erledigen wir mit der folgenden Anweisung:<\/p>\n Das Ergebnis sehen Sie in Bild 23.<\/p>\n Bild 23: Prüfen, ob das Zertifikat bereits installiert ist.<\/span><\/b><\/p>\n Ist dieses nicht vorhanden, können wir es wie folgt aus der gesicherten Version wiederherstellen:<\/p>\n Damit fehlt nun nur noch das Wiederherstellen des eigentlichen Backups. Hier sind wir in unserem Fall mit der folgenden Anweisung gestartet, die eigentlich ausreicht:<\/p>\n Allerdings haben wir auf dem neuen Testrechner auch eine neuere Version des SQL Servers installiert, nämlich Version 16 statt der auf dem vorherigen Rechner installierten Version 15. Der Befehl findet nun allerdings Dateien vor, die für Version 15 vorgesehen sind. Daher müssen wir noch das MOVE<\/b>-Schlüsselwort wie folgt hinzuziehen:<\/p>\n Damit werden die Dateien nun nicht mehr in dem Verzeichnis wiederhergestellt, das wir unter SQL Server 15 verwendet haben, sondern in dem aktuell verwendeten. Um herauszufinden, wie die Bezeichnung der wiederherzustellenden Dateien im Backup ist, können wir übrigens diesen Befehl verwenden:<\/p>\n Dieser Beitrag zeigt, wie wir eine Datenbank des SQL Servers in ein verschlüsseltes Backup sichern und wiederherstellen können. Dazu haben wir einen Master Key angelegt, in dessen Kontext wir ein Zertifikat für die zu verschlüsselnde Datenbank erstellt haben.<\/p>\n Dieses haben wir genutzt, um die Datenbank verschlüsselt zu sichern, also so, dass man der Sicherungsdatei keine Informationen mehr entnehmen kann, wenn man diese beispielsweise mit einem Texteditor öffnet.<\/p>\n Anschließend haben wir auf einem neuen Rechner mit einer neuen SQL Server-Installation zuerst einen Master Key festgelegt, dann das Zertifikat wiederhergestellt und damit schließlich die Datenbank aus dem Backup eingespielt.<\/p>\n","protected":false},"excerpt":{"rendered":" Im Beitrag „SQL Server: Vollsicherung und Wiederherstellung“ haben wir uns angesehen, wie wir eine Sicherung einer SQL Server-Datenbank durchführen können. Wenn wir uns eine solche Sicherungsdatei im Texteditor ansehen, stellen wir schnell fest, dass ein Backup, wie wir es in diesem Beitrag vorgestellt haben, nicht verschlüsselt abgelegt wird, sondern den unverschlüsselten Text enthält. Liegen solche Daten im heimischen Server, der durch das Windows-Sicherheitssystem vor Zugriffen Fremder gesichert ist, mag das praktikabel sein. Sollen jedoch Kopien von diesen Daten angelegt werden, die nicht auf diese Weise gesichert sind, ist eine zusätzliche Verschlüsselung nötig. Das verschlüsselte Sichern einer SQL Server-Datenbank ist wesentlich aufwendiger als die einfache Sicherung. Deshalb schauen wir uns dies Schritt für Schritt im vorliegenden Beitrag an.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"footnotes":""},"categories":[662023,66052023,44000022],"tags":[],"class_list":["post-55001450","post","type-post","status-publish","format-standard","hentry","category-662023","category-66052023","category-SQL_Server_und_Co"],"yoast_head":"\nMaster-Key für die Master-Datenbank<\/h2>\n
CREATE MASTER KEY \r\n ENCRYPTION BY PASSWORD = N''DiesIstDerSchluessel''; \r\nGO<\/pre>\n
![\"Einfügen](\"..\/fileadmin\/_temp_\/2023_05\/pic_1450_003.png\")
<\/p>\n![\"Erstellen](\"..\/fileadmin\/_temp_\/2023_05\/pic_1450_004.png\")
<\/p>\n![\"Der](\"..\/fileadmin\/_temp_\/2023_05\/pic_1450_006.png\")
<\/p>\nMaster Key anlegen<\/h2>\n
CREATE MASTER KEY \r\n ENCRYPTION BY PASSWORD = N''PqM8BMLK5x7BBNejCxfh''; \r\nGO<\/pre>\n
![\"Anlegen](\"..\/fileadmin\/_temp_\/2023_05\/pic_1450_005.png\")
<\/p>\nZertifikat erstellen<\/h2>\n
CREATE CERTIFICATE certBackup_Experimente\r\n WITH SUBJECT = N''Zertifikat zum Verschlüsseln der Sicherung der Datenbank Experimente'',\r\n EXPIRY_DATE = N''20401231''; <\/pre>\n
![\"Das](\"..\/fileadmin\/_temp_\/2023_05\/pic_1450_007.png\")
<\/p>\nZertifikat und privaten Zertifikatsschlüssel als Datei sichern<\/h2>\n
BACKUP CERTIFICATE certBackup_Experimente \r\n TO FILE = N''C:\\...\\certBackup_Experimente.cer''\r\n WITH PRIVATE KEY \r\n (ENCRYPTION BY PASSWORD = N''Zertifikatskennwort'', FILE = N''C:\\...\\certBackup_Experimente.pvk'');\r\nGO<\/pre>\n
C:\\Program Files\\Microsoft SQL Server\\MSSQL15.MSSQLSERVER\\MSSQL\\DATA<\/pre>\n
![\"Anlegen](\"..\/fileadmin\/_temp_\/2023_05\/pic_1450_010.png\")
<\/p>\n![\"Der](\"..\/fileadmin\/_temp_\/2023_05\/pic_1450_011.png\")
<\/p>\n![\"Sichern](\"..\/fileadmin\/_temp_\/2023_05\/pic_1450_008.png\")
<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2023_05\/pic_1450_009.png\")
<\/p>\nZertifikat und Schlüssel in KeePass sichern<\/h2>\n
![\"Sichern](\"..\/fileadmin\/_temp_\/2023_05\/pic_1450_012.png\")
<\/p>\nVerschlüsseltes Backup anlegen<\/h2>\n
![\"Einstellungen](\"..\/fileadmin\/_temp_\/2023_05\/pic_1450_013.png\")
<\/p>\n![\"Definieren](\"..\/fileadmin\/_temp_\/2023_05\/pic_1450_014.png\")
<\/p>\n![\"Verschlüsselungseinstellungen\"](\"..\/fileadmin\/_temp_\/2023_05\/pic_1450_015.png\")
<\/p>\nNeuen Job erstellen<\/h2>\n
![\"Neuer](\"..\/fileadmin\/_temp_\/2023_05\/pic_1450_016.png\")
<\/p>\nNeuen Job ansehen<\/h2>\n
![\"Anzeige](\"..\/fileadmin\/_temp_\/2023_05\/pic_1450_017.png\")
<\/p>\nBACKUP DATABASE [Experimente] TO DISK = N''C:\\...\\Backup\\Experimente_Backup.bak'' WITH FORMAT, INIT, \r\nMEDIANAME = N''Experimente_MediaSet'', NAME = N''Experimente-Full Database Backup'', SKIP, NOREWIND, NOUNLOAD, \r\nENCRYPTION(ALGORITHM = AES_128, SERVER CERTIFICATE = [certBackup_Experimente]), STATS = 10\r\nGO<\/pre>\n
Unterschied zwischen der verschlüsselten und der unverschlüsselten Datei<\/h2>\n
![\"Unverschlüsseltes](\"..\/fileadmin\/_temp_\/2023_05\/pic_1450_018.png\")
<\/p>\n![\"Ausführen](\"..\/fileadmin\/_temp_\/2023_05\/pic_1450_019.png\")
<\/p>\n![\"Verschlüsseltes](\"..\/fileadmin\/_temp_\/2023_05\/pic_1450_020.png\")
<\/p>\nWiederherstellung eines verschlüsselten Backups<\/h2>\n
![\"Wiederherstellen](\"..\/fileadmin\/_temp_\/2023_05\/pic_1450_021.png\")
<\/p>\nWiederherstellen eines verschlüsselten Backups auf einem anderen Rechner<\/h2>\n
\n
Master Key auf dem neuen Rechner erstellen<\/h2>\n
![\"Neue](\"..\/fileadmin\/_temp_\/2023_05\/pic_1450_022.png\")
<\/p>\nSELECT name, is_master_key_encrypted_by_server \r\nFROM sys.databases<\/pre>\n
![\"Abfrage](\"..\/fileadmin\/_temp_\/2023_05\/pic_1450_023.png\")
<\/p>\nCREATE MASTER KEY \r\n ENCRYPTION BY PASSWORD = N''DiesIstDerSchluessel''; \r\nGO<\/pre>\n
SELECT name, certificate_id, principal_id, pvt_key_encryption_type_desc, subject, start_date, expiry_date\r\nFROM sys.certificates;<\/pre>\n
![\"Prüfen,](\"..\/fileadmin\/_temp_\/2023_05\/pic_1450_024.png\")
<\/p>\nCREATE CERTIFICATE certBackup_Experimente \r\n FROM FILE = N''C:\\...\\certBackup_Experimente.cer'' \r\n WITH PRIVATE KEY (FILE = N''C:\\...\\certBackup_Experimente.pvk'', \r\n DECRYPTION BY PASSWORD = N''DiesIstDerSchluessel''); \r\nGO<\/pre>\n
RESTORE DATABASE Experimente\r\nFROM DISK = ''C:\\Daten\\Experimente_Backup.bak''\r\nWITH NORECOVERY<\/pre>\n
RESTORE DATABASE Experimente\r\nFROM DISK = ''C:\\Daten\\Experimente_Backup.bak''\r\nWITH MOVE ''Experimente'' TO ''C:\\Program Files\\Microsoft SQL Server\\MSSQL16.MSSQLSERVER\\MSSQL\\DATA\\Experimente.mdf'',\r\n MOVE ''Experimente_log'' TO ''C:\\Program Files\\Microsoft SQL Server\\MSSQL16.MSSQLSERVER\\MSSQL\\DATA\\Experimente_log.ldf'',\r\n NORECOVERY<\/pre>\n
RESTORE FILELISTONLY\r\nFROM DISK = ''C:\\...\\Experimente_Backup.bak''<\/pre>\n
Zusammenfassung und Ausblick<\/h2>\n