Einsteigerhandbuch zu Ruby on Rails: Bearbeiten von Anmeldeinformationen und verschlüsselten Geheimnissen

Ruby on Rails, oft auch nur Rails genannt, ist ein leistungsfähiges Webanwendungs-Framework, das auf der Programmiersprache Ruby basiert. Eines seiner wichtigsten Merkmale ist die Möglichkeit, sensible Daten wie API-Schlüssel, Datenbankanmeldeinformationen und andere Geheimnisse durch verschlüsselte Anmeldeinformationen sicher zu verwalten. Dieser Leitfaden soll Anfängern die Arbeit mit dem Anmeldesystem von Rails näher bringen, wobei der Schwerpunkt auf der Bearbeitung von Anmeldedaten und der effektiven Verwaltung verschlüsselter Geheimnisse liegt. Am Ende werden Sie ein klares Verständnis davon haben, wie Sie sensible Informationen in Ihrer Rails-Anwendung sicher handhaben können, mit praktischen Beispielen und Best Practices.

In diesem Artikel wird davon ausgegangen, dass Sie ein grundlegendes Verständnis von Ruby und Rails haben, z. B. wie man eine Rails-Anwendung einrichtet und in der Verzeichnisstruktur navigiert. Wenn Sie neu in Rails sind, sollten Sie sich die offizielle Ruby auf Schienen Leitfäden für grundlegendes Wissen. Tauchen Sie ein in die Welt der Rails-Anmeldedaten und verschlüsselten Geheimnisse!

Verständnis von Rails Credentials und verschlüsselten Geheimnissen

Was sind Rails Credentials?

Rails-Credentials bieten eine sichere Möglichkeit, sensible Informationen wie API-Schlüssel, Passwörter oder Token zu speichern, die Ihre Anwendung zum Funktionieren benötigt. Im Gegensatz zu fest kodierten Werten im Quellcode oder unverschlüsselten Konfigurationsdateien werden Rails-Anmeldeinformationen verschlüsselt und in einer Datei namens config/credentials.yml.enc. Diese Datei kann sicher an die Versionskontrolle (z. B. Git) übergeben werden, da sie verschlüsselt ist und somit keine sensiblen Daten offengelegt werden.

Die Verschlüsselung wird mit einem Hauptschlüssel verwaltet, der in config/master.key oder einen umgebungsspezifischen Schlüssel (z.B., config/credentials/production.key). Der Hauptschlüssel wird zum Ver- und Entschlüsseln der Anmeldedatei verwendet und sollte niemals der Versionskontrolle unterworfen werden, um einen unbefugten Zugriff auf Ihre Geheimnisse zu verhindern.

Entwicklung des Secrets Management in Rails

Vor Rails 5.1 wurden sensible Daten oft in config/geheimnisse.ymldie nicht verschlüsselt war und ein Sicherheitsrisiko darstellte, wenn sie versehentlich in ein Repository übertragen wurde. Mit Rails 5.1 wurden verschlüsselte Geheimnisse eingeführt, und ab Rails 5.2 wurde dieses System zu dem heute verwendeten Anmeldesystem weiterentwickelt. Ab Rails 6 können Sie umgebungsspezifische Anmeldeinformationen verwalten, die separate Geheimnisse für Entwicklungs-, Test- und Produktionsumgebungen ermöglichen. Diese Entwicklung war eine Antwort auf die Herausforderungen in Teamumgebungen, in denen der sichere Austausch sensibler Daten umständlich war.

Warum verschlüsselte Anmeldeinformationen verwenden?

Verschlüsselte Anmeldedaten lösen mehrere Probleme:

• Sicherheit: Sensible Daten werden verschlüsselt, um das Risiko einer Aufdeckung zu verringern.
• Versionskontrolle: Die verschlüsselte credentials.yml.enc Datei sicher an Git übergeben werden kann.
• Teamzusammenarbeit: Entwickler können eine Codebasis gemeinsam nutzen, ohne Geheimnisse preiszugeben, indem sie einen sicher geteilten Hauptschlüssel verwenden (z. B. über einen Passwortmanager).
• Umweltspezifische Geheimnisse: Rails unterstützt separate Anmeldeinformationen für verschiedene Umgebungen, was die Bereitstellung vereinfacht.

