Go Passwort Manager ================== Allgemeine Übersicht ----------------------- Projektbeschreibung und Ziele ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Der Go Passwort Manager ist eine sichere Anwendung zur Verwaltung von Passwörtern, die mit der Programmiersprache Go entwickelt wurde. Das Projekt zielt darauf ab, eine leichtgewichtige, sichere und benutzerfreundliche Lösung für die Speicherung und Verwaltung sensibler Anmeldedaten zu bieten. Im Gegensatz zu kommerziellen Passwort-Managern liegt der Fokus auf Datensicherheit durch lokale Verschlüsselung und einer modernen Browser-Integration. Die Hauptziele des Projekts sind: * Implementierung eines sicheren Passwort-Speichers mit AES-GCM Verschlüsselung * Bereitstellung einer einfachen CLI- und Browser-Schnittstelle * Automatische Generierung sicherer Passwörter * Einfache Integration in den Arbeitsablauf durch Browser-Extension Hauptfunktionalitäten ^^^^^^^^^^^^^^^^^^^^^ Der Go Passwort Manager bietet folgende Kernfunktionen: * **Sichere Datenspeicherung**: Alle Passwörter werden verschlüsselt in einer lokalen Datei gespeichert * **Passwort-Generator**: Automatische Erzeugung kryptografisch sicherer Passwörter (10-20 Zeichen, ASCII) * **Passwort-Verwaltung**: Hinzufügen, Suchen, Anzeigen und Löschen von Passwörtern * **Browser-Integration**: Eine Edge-Browser-Extension ermöglicht den direkten Zugriff auf gespeicherte Passwörter * **REST-API**: Backend-Server für die Kommunikation zwischen Browser-Extension und Passwort-Speicher Technologiestack (Go, Browser-Extension) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Der Passwort Manager basiert auf folgenden Technologien: * **Backend**: Go (Golang) für das Server-Backend und die Kernfunktionalitäten * Standard-Bibliothek für HTTP-Server und Kryptografie * Modulare Struktur mit separaten Packages für verschiedene Funktionsbereiche * **Frontend**: Browser-Extension für Microsoft Edge * HTML, CSS und JavaScript für die Benutzeroberfläche * Manifest V2 für die Extension-Konfiguration * Content und Background Scripts für die Browser-Integration * **Kommunikation**: REST-API für die Interaktion zwischen Extension und Backend * **Datenspeicherung**: Verschlüsselte lokale Dateien (passwords.dat, master.key) Architekturübersicht ^^^^^^^^^^^^^^^^^^^ Die Anwendung folgt einer Client-Server-Architektur mit folgenden Komponenten: * **Go-Backend**: Stellt einen HTTP-Server bereit, der die REST-API für den Zugriff auf Passwörter implementiert * **Models**: Definieren Datenstrukturen für Passwort-Einträge * **Storage**: Verwaltet die verschlüsselte Datei-Persistenz * **Encryption**: Implementiert die AES-GCM Verschlüsselung * **Utils**: Enthält den Passwort-Generator und Hilfsfunktionen * **Browser-Extension**: Bietet die Benutzeroberfläche und kommuniziert mit dem Backend * **Popup**: Benutzeroberfläche für die Passwort-Verwaltung * **Background Script**: Verarbeitet API-Anfragen im Hintergrund * **Content Script**: Ermöglicht die Integration mit besuchten Webseiten Die Kommunikation erfolgt über eine REST-API mit CORS-Unterstützung, wobei die Daten JSON-formatiert übertragen werden. Die Sicherheit wird durch die lokale Ausführung und verschlüsselte Datenspeicherung gewährleistet. Sicherheitskonzept --------------------- Das Sicherheitskonzept des Password Managers basiert auf mehreren sich ergänzenden Sicherheitsschichten, die zusammen ein robustes System bilden. Jede Komponente erfüllt dabei eine spezifische Schutzfunktion: 1. **Verschlüsselte Speicherung mit AES-GCM** Die Basis der Sicherheit bildet der moderne AES-GCM Verschlüsselungsalgorithmus. AES (Advanced Encryption Standard) mit GCM (Galois/Counter Mode) bietet nicht nur Verschlüsselung, sondern auch Integritätsprüfung der Daten: .. code-block:: go func Encrypt(key []byte, data []byte) []byte { // Erstelle einen neuen AES-Verschlüsselungsblock block, err := aes.NewCipher(key) if err != nil { panic(err) } // Verwende den GCM-Modus für zusätzliche Sicherheit gcm, err := cipher.NewGCM(block) if err != nil { panic(err) } // Erzeuge einen zufälligen "Nonce" - dieser macht jede // Verschlüsselung einzigartig nonce := make([]byte, gcm.NonceSize()) if _, err = io.ReadFull(rand.Reader, nonce); err != nil { panic(err) } // Verschlüssele die Daten return gcm.Seal(nonce, nonce, data, nil) } Die Entschlüsselung erfolgt mit der entsprechenden Decrypt-Funktion, die ebenfalls die Datenintegrität überprüft: .. code-block:: go func Decrypt(key []byte, data []byte) []byte { block, err := aes.NewCipher(key) if err != nil { panic(err) } gcm, err := cipher.NewGCM(block) if err != nil { panic(err) } nonceSize := gcm.NonceSize() if len(data) < nonceSize { panic("Verschlüsselte Daten zu kurz") } nonce, ciphertext := data[:nonceSize], data[nonceSize:] plaintext, err := gcm.Open(nil, nonce, ciphertext, nil) if err != nil { panic(err) } return plaintext } 2. **Sichere Schlüsselverwaltung** Der Verschlüsselungsschlüssel wird in einer separaten Datei (``master.key``) gespeichert. Das System implementiert eine automatische Schlüsselverwaltung mit folgenden Eigenschaften: - Verwendung eines 256-Bit Schlüssels für maximale Sicherheit - Automatische Schlüsselgenerierung bei Erstnutzung - Sichere Speicherung des Schlüssels mit eingeschränkten Dateiberechtigungen .. code-block:: go func LoadOrCreateKey(keyFile string) []byte { key := make([]byte, 32) // 256-Bit Schlüssel if _, err := os.Stat(keyFile); os.IsNotExist(err) { // Erzeuge einen neuen Schlüssel wenn keiner existiert key = GenerateKey() err = ioutil.WriteFile(keyFile, []byte(hex.EncodeToString(key)), 0600) if err != nil { panic(err) } } else { // Lade existierenden Schlüssel keyHex, err := ioutil.ReadFile(keyFile) if err != nil { panic(err) } key, err = hex.DecodeString(string(keyHex)) if err != nil { panic(err) } } return key } Die Schlüsselgenerierung nutzt kryptografisch sichere Zufallszahlen: .. code-block:: go func GenerateKey() []byte { key := make([]byte, 32) if _, err := io.ReadFull(rand.Reader, key); err != nil { panic(err) } return key } 3. **Sichere Datenspeicherung und -verwaltung** Die Passwörter werden in einer verschlüsselten Datei (``passwords.dat``) gespeichert. Der FileManager implementiert dabei mehrere Sicherheitsmechanismen: - Atomare Schreiboperationen zur Vermeidung von korrupten Daten - Verschlüsselung aller Passwortdaten vor der Speicherung - Validierung der Datenintegrität beim Laden .. code-block:: go func (fm *FileManager) SavePasswords(entries []models.PasswordEntry) error { // Wandle die Passworteinträge in JSON um data, err := json.Marshal(entries) if err != nil { return err } // Verschlüssele die Daten vor dem Speichern encrypted := encryption.Encrypt(fm.key, data) return ioutil.WriteFile(fm.dataFile, encrypted, 0644) } Beim Laden der Passwörter wird die Integrität der Daten geprüft: .. code-block:: go func (fm *FileManager) LoadPasswords() ([]models.PasswordEntry, error) { var entries []models.PasswordEntry if _, err := os.Stat(fm.dataFile); os.IsNotExist(err) { return entries, nil } data, err := ioutil.ReadFile(fm.dataFile) if err != nil { return entries, err } decrypted := encryption.Decrypt(fm.key, data) err = json.Unmarshal(decrypted, &entries) return entries, err } 4. **Sichere Kommunikation und API-Zugriff** Die Kommunikation zwischen Browser-Extension und Backend wird durch CORS-Header und weitere Sicherheitsmaßnahmen geschützt: - Strikte CORS-Konfiguration für kontrollierte Zugriffe - Validierung aller API-Anfragen - Sichere Fehlerbehandlung ohne Informationslecks .. code-block:: go func handleCORS(w http.ResponseWriter) { w.Header().Set("Access-Control-Allow-Origin", "*") w.Header().Set("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS") w.Header().Set("Access-Control-Allow-Headers", "Content-Type") } Die API-Handler implementieren zusätzliche Sicherheitsprüfungen: .. code-block:: go func searchPasswordHandler(w http.ResponseWriter, r *http.Request) { handleCORS(w) if r.Method == "OPTIONS" { return } // Validiere notwendige Parameter service := r.URL.Query().Get("service") if service == "" { http.Error(w, "Service parameter is required", http.StatusBadRequest) return } // Sichere Suche mit case-insensitive Vergleich for _, entry := range entries { if strings.ToLower(entry.Service) == strings.ToLower(service) { json.NewEncoder(w).Encode(entry) return } } // Generische Fehlermeldung ohne Details http.Error(w, "Password not found", http.StatusNotFound) } 5. **Zusätzliche Sicherheitsmerkmale** Der Password Manager implementiert weitere Sicherheitsfunktionen: - Automatische Passwortgenerierung mit kryptografisch sicheren Zufallszahlen - Sichere Behandlung von Fehlerzuständen ohne Preisgabe sensibler Informationen - Lokale Ausführung zur Minimierung von Angriffsrisiken Die Kombination dieser Sicherheitsmaßnahmen gewährleistet, dass die gespeicherten Passwörter auch dann geschützt bleiben, wenn ein Angreifer Zugriff auf die Datendatei erhält. Nur mit dem korrekten Schlüssel aus der ``master.key`` Datei können die Daten entschlüsselt werden. Backend-Implementierung ----------------------- RESTful API-Design ^^^^^^^^^^^^^^^^^^ Das Backend des Go Passwort Managers stellt eine einfache REST-API bereit, die von der Browser-Extension genutzt wird. Die Kommunikation erfolgt über HTTP-Endpunkte mit JSON als Datenformat und CORS-Unterstützung für browserseitige Zugriffe. Die folgenden Routen sind implementiert: - ``GET /passwords``: Gibt alle gespeicherten Passwort-Einträge zurück - ``POST /password/add``: Fügt einen neuen Passwort-Eintrag hinzu - ``GET /password/search?service=...``: Sucht ein Passwort zu einem bestimmten Dienst - ``DELETE /password/delete?service=...``: Löscht ein Passwort für einen bestimmten Dienst Jede Route ist über eine eigene Handler-Funktion im ``main.go`` implementiert. Die Funktionen validieren Anfragen, führen die gewünschte Operation aus und geben strukturierte JSON-Antworten zurück. Datenmodell und Strukturen ^^^^^^^^^^^^^^^^^^^^^^ Das zentrale Datenmodell ist ``PasswordEntry``, definiert im Modul ``models``: .. code-block:: go type PasswordEntry struct { Service string Username string Password string } Jeder Eintrag enthält den Dienstnamen, Benutzernamen und das zugehörige Passwort. Die Einträge werden in einer Slice ``[]PasswordEntry`` gespeichert und über alle Routen verarbeitet. Dateiverwaltung und Persistenz ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Die Speicherung der Passwörter erfolgt verschlüsselt in einer Datei (``passwords.dat``). Der symmetrische AES-GCM-Schlüssel wird aus ``master.key`` geladen oder erzeugt. Die Logik zur Dateioperation ist im ``storage``-Package gekapselt. Wichtige Methoden des ``FileManager``: - ``LoadPasswords()``: Lädt und entschlüsselt bestehende Einträge aus der Datei - ``SavePasswords()``: Serialisiert, verschlüsselt und speichert neue Einträge .. code-block:: go encrypted := encryption.Encrypt(fm.key, data) ioutil.WriteFile(fm.dataFile, encrypted, 0644) Durch diese Abstraktion bleibt die Speicherlogik vom Servercode getrennt. .. image:: _static/go_vscdoe.png :alt: VS_code Go :width: 600px Password Generator Funktionalität ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Wenn ein Passwort bei der Eingabe fehlt, wird automatisch ein sicheres Passwort generiert. Diese Funktion ist in ``utils.GeneratePassword()`` definiert. .. code-block:: go if entry.Password == "" { entry.Password = utils.GeneratePassword() } Der Generator erzeugt Passwörter mit 10–20 zufälligen ASCII-Zeichen, geeignet für sichere Anmeldedaten. .. image:: _static/go_web.png :width: 600px Browser-Extension Frontend --------------------------- Die Browser-Extension bildet die Benutzeroberfläche des Passwort Managers und besteht aus mehreren wichtigen Komponenten: Benutzeroberfläche und Design ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Die Benutzeroberfläche ist in HTML und CSS implementiert und bietet: - Ein übersichtliches Popup-Fenster für schnelle Aktionen - Formulare zur Passwort-Verwaltung - Automatische Erkennung von Login-Formularen Die manifest.json definiert dabei die grundlegende Konfiguration: .. code-block:: json { "manifest_version": 2, "name": "GO-Passwort Manager für Edge", "version": "1.0", "permissions": [ "activeTab", "tabs", "http://localhost:8080/*" ], "browser_action": { "default_popup": "popup.html" } } .. image:: _static/user_go.png :width: 600px Extension-Funktionalitäten ^^^^^^^^^^^^^^^^^^^^^^^^^ Die Extension bietet drei Hauptfunktionen: 1. **Passwort-Generierung**: Erstellt sichere Passwörter direkt im Browser .. code-block:: javascript function generatePassword() { const length = 16; const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()_+"; let password = ""; for (let i = 0; i < length; i++) { const randomIndex = Math.floor(Math.random() * charset.length); password += charset[randomIndex]; } document.getElementById('password').value = password; } 2. **Formularerkennung**: Erkennt automatisch Login-Formulare auf Webseiten .. code-block:: javascript function detectLoginForms() { const allForms = document.querySelectorAll('form'); allForms.forEach((form) => { const passwordField = findPasswordField(form); if (passwordField) { const usernameField = findUsernameField(form); if (usernameField) { addFormIndicator(form, usernameField, passwordField); } } }); } 3. **Autofill-Funktion**: Füllt erkannte Formulare automatisch aus Integration mit Backend ^^^^^^^^^^^^^^^^^^^^ Die Kommunikation mit dem Go-Backend erfolgt über die REST-API. Das background.js Script handhabt dabei die API-Aufrufe: .. code-block:: javascript async function searchPassword(service) { try { const response = await fetch( `http://localhost:8080/password/search?service=${encodeURIComponent(service)}` ); if (response.ok) { return await response.json(); } } catch (error) { console.error('API-Fehler:', error); } } Sicherheitsaspekte ^^^^^^^^^^^^^^^ Die Extension implementiert wichtige Sicherheitsmaßnahmen: - CORS-Validierung für API-Zugriffe - Sichere Kommunikation mit dem Backend - Beschränkte Berechtigungen durch das Manifest .. code-block:: javascript // Beispiel für sichere API-Kommunikation fetch('http://localhost:8080/passwords', { method: 'GET', headers: { 'Content-Type': 'application/json' }, credentials: 'omit' // Keine Cookies senden }); Demonstration und Verwendung ----------------------------- Installation und Setup ```````````````````````````````` Die Installation und Einrichtung des Go Passwort Managers umfasst zwei Hauptkomponenten: das Go-Backend und die Edge-Browser-Extension. **Go-Backend starten** Für die Ausführung des Backend-Servers wird Go benötigt. Nach der Installation von Go kann das Programm einfach über die Kommandozeile gestartet werden: .. code-block:: bash go run main.go **Browser-Extension installieren** Die Installation der Microsoft Edge Extension erfolgt über den Entwicklermodus: 1. In Edge zu edge://extensions/ navigieren 2. Entwicklermodus aktivieren 3. "Entpackte Erweiterung laden" wählen 4. Den `extension`-Ordner des Projekts auswählen Passwort erstellen/generieren `````````````````````````````` Der Go Passwort Manager bietet zwei Möglichkeiten zum Erstellen von Passwörtern: **CLI-Modus** Im Terminal-Interface können Passwörter manuell eingegeben oder automatisch generiert werden: .. code-block:: go fmt.Println("\nWie möchten Sie das Passwort erstellen?") fmt.Println("1. Manuell eingeben") fmt.Println("2. Automatisch generieren") fmt.Print("Wähle eine Option (1-2): ") scanner.Scan() passwordChoice := strings.TrimSpace(scanner.Text()) fmt.Print("Service: ") scanner.Scan() service := strings.TrimSpace(scanner.Text()) fmt.Print("Benutzername: ") scanner.Scan() username := strings.TrimSpace(scanner.Text()) var password string switch passwordChoice { case "1": fmt.Print("Passwort: ") scanner.Scan() password = strings.TrimSpace(scanner.Text()) case "2": password = utils.GeneratePassword() fmt.Printf("Generiertes Passwort: %s\n", password) } Der Passwortgenerator in utils/generator.go erzeugt sichere, zufällige Passwörter: .. code-block:: go func GeneratePassword() string { const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()-_=+,.?/:;{}[]|" length := rand.Intn(11) + 10 // 10-20 Zeichen password := make([]byte, length) for i := 0; i < length; i++ { password[i] = charset[rand.Intn(len(charset))] } return string(password) } .. image:: _static/go_web.png **Browser-Extension** In der Extension können Passwörter über die Popup-Benutzeroberfläche erstellt werden: .. code-block:: javascript // Button-Event-Handler in popup.js document.getElementById('generateBtn').addEventListener('click', generatePassword); document.getElementById('saveBtn').addEventListener('click', savePassword); Die Passwortgenerierung in der Extension verwendet einen ähnlichen Algorithmus: .. code-block:: javascript function generatePassword() { const length = 16; const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()_+"; let password = ""; for (let i = 0; i < length; i++) { const randomIndex = Math.floor(Math.random() * charset.length); password += charset[randomIndex]; } document.getElementById('password').value = password; } Passwörter verwalten ````````````````````` **Speichern von Passwörtern** Der zentrale Speichermechanismus basiert auf der Verschlüsselung mit AES-GCM. Die Implementierung des FileManager in storage/filemanager.go zeigt den Prozess: .. code-block:: go func (fm *FileManager) SavePasswords(entries []models.PasswordEntry) error { // Wandle die Passworteinträge in JSON um data, err := json.Marshal(entries) if err != nil { return err } // Verschlüssele die Daten vor dem Speichern encrypted := encryption.Encrypt(fm.key, data) return ioutil.WriteFile(fm.dataFile, encrypted, 0644) } Die Verschlüsselung im encryption-Package verwendet Go's kryptografische Standardbibliotheken: .. code-block:: go func Encrypt(key []byte, data []byte) []byte { block, err := aes.NewCipher(key) if err != nil { panic(err) } gcm, err := cipher.NewGCM(block) if err != nil { panic(err) } nonce := make([]byte, gcm.NonceSize()) if _, err = io.ReadFull(rand.Reader, nonce); err != nil { panic(err) } return gcm.Seal(nonce, nonce, data, nil) } **Automatische Formularerkennung (Browser-Extension)** Eine der fortschrittlichsten Funktionen der Extension ist die automatische Erkennung von Login-Formularen. Das content.js Script analysiert die DOM-Struktur der besuchten Webseiten: .. code-block:: javascript function detectLoginForms() { // Zurücksetzen der erkannten Formulare detectedForms = []; // Suche nach allen Formularen auf der Seite const allForms = document.querySelectorAll('form'); // Durchlaufe alle Formulare und prüfe, ob es sich um ein Login-Formular handeln könnte allForms.forEach((form) => { const passwordField = findPasswordField(form); // Ein Login-Formular hat typischerweise ein Passwort-Feld if (passwordField) { const usernameField = findUsernameField(form); if (usernameField) { detectedForms.push({ form: form, usernameField: usernameField, passwordField: passwordField }); // Füge einen visuellen Indikator und einen Klick-Handler hinzu addFormIndicator(form, usernameField, passwordField); } } }); } Suchen und Löschen ``````````````````` **Suche nach Passwörtern** Die Suchfunktion im Backend ermöglicht das Auffinden von Passwörtern anhand des Service-Namens: .. code-block:: go func searchPasswordHandler(w http.ResponseWriter, r *http.Request) { handleCORS(w) if r.Method == "OPTIONS" { return } service := r.URL.Query().Get("service") if service == "" { http.Error(w, "Service parameter is required", http.StatusBadRequest) return } for _, entry := range entries { if strings.ToLower(entry.Service) == strings.ToLower(service) { json.NewEncoder(w).Encode(entry) return } } http.Error(w, "Password not found", http.StatusNotFound) } In der Extension wird diese Funktion über ein einfaches Suchformular zugänglich gemacht: .. code-block:: javascript async function searchPassword() { const service = document.getElementById('searchService').value; if (!service) { alert('Bitte geben Sie einen Dienstnamen zur Suche ein'); return; } try { const response = await fetch(`${API_BASE}/password/search?service=${encodeURIComponent(service)}`); const resultDiv = document.getElementById('searchResult'); if (response.ok) { const data = await response.json(); resultDiv.innerHTML = `

Service: ${data.Service}

Username: ${data.Username}

Password: ${data.Password}

`; } else { resultDiv.innerHTML = '

Passwort nicht gefunden

'; } } catch (error) { document.getElementById('searchResult').innerHTML = `

Fehler: ${error.message}

`; } } **Automatische Erkennung passender Passwörter** Die Extension kann auch automatisch Passwörter finden, die zur aktuell besuchten Webseite passen: .. code-block:: javascript async function loadMatchingPasswords(url) { if (!url) return; try { // Extrahiere die Domain aus der URL const domain = extractDomain(url); console.log('Suche nach passenden Passwörtern für Domain:', domain); // Hole alle Passwörter vom Server const response = await fetch(`${API_BASE}/passwords`); if (!response.ok) { throw new Error('Fehler beim Laden der Passwörter'); } const passwords = await response.json(); const matchingDiv = document.getElementById('matchingPasswords'); // Filtere Passwörter, die zur aktuellen Domain passen könnten const matches = passwords.filter(entry => { const entryDomain = extractDomain(entry.Service.toLowerCase()); return domain.includes(entryDomain) || entryDomain.includes(domain); }); // Zeige passende Ergebnisse an... } catch (error) { console.error('Fehler beim Laden passender Passwörter:', error); } } Live-Demo der Extension ```````````````````````````````````````````````` Das Herzstück der Benutzerinteraktion ist die automatische Formularerkennung und das Autofill-Feature. Wenn ein Login-Formular erkannt wird, bietet die Extension einen "Autofill"-Button an: .. code-block:: javascript function addFormIndicator(formElement, usernameField, passwordField) { // Erstelle einen Button für das automatische Ausfüllen const autofillButton = document.createElement('button'); autofillButton.textContent = '🔑 Autofill'; autofillButton.style.cssText = ` position: absolute; z-index: 10000; background-color: #4285f4; color: white; border: none; border-radius: 4px; padding: 5px 10px; font-size: 12px; cursor: pointer; opacity: 0.8; transition: opacity 0.3s; `; // Button-Events und Positionierung... // Klick-Handler für das automatische Ausfüllen autofillButton.addEventListener('click', (e) => { e.preventDefault(); e.stopPropagation(); // Hole den Domain-Namen const domain = window.location.hostname; // Sende Anfrage zum Abrufen passender Anmeldedaten chrome.runtime.sendMessage({ action: 'getMatchingCredentials', domain: domain }, (response) => { // Verarbeitung der Antwort... }); }); // Füge den Button zum DOM hinzu document.body.appendChild(autofillButton); } Beim Ausfüllen werden die Anmeldedaten in die entsprechenden Formularfelder eingefügt: .. code-block:: javascript function fillCredentials(data, sendResponse) { console.log('Versuche Anmeldedaten auszufüllen:', data); let filled = false; // Zuerst in den erkannten Formularen suchen for (const formData of detectedForms) { if (formData.usernameField && formData.passwordField) { formData.usernameField.value = data.Username; formData.usernameField.dispatchEvent(new Event('input', { bubbles: true })); formData.usernameField.dispatchEvent(new Event('change', { bubbles: true })); formData.passwordField.value = data.Password; formData.passwordField.dispatchEvent(new Event('input', { bubbles: true })); formData.passwordField.dispatchEvent(new Event('change', { bubbles: true })); filled = true; // Optional: Autofocus auf Submit-Button const submitButton = findSubmitButton(formData.form); if (submitButton) { submitButton.focus(); } break; } } // Sende Antwort zurück if (sendResponse) { sendResponse({ success: filled }); } return filled; } Diese Live-Interaktion mit Webseiten macht den GO Passwort Manager zu einem nützlichen Werkzeug für den täglichen Einsatz. Die Extension erkennt Anmeldeformulare automatisch, bietet passende gespeicherte Anmeldedaten an und kann diese mit einem Klick einfügen. 6. Fazit ---------------- Der Go Passwort Manager zeigt, wie mit modernen Programmiersprachen und Webtechnologien eine sichere, effiziente und benutzerfreundliche Lösung zur Passwortverwaltung realisiert werden kann. Die Kombination aus lokaler AES-GCM-Verschlüsselung, einer klar strukturierten Go-Backend-Architektur und der nahtlosen Integration in den Browser durch eine Extension bietet einen hohen Sicherheitsstandard und Komfort im Alltag. Die modulare Struktur des Projekts erleichtert Wartung und Erweiterung, während die REST-API eine flexible Schnittstelle für verschiedene Frontends ermöglicht. Im Vergleich zu kommerziellen Lösungen überzeugt der Ansatz durch volle Datensouveränität und Transparenz. Zukünftige Erweiterungen wie Cloud-Synchronisation oder Multi-Browser-Support sind durch das gewählte Design problemlos möglich. Insgesamt ist der Go Passwort Manager ein gelungenes Beispiel für die praktische Anwendung kryptographischer Prinzipien und moderner Softwarearchitektur. 7. Quellen -------------- * Go Programmiersprache - Offizielle Dokumentation. (2023). [https://golang.org/doc/] * Mozilla Developer Network. (2023). Browser Extensions. [https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions] * Microsoft Edge Extensions Documentation. (2023). [https://docs.microsoft.com/en-us/microsoft-edge/extensions-chromium/] * Stallings, W. (2017). *Cryptography and Network Security: Principles and Practice* (7th ed.). Pearson. * NIST. (2022). Advanced Encryption Standard (AES). [https://csrc.nist.gov/publications/detail/fips/197/final] * McGrew, D., & Viega, J. (2004). The Galois/Counter Mode of Operation (GCM). [https://csrc.nist.gov/CSRC/media/Projects/Block-Cipher-Techniques/documents/BCM/proposed-modes/gcm/gcm-spec.pdf] * Bonneau, J., Herley, C., Van Oorschot, P. C., & Stajano, F. (2015). Passwords and the Evolution of Imperfect Authentication. *Communications of the ACM*, 58(7), 78-87. * Hunt, T. (2018). Password Security: Best Practices. [https://www.troyhunt.com/passwords-evolved-authentication-guidance-for-the-modern-era/] * Fielding, R. T. (2000). *Architectural Styles and the Design of Network-based Software Architectures* (Doctoral dissertation). University of California, Irvine. [https://www.ics.uci.edu/~fielding/pubs/dissertation/top.htm]