4. Go Passwort Manager

4.1. Allgemeine Übersicht

4.1.1. 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

4.1.2. 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

4.1.3. 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)

4.1.4. 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.

4.2. 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:

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:

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
}

  1. 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

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:

func GenerateKey() []byte {
    key := make([]byte, 32)
    if _, err := io.ReadFull(rand.Reader, key); err != nil {
        panic(err)
    }
    return key
}

  1. 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

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:

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
}

  1. 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

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:

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)
}

  1. 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.

4.3. Backend-Implementierung

4.3.1. 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.

4.3.2. Datenmodell und Strukturen

Das zentrale Datenmodell ist PasswordEntry, definiert im Modul models:

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.

4.3.3. 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

encrypted := encryption.Encrypt(fm.key, data)
ioutil.WriteFile(fm.dataFile, encrypted, 0644)

Durch diese Abstraktion bleibt die Speicherlogik vom Servercode getrennt.

VS_code Go

4.3.4. Password Generator Funktionalität

Wenn ein Passwort bei der Eingabe fehlt, wird automatisch ein sicheres Passwort generiert. Diese Funktion ist in utils.GeneratePassword() definiert.

if entry.Password == "" {
    entry.Password = utils.GeneratePassword()
}

Der Generator erzeugt Passwörter mit 10–20 zufälligen ASCII-Zeichen, geeignet für sichere Anmeldedaten.

_images/go_web.png

4.4. Browser-Extension Frontend

Die Browser-Extension bildet die Benutzeroberfläche des Passwort Managers und besteht aus mehreren wichtigen Komponenten:

4.4.1. 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:

{
  "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"
  }
}
_images/user_go.png

4.4.2. Extension-Funktionalitäten

Die Extension bietet drei Hauptfunktionen:

  1. Passwort-Generierung: Erstellt sichere Passwörter direkt im Browser

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;
}

  1. Formularerkennung: Erkennt automatisch Login-Formulare auf Webseiten

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);
            }
        }
    });
}

  1. Autofill-Funktion: Füllt erkannte Formulare automatisch aus

4.4.3. Integration mit Backend

Die Kommunikation mit dem Go-Backend erfolgt über die REST-API. Das background.js Script handhabt dabei die API-Aufrufe:

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);
    }
}

4.4.4. Sicherheitsaspekte

Die Extension implementiert wichtige Sicherheitsmaßnahmen:

  • CORS-Validierung für API-Zugriffe

  • Sichere Kommunikation mit dem Backend

  • Beschränkte Berechtigungen durch das Manifest

// Beispiel für sichere API-Kommunikation
fetch('http://localhost:8080/passwords', {
    method: 'GET',
    headers: {
        'Content-Type': 'application/json'
    },
    credentials: 'omit'  // Keine Cookies senden
});

4.5. Demonstration und Verwendung

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:

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

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:

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:

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)
}
_images/go_web.png

Browser-Extension

In der Extension können Passwörter über die Popup-Benutzeroberfläche erstellt werden:

// 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:

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;
}

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:

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:

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:

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);
            }
        }
    });
}

Suche nach Passwörtern

Die Suchfunktion im Backend ermöglicht das Auffinden von Passwörtern anhand des Service-Namens:

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:

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 = `
                <div class="password-entry">
                    <p><strong>Service:</strong> ${data.Service}</p>
                    <p><strong>Username:</strong> ${data.Username}</p>
                    <p><strong>Password:</strong> ${data.Password}</p>
                </div>
            `;
        } else {
            resultDiv.innerHTML = '<p class="error">Passwort nicht gefunden</p>';
        }
    } catch (error) {
        document.getElementById('searchResult').innerHTML = `<p class="error">Fehler: ${error.message}</p>`;
    }
}

Automatische Erkennung passender Passwörter

Die Extension kann auch automatisch Passwörter finden, die zur aktuell besuchten Webseite passen:

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);
    }
}

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:

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:

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.

4.6. 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.

4.7. 7. Quellen