Rails-Anmeldeinformationen einrichten

Erstellen einer neuen Rails-Anwendung

Um mitzumachen, müssen Sie sicherstellen, dass Ruby und Rails installiert sind. Sie können Ihre Versionen mit überprüfen:

bash
ruby -v
schienen -v

Wenn Rails nicht installiert ist, installieren Sie es mit:

bash
gem install rails

Erstellen Sie eine neue Rails-Anwendung:

bash
rails new myapp
cd myapp

Wenn Sie eine neue Rails-Anwendung erstellen, erzeugt Rails automatisch zwei Schlüsseldateien in der config Verzeichnis:

• config/credentials.yml.enc: Die verschlüsselte Datei, in der die Anmeldeinformationen gespeichert sind.
• config/master.key: Der zum Entschlüsseln verwendete Verschlüsselungsschlüssel credentials.yml.enc.

Das ist wichtig: Niemals verpflichten config/master.key zur Versionskontrolle. Fügen Sie es zu Ihrem .gitignore Datei, um eine versehentliche Exposition zu verhindern.

Überprüfen Ihrer Anmeldeinformationen Einrichtung

Um zu überprüfen, ob die Datei mit den Anmeldeinformationen existiert, prüfen Sie die config Verzeichnis:

bash
ls config/

Sie sollten sehen credentials.yml.enc Und master.key. Wenn master.key fehlt, wird Rails beim ersten Bearbeiten der Anmeldeinformationen eine generieren (siehe unten).

Rails-Anmeldeinformationen bearbeiten

Öffnen der Berechtigungsnachweisdatei

Verwenden Sie zum Bearbeiten von Anmeldeinformationen den Rails-Befehl:

bash
EDITOR="vim" Schienen Anmeldeinformationen:edit

Dieser Befehl öffnet die entschlüsselte config/credentials.yml.enc in dem von Ihnen angegebenen Editor (z. B. Vim, Nano oder VS Code). Ersetzen Sie "vim" mit Ihrem bevorzugten Editor, z. B. "Code" für VS Code. Wenn <code.config/credentials.yml.enc oder config/master.key nicht existiert, wird Rails sie erstellen.

Wenn Sie den Befehl ausführen, erhalten Sie eine YAML-formatierte Datei. Eine Standard-Anmeldedatei könnte wie folgt aussehen:

yaml
# Wird als Basisgeheimnis für alle MessageVerifier in Rails verwendet, einschließlich desjenigen, der Cookies schützt.
secret_key_base: your_secret_key_base

Die geheim_schlüssel_basis ist ein wichtiger Wert, der zum Signieren und Verschlüsseln von Cookies und anderen Daten in Rails verwendet wird. Er wird automatisch generiert, wenn Sie eine neue Rails-Anwendung erstellen.

Hinzufügen neuer Berechtigungsnachweise

Sie können in der YAML-Datei Ihre eigenen Anmeldeinformationen hinzufügen. Um zum Beispiel AWS- und Stripe-API-Schlüssel hinzuzufügen, ändern Sie die Datei wie folgt:

yaml
# config/credentials.yml.enc
aws:
    access_key_id: your_access_key_id
    geheimer_Zugangsschlüssel: Ihr_geheimer_Zugangsschlüssel
streifen:
    public_key: test_public
    privater_Schlüssel: test_privat
secret_key_base: ihr_geheimer_key_base

Speichern und schließen Sie den Editor. Rails verschlüsselt die Datei automatisch und speichert sie als config/credentials.yml.enc. Die Daten sind nun sicher und können der Versionskontrolle übergeben werden.

Umgebungsspezifische Berechtigungsnachweise (Rails 6+)

