Authentifizierung und Autorisierung
Implementieren Sie sichere Benutzerauthentifizierung (z. B. JWT) und Autorisierungsmechanismen zum Schutz der Endpunkte Ihres Webdienstes.
Authentifizierung und Autorisierung ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 3 von 3. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Learn Rust Coding-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Learn Rust Coding-Kurs umfasst insgesamt 3 Lektionen.
Sichern Sie Ihre Webdienste
Willkommen! In dieser Lektion beschäftigen Sie sich eingehend mit Authentifizierung und Autorisierung – zwei entscheidenden Konzepten für die Entwicklung sicherer Webdienste in Rust.
Sie lernen, wie Sie Ihre API-Endpunkte schützen, indem Sie sicherstellen, dass nur berechtigte Benutzer darauf zugreifen können und nur über die erforderlichen Berechtigungen verfügen.
Authentifizierung vs. Autorisierung
Diese beiden Begriffe klingen ähnlich, bedeuten aber Unterschiedliches:
- Authentifizierung: Überprüft, wer Sie sind. Das ist vergleichbar damit, beim Betreten eines Gebäudes Ihren Ausweis vorzuzeigen.
- Autorisierung: Legt fest, was Sie tun dürfen. Sobald Sie sich im Gebäude befinden, geht es darum, welche Räume Sie betreten dürfen.
Wir implementieren beides, um unsere Rust-Webdienste abzusichern.
Warum sollten Sie Ihre APIs absichern?
Der Schutz Ihrer API-Endpunkte ist aus mehreren Gründen unverzichtbar:
- Datenschutz: Schützen Sie vertrauliche Benutzerdaten vor unbefugtem Zugriff.
- Systemintegrität: Verhindern Sie, dass Angreifer Ihre Daten verändern oder beschädigen.
- Compliance: Erfüllen Sie gesetzliche und regulatorische Anforderungen (z. B. DSGVO, HIPAA).
Eine robuste Sicherheitsschicht schafft Vertrauen und schützt Ihre Anwendung.
JSON Web Tokens (JWTs)
Eine verbreitete Methode zur Authentifizierung in modernen Webdiensten ist die Verwendung von JSON Web Tokens (JWTs), ausgesprochen „jot“.
JWTs sind kompakte, URL-sichere Mittel zur Darstellung von Claims, die zwischen zwei Parteien übertragen werden. Sie werden häufig für eine zustandslose Authentifizierung verwendet.
Das bedeutet, dass der Server keine Sitzungsinformationen für einzelne Benutzer speichern muss.
Aufbau eines JWT: Header, Payload, Signatur
Ein JWT besteht aus drei durch Punkte getrennten Teilen:
- Header: Enthält Metadaten über das Token, etwa den Tokentyp (JWT) und den Signaturalgorithmus (z. B. HS256).
- Payload: Enthält die „Claims“ – Aussagen über eine Entität (in der Regel den Benutzer) sowie zusätzliche Daten.
- Signatur: Dient dazu zu überprüfen, dass das Token nicht manipuliert wurde. Sie wird erzeugt, indem Header und Payload mit einem geheimen Schlüssel kodiert werden.
JWTs in Rust erzeugen und überprüfen
Sehen wir uns an, wie Sie mit dem Crate jsonwebtoken in Rust ein JWT erzeugen und überprüfen. Denken Sie daran, dass Sie jsonwebtoken, serde (mit dem Feature „derive“) und chrono (mit dem Feature „serde“) zu Ihrer Cargo.toml hinzufügen müssen.
Dieses Beispiel erzeugt ein Token und überprüft es anschließend sofort.
use jsonwebtoken::{encode, decode, Header, EncodingKey, DecodingKey, Validation};
use serde::{Deserialize, Serialize};
use chrono::{Utc, Duration};
#[derive(Debug, Serialize, Deserialize)]
struct Claims {
sub: String, // Subject (user ID)
company: String,
exp: usize, // Expiration time
}
fn main() {
// --- Setup (requires crates: jsonwebtoken, serde, chrono) ---
let secret_key = "my_super_secret_key";
// --- 1. Generate a JWT ---
let my_claims = Claims {
sub: "user123".to_string(),
company: "CoddyKit".to_string(),
exp: (Utc::now() + Duration::minutes(10)).timestamp() as usize,
};
let token = encode(
&Header::default(),
&my_claims,
&EncodingKey::from_secret(secret_key.as_ref()),
).expect("Failed to encode token");
println!("Generated JWT:\n{}", token);
println!("\n--- Verifying the Token ---");
// --- 2. Verify the JWT ---
let validation = Validation::default();
let decoded_result = decode::<Claims>(
&token,
&DecodingKey::from_secret(secret_key.as_ref()),
&validation,
);
match decoded_result {
Ok(token_data) => {
println!("Token valid!");
println!("Subject: {}", token_data.claims.sub);
println!("Company: {}", token_data.claims.company);
},
Err(err) => println!("Token invalid: {:?}", err),
}
}Autorisierung: Zugriff definieren
Sobald ein Benutzer authentifiziert ist (wir wissen also, wer er ist), legt die Autorisierung fest, auf welche Ressourcen oder Aktionen er zugreifen darf.
Zu den gängigen Autorisierungsmodellen gehören:
- Role-Based Access Control (RBAC): Benutzern werden Rollen zugewiesen (z. B. „admin“, „editor“, „viewer“), und Rollen verfügen über bestimmte Berechtigungen.
- Attribute-Based Access Control (ABAC): Der Zugriff wird anhand von Attributen des Benutzers, der Ressource oder der Umgebung gewährt.
Konzept der Autorisierungs-Middleware
In einem Webdienst wird die Autorisierung häufig von einer Middleware übernommen. Dabei handelt es sich um Code, der vor Ihrem eigentlichen Routen-Handler ausgeführt wird.
Die Middleware würde:
- Die Identität des authentifizierten Benutzers ermitteln (z. B. aus einem JWT).
- Seine Rollen oder Berechtigungen mit den für den angeforderten Endpunkt erforderlichen Zugriffsrechten vergleichen.
- Wenn der Zugriff autorisiert ist, die Anfrage fortsetzen lassen; andernfalls einen Fehler „Unauthorized“ oder „Forbidden“ zurückgeben.
So bleiben Ihre Routen-Handler übersichtlich und auf die Geschäftslogik konzentriert.
Testen Sie Ihr Wissen
Überprüfen wir kurz Ihr Verständnis von Authentifizierung und Autorisierung.
Rückblick: Webdienste absichern
Sehr gut! In dieser Lektion haben Sie die Grundlagen zur Absicherung Ihrer Rust-Webdienste kennengelernt:
- Den Unterschied zwischen Authentifizierung (wer Sie sind) und Autorisierung (was Sie tun dürfen).
- Die Bedeutung des Schutzes von API-Endpunkten.
- Die Funktionsweise von JSON Web Tokens (JWTs) für die zustandslose Authentifizierung einschließlich ihres Aufbaus.
- Ein praktisches Rust-Beispiel zum Erzeugen und Überprüfen von JWTs.
- Die Konzepte der Role-Based Access Control und die Verwendung von Middleware zur Implementierung von Autorisierungsprüfungen.
Sie sind nun bereit, sicherere und robustere Rust-Anwendungen zu entwickeln!
Häufig gestellte Fragen
Ist die Lektion „Authentifizierung und Autorisierung“ kostenlos?
Ja — der vollständige Text von „Authentifizierung und Autorisierung“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Learn Rust Coding-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Learn Rust Coding-Kurs umfasst insgesamt 3 Lektionen.
Was lerne ich in „Authentifizierung und Autorisierung“?
Implementieren Sie sichere Benutzerauthentifizierung (z. B. JWT) und Autorisierungsmechanismen zum Schutz der Endpunkte Ihres Webdienstes. Du übst Learn Rust Coding mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Learn Rust Coding zu starten?
Keine Vorkenntnisse erforderlich. Learn Rust Coding auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 3.
Wie lange dauert die Lektion „Authentifizierung und Autorisierung“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Learn Rust Coding-Lektion Code schreiben und ausführen?
Ja. Jede Learn Rust Coding-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- REST-APIs mit Actix-web/Rocket
- Datenbankintegration (SQLx/Diesel)
- Authentifizierung und Autorisierung