Für Rails 6 und höher können Sie umgebungsspezifische Anmeldeinformationen verwalten. Zum Beispiel, um die Produktionsanmeldeinformationen zu bearbeiten:

bash
EDITOR="vim" rails credentials:edit --environment production

Dadurch wird Folgendes erstellt oder bearbeitet config/credentials/production.yml.enc und verwendet config/credentials/production.key für die Verschlüsselung. Ein Beispiel für eine Datei mit Produktionsanmeldeinformationen könnte wie folgt aussehen:

yaml
# config/credentials/production.yml.enc
aws:
    access_key_id: prod_access_key_id
    secret_access_key: prod_secret_access_key
secret_key_base: prod_secret_key_base

In ähnlicher Weise können Sie Entwicklungs- oder Testanmeldeinformationen verwalten mit --Umweltentwicklung oder --Umgebungstest. So können Sie für jede Umgebung unterschiedliche API-Schlüssel oder Datenbankanmeldeinformationen verwenden.

Zugriff auf Anmeldeinformationen in Ihrer Anwendung

Leseberechtigung

Sie können auf Anmeldeinformationen in Ihrer Rails-Anwendung zugreifen, indem Sie Rails.application.credentials. Zum Beispiel, um den AWS-Zugangsschlüssel abzurufen:

ruby
Rails.application.credentials.aws[:access_key_id]
# => "Ihre_Zugangsschlüssel_ID"

Für umgebungsspezifische Anmeldeinformationen lädt Rails automatisch die entsprechende Datei basierend auf der RAILS_ENV Umgebungsvariable. Zum Beispiel in der Entwicklung:

ruby
Rails.application.credentials.dig(:stripe, :public_key)
# => "test_public_development"

In der Produktion würde derselbe Code den Produktionsschlüssel abrufen, wenn dieser in config/credentials/production.yml.enc.

Vereinfachung des Zugriffs mit Punktschreibweise

Der Einfachheit halber unterstützt Rails die Punktnotation für den Zugriff auf Anmeldeinformationen:

ruby
Rails.application.credentials.stripe.public_key
# => "test_public"

Einige Entwickler bevorzugen jedoch die Verwendung von dig für verschachtelte Schlüssel, um Fehler zu vermeiden, wenn ein Schlüssel fehlt.

Beispiel: Verwendung von Berechtigungsnachweisen in einem Controller

Angenommen, Sie integrieren einen Zahlungsdienst wie Stripe. Sie können ihn in einem Controller mit Anmeldedaten konfigurieren:

ruby
class PaymentsController < AnwendungsController
    def create
        Stripe.api_key = Rails.application.credentials.stripe[:private_key]
        # Logik der Zahlungsverarbeitung
    end
end

So bleibt Ihr API-Schlüssel sicher und aus der Codebasis heraus.

Verwaltung des Hauptschlüssels

Sichern des Hauptschlüssels

Die config/master.key Datei (oder umgebungsspezifische Schlüssel wie config/credentials/production.key</code.) ist entscheidend für die Entschlüsselung von Anmeldedaten. Hier sind die besten Praktiken für die Verwaltung dieser Schlüssel:

• Übertragen Sie niemals in die Versionskontrolle: Sicherstellen master.key ist in .gitignore.
• Sicheres Teilen: Verwenden Sie einen Passwort-Manager oder einen sicheren Kanal (z. B. verschlüsselte Nachrichten), um den Schlüssel mit Teammitgliedern zu teilen.
• Verwenden Sie Umgebungsvariablen: Alternativ können Sie auch den >RAILS_MASTER_KEY Umgebungsvariable anstelle der Verwendung von master.key. Zum Beispiel:

bash
export RAILS_MASTER_KEY=Ihr_master_key

Rails priorisiert RAILS_MASTER_KEY über die master.key Datei. Dies ist nützlich für Bereitstellungsumgebungen wie Heroku oder AWS.

Drehen des Hauptschlüssels

Wenn Sie vermuten, dass der Hauptschlüssel kompromittiert wurde, drehen Sie ihn um:

• Erzeugen Sie einen neuen Hauptschlüssel:

bash
Schienen-Anmeldeinformationen:edit

Dadurch wird eine neue config/master.key und wieder verschlüsselt config/credentials.yml.enc.

• Aktualisieren Sie alle Teammitglieder und Bereitstellungsumgebungen mit dem neuen Schlüssel.
• Wenn Sie umgebungsspezifische Anmeldeinformationen verwenden, wiederholen Sie dies für jede Umgebung (z. B., Schienen-Anmeldeinformationen:edit --Umgebung Produktion).

Das Drehen der geheim_schlüssel_basis werden bestehende Sitzungen und Cookies ungültig. Planen Sie die Rotationen daher sorgfältig, um Störungen der Benutzer zu vermeiden.

Bewährte Praktiken für Rails-Anmeldeinformationen

1. Geheimnisse aus dem Quellcode heraushalten

Verschlüsseln Sie niemals sensible Daten in Ihrem Anwendungscode. Vermeiden Sie zum Beispiel:

ruby
# Schlechte Praxis
AWS.config(zugangsschlüssel_id: "ihre_zugangsschlüssel_id")

Verwenden Sie stattdessen:

ruby
AWS.config(access_key_id: Rails.application.credentials.aws[:access_key_id])

Dies gewährleistet, dass Geheimnisse verschlüsselt und sicher bleiben.

2. Umgebungsspezifische Anmeldeinformationen verwenden

Nutzen Sie die Unterstützung von Rails für umgebungsspezifische Anmeldedaten, um die Verwendung von Entwicklungsschlüsseln in der Produktion zu vermeiden. Dadurch wird das Risiko eines versehentlichen Missbrauchs sensibler Schlüssel verringert.

3. Sensible Daten in Protokollen filtern

Rails-Protokolle können ungewollt sensible Daten preisgeben. Konfigurieren Sie config.filter_parameters In config/application.rb um sensible Parameter zu filtern:

ruby
config.filter_parameters += [:password, :secret, :token]

Dies markiert sensible Daten als [FILTERED] in Protokollen, um eine Exposition zu verhindern.

4. Regelmäßige Rotation der Geheimnisse

Drehen Sie regelmäßig Ihre geheim_schlüssel_basis und andere Berechtigungsnachweise, um die Auswirkungen möglicher Lecks zu minimieren. Verwenden Sie die Rotationsmechanismen von Rails, um Cookies anständig zu aktualisieren.

5. Sichern Sie Ihre Datenbankkonfiguration

Sicherstellen config/atabase.yml keine sensiblen Daten enthält. Verwenden Sie Credentials für Datenbankpasswörter:

yaml
# config/database.yml
Produktion:
adapter: postgresql
Datenbank: 
username: 
password:

Dadurch bleiben die Anmeldedaten der Datenbank sicher.

6. Audit Ihrer Bewerbung

Verwenden Sie Tools wie Brakeman und bundler-audit, um Ihre Rails-Anwendung auf Sicherheitsschwachstellen zu scannen. Integrieren Sie sie in Ihre CI/CD-Pipeline, um Probleme frühzeitig zu erkennen.

Häufige Fallstricke und wie man sie vermeidet

1. Übergabe des Hauptschlüssels

Versehentlich begehen config/master.key zur Versionskontrolle ist ein häufiger Fehler. Überprüfen Sie immer zweimal Ihre .gitignore file:

gitignore
/config/master.key
/config/credentials/*.key

2. Inkonsistente Berechtigungsnachweise für die Umgebung

Wenn Sie umgebungsspezifische Anmeldeinformationen verwenden, achten Sie darauf, dass die Schlüssel in allen Umgebungen konsistent sind. Wenn Sie zum Beispiel einen streifen Schlüssel in der Entwicklung verwenden, fügen Sie ihn auch zu den Produktions- und Testanmeldedaten hinzu, selbst wenn es sich um Platzhalterwerte handelt.

3. Offenlegung von Berechtigungsnachweisen in Protokollen

Ungefilterte Protokolle können Geheimnisse preisgeben. Prüfen Sie immer, ob config.filter_parameters umfasst alle sensiblen Tasten.

4. Verwendung von ERB in Berechtigungsnachweisen

Rails unterstützt kein eingebettetes Ruby (ERB) in verschlüsselten Credentials-Dateien, also vermeiden Sie die Verwendung von <%= %> Syntax. Verwenden Sie stattdessen einfaches YAML.

Fortgeschrittene Themen

Verwendung von Berechtigungsnachweisen bei Diensten von Drittanbietern

Wenn Sie Dienste von Drittanbietern wie AWS, Stripe oder SendGrid integrieren, speichern Sie deren API-Schlüssel in Anmeldeinformationen. Zum Beispiel:

yaml
sendgrid:
    api_key: Ihr_sendgrid_api_key

Greifen Sie in Ihrer Anwendung darauf zu:

ruby
SendGrid::API.api_key = Rails.application.credentials.sendgrid[:api_key]

So bleibt Ihre Integration sicher und wartbar.

Aktive Datensatzverschlüsselung

Um Datenbankfelder zu verschlüsseln, bietet Rails die Active Record Encryption (eingeführt in Rails 7). Zum Beispiel:

ruby
Klasse Artikel < ApplicationRecord
    verschlüsselt :summary, key: Rails.application.credentials.active_record_encryption[:primary_key]
end

Speichern Sie den Verschlüsselungscode in den Anmeldeinformationen:

yaml
active_record_encryption:
    primary_key: ihr_verschlüsselungs_schlüssel
    schlüssel_ableitung_salz: ihr_salz

Dies ermöglicht die sichere Speicherung von sensiblen Datenbankfeldern.

Verwaltung benutzerdefinierter Geheimnisse

Für Ruby-Anwendungen, die nicht auf Rails basieren, oder für fortgeschrittene Anwendungsfälle können Sie Gems wie sekrets um verschlüsselte Geheimnisse zu verwalten. Diese können in Rails für benutzerdefinierte Arbeitsabläufe integriert werden.

Abschluss

Die Verwaltung von Berechtigungsnachweisen und verschlüsselten Geheimnissen in Ruby on Rails ist eine wichtige Voraussetzung für die Entwicklung sicherer Anwendungen. Indem Sie das in Rails eingebaute System für Anmeldeinformationen nutzen, können Sie sensible Daten sicher speichern, sie mit Ihrem Team teilen und Ihre Anwendung mit Vertrauen einsetzen. Von der Bearbeitung config/credentials.yml.enc bis hin zur Sicherung des Hauptschlüssels und der Verwendung von umgebungsspezifischen Anmeldeinformationen hat dieser Leitfaden die wichtigsten Punkte für Anfänger abgedeckt.

Um Ihre Rails-Entwicklung auf die nächste Stufe zu heben, sollten Sie eine Partnerschaft mit Experten wie SchienenCarmaeine spezialisierte Ruby on Rails-Entwicklungsunternehmen. RailsCarma bietet umfassende Dienstleistungen, einschließlich Anwendungsentwicklung, Wartung und SicherheitsprüfungenSie helfen Ihnen, robuste und sichere Rails-Anwendungen zu erstellen, die auf Ihre Bedürfnisse zugeschnitten sind. Egal, ob Sie Anfänger sind oder ein komplexes Projekt skalieren, ihre Expertise kann Sie durch bewährte Praktiken und fortgeschrittene Techniken führen. Wenn Sie die in diesem Leitfaden beschriebenen Praktiken befolgen und bei Bedarf professionelle Unterstützung in Anspruch nehmen, sind Sie gut gerüstet, um sensible Daten in Ihren Rails-Anwendungen sicher zu handhaben.