WordPress Rollen & Berechtigungen: Der komplette Entwickler-Leitfaden (2026)

Die größte Sicherheitslücke in den meisten WordPress-Websites ist keine Plugin-Schwachstelle. Es ist der Fehler, dem Kunden “Administrator”-Zugriff zu geben, wenn er nur Beiträge bearbeiten muss.

Oder schlimmer noch, einem “Praktikanten” die Fähigkeit zu geben, Themes zu wechseln (switch_themes).

WordPress hat ein leistungsstarkes Zugriffskontrollsystem (ACL) integriert. Es heißt Rollen & Berechtigungen (Roles & Capabilities). In diesem Leitfaden gehen wir über die Standardrolle “Redakteur” hinaus und lernen, sichere Berechtigungen zu strukturieren.

1. Konzepte: Rolle vs. Berechtigung (Capability)

• Berechtigung (Cap): Eine spezifische Erlaubnis, eine Sache zu tun.
  • Beispiel: edit_posts (Beiträge bearbeiten), publish_pages (Seiten veröffentlichen), install_plugins (Plugins installieren).
• Rolle (Role): Eine Sammlung von Berechtigungen.
  • Beispiel: Editor (Redakteur) = edit_posts + publish_posts + manage_categories (aber NICHT install_plugins).

Goldene Regel: Prüfen Sie immer auf Berechtigungen, niemals auf Rollen.

// ❌ FALSCH
if ( current_user_can( 'administrator' ) ) { ... }

// ✅ RICHTIG
if ( current_user_can( 'manage_options' ) ) { ... }

2. Vollständige Referenz der WordPress-Standardrollen

WordPress kommt mit sechs vordefinierten Rollen, die für die meisten Anwendungsfälle ausreichen:

2.1 Administrator

• Berechtigungen: Vollständiger Zugriff auf alle Funktionen
• Verwendung: Website-Besitzer, Entwickler
• Risiko: Kann alles löschen, Themes/Plugins ändern, andere Administratoren entfernen
• Wichtige Capabilities: manage_options, activate_plugins, switch_themes, edit_users, delete_site

2.2 Redakteur (Editor)

• Berechtigungen: Verwalten aller Inhalte, einschließlich fremder Beiträge
• Verwendung: Content-Manager, Chefredakteure
• Einschränkungen: Kein Zugriff auf Einstellungen, Plugins, Themes
• Wichtige Capabilities: edit_others_posts, publish_posts, manage_categories, moderate_comments

2.3 Autor (Author)

• Berechtigungen: Erstellen und Veröffentlichen eigener Beiträge
• Verwendung: Regelmäßige Content-Ersteller
• Einschränkungen: Keine Bearbeitung fremder Inhalte, keine Seiten-Verwaltung
• Wichtige Capabilities: publish_posts, upload_files, edit_published_posts

2.4 Mitarbeiter (Contributor)

• Berechtigungen: Erstellen von Beiträgen zur Überprüfung
• Verwendung: Gastautoren, Praktikanten
• Einschränkungen: Keine Veröffentlichung, keine Medien-Uploads
• Wichtige Capabilities: edit_posts, delete_posts (nur eigene, unveröffentlichte)

2.5 Abonnent (Subscriber)

• Berechtigungen: Nur Profil-Verwaltung
• Verwendung: Kommentatoren, Mitgliederbereiche
• Wichtige Capabilities: read

2.6 Super-Admin (Multisite)

• Berechtigungen: Netzwerk-weite Kontrolle über alle Sites
• Verwendung: Multisite-Netzwerk-Administratoren
• Wichtige Capabilities: manage_network, create_sites, delete_sites

3. Erstellen einer eigenen Rolle

Nehmen wir an, Sie haben einen “Shop-Manager”, der Produkte verwalten muss, aber Ihr Theme oder Ihre Plugins nicht anfassen darf.

function wppoland_add_store_manager_role() {
    add_role(
        'store_manager',
        'Shop Manager',
        [
            'read'         => true,
            'edit_posts'   => true,
            'upload_files' => true,
            'manage_woocommerce' => true, // Eigene Berechtigung
        ]
    );
}
// Führen Sie dies NUR EINMAL aus (z.B. bei der Aktivierung)
// add_action( 'init', 'wppoland_add_store_manager_role' );

Wichtig: Rollen werden in der Datenbank gespeichert (wp_options > wp_user_roles). Sie müssen add_role nicht bei jedem Seitenaufruf ausführen. Führen Sie es einmal bei der Bereitstellung aus.

3.1 Praktische Beispiele für benutzerdefinierte Rollen

SEO-Manager Rolle:

function wppoland_add_seo_manager_role() {
    add_role(
        'seo_manager',
        'SEO Manager',
        [
            'read'                    => true,
            'edit_posts'              => true,
            'edit_others_posts'       => true,
            'edit_pages'              => true,
            'edit_others_pages'       => true,
            'publish_posts'           => true,
            'publish_pages'           => true,
            'upload_files'            => true,
            'manage_categories'       => true,
            'edit_theme_options'      => true, // Für SEO-Einstellungen
            'manage_options'          => false, // Keine allgemeinen Einstellungen
            'install_plugins'         => false,
            'activate_plugins'        => false,
        ]
    );
}

Content Reviewer Rolle:

function wppoland_add_content_reviewer_role() {
    add_role(
        'content_reviewer',
        'Content Reviewer',
        [
            'read'                    => true,
            'edit_posts'              => true,
            'edit_others_posts'       => true,
            'edit_published_posts'    => true,
            'publish_posts'           => false, // Kann nicht veröffentlichen
            'moderate_comments'       => true,
            'upload_files'            => false,
        ]
    );
}

4. Hinzufügen von Berechtigungen zu bestehenden Rollen

Manchmal möchten Sie dem “Redakteur” nur erlauben, Menüs zu bearbeiten (was er standardmäßig nicht kann).

function wppoland_upgrade_editor() {
    $role = get_role( 'editor' );
    if ( $role ) {
        $role->add_cap( 'edit_theme_options' ); // Erlaubt Menü- & Widget-Bearbeitung
    }
}
// Einmal ausführen

4.1 Berechtigungen entfernen

function wppoland_restrict_author_uploads() {
    $role = get_role( 'author' );
    if ( $role ) {
        $role->remove_cap( 'upload_files' );
    }
}

5. Notfallwiederherstellung: Rollen zurücksetzen

Wenn ein Plugin Ihre Datenbank durcheinander gebracht hat oder Sie versehentlich die Rolle ‘Administrator’ gelöscht haben (das passiert!), benötigen Sie einen Hard Reset.

Dieses Skript stellt die Standard-WordPress-Architektur wieder her.

function wppoland_reset_roles() {
    if ( ! isset( $_GET['reset_roles_secret_key'] ) ) return;

    require_once( ABSPATH . 'wp-admin/includes/schema.php' );
    populate_roles();

    echo "Rollen erfolgreich zurückgesetzt.";
    exit;
}
add_action( 'init', 'wppoland_reset_roles' );

Zugriff über: https://ihre-domain.de/?reset_roles_secret_key=1

6. Capability-Checking Best Practices

6.1 Prüfung in Templates

if ( current_user_can( 'edit_post', $post_id ) ) {
    // Zeige Bearbeiten-Button
}

6.2 Prüfung in AJAX-Handlern

add_action( 'wp_ajax_my_custom_action', 'my_ajax_handler' );

function my_ajax_handler() {
    if ( ! current_user_can( 'manage_options' ) ) {
        wp_send_json_error( 'Unzureichende Berechtigungen' );
    }
    // Verarbeite Anfrage
}

6.3 Prüfung in REST API

register_rest_route( 'myplugin/v1', '/data/', [
    'methods'  => 'GET',
    'callback' => 'get_data',
    'permission_callback' => function () {
        return current_user_can( 'read' );
    },
] );

7. Role Editor Plugins im Vergleich

7.1 User Role Editor

// Programmatischer Zugriff auf URE-Funktionen
if ( function_exists( 'ure_edit_roles' ) ) {
    $ure = new URE_Role_View();
    // Erweiterte Rollenbearbeitung
}

7.2 Members Plugin

// CPT-Unterstützung mit Members
add_action( 'members_register_caps', function() {
    members_register_cap( 'custom_capability', [
        'label' => __( 'Custom Capability', 'textdomain' ),
    ] );
} );

8. Multisite-Rollen-Überlegungen

In einer Multisite-Installation gibt es wichtige Unterschiede:

8.1 Netzwerk- vs. Site-Rollen

// Prüfung auf Super-Admin
if ( is_super_admin() ) {
    // Netzwerk-weite Aktionen
}

// Site-spezifische Berechtigungen
if ( current_user_can_for_blog( $blog_id, 'manage_options' ) ) {
    // Site-spezifische Aktionen
}

8.2 Rollen-Synchronisation

function wppoland_sync_role_to_all_sites( $user_id, $role ) {
    if ( ! is_multisite() ) return;

    $blogs = get_sites();
    foreach ( $blogs as $blog ) {
        switch_to_blog( $blog->blog_id );
        $user = new WP_User( $user_id );
        $user->set_role( $role );
        restore_current_blog();
    }
}

9. WooCommerce-Rollen-Erweiterungen

WooCommerce fügt eigene Rollen und Capabilities hinzu:

9.1 Shop Manager

// Shop Manager Capabilities
$shop_manager_caps = [
    'manage_woocommerce'       => true,
    'view_woocommerce_reports' => true,
    'edit_product'             => true,
    'edit_products'            => true,
    'publish_products'         => true,
    'read_private_products'    => true,
    'edit_others_products'     => true,
    'edit_private_products'    => true,
    'edit_published_products'  => true,
    'read_product'             => true,
];

9.2 Customer Rolle

// Customer hat minimale Berechtigungen
add_role( 'customer', 'Customer', [
    'read' => true,
] );

9.3 Eigene Produkt-Rollen

function wppoland_add_product_editor_role() {
    add_role( 'product_editor', 'Product Editor', [
        'read'                     => true,
        'edit_product'             => true,
        'edit_products'            => true,
        'edit_others_products'     => false, // Nur eigene Produkte
        'publish_products'         => false, // Zur Überprüfung
        'read_product'             => true,
        'upload_files'             => true,
    ] );
}

10. Sicherheits-Best-Practices 2026

10.1 Verwenden Sie keinen Benutzernamen ‘admin’

Brute-Force-Angriffe zielen auf die Benutzer-ID 1 oder den Benutzernamen ‘admin’.

10.2 Map Meta Capabilities

Wenn Sie Custom Post Types verwenden, nutzen Sie nicht einfach edit_posts. Mappen Sie granulare Caps:

register_post_type( 'book', [
    'capability_type' => 'book',
    'map_meta_cap'    => true, // Schlüssel für granulare Kontrolle
] );

Jetzt können Sie einem Benutzer edit_books geben, ohne ihm edit_posts zu geben.

10.3 Zwei-Faktor-Authentifizierung für Administratoren

function wppoland_require_2fa_for_admins() {
    $user = wp_get_current_user();
    if ( in_array( 'administrator', $user->roles ) ) {
        // Prüfe 2FA-Status
        if ( ! get_user_meta( $user->ID, 'two_factor_enabled', true ) ) {
            add_action( 'admin_notices', function() {
                echo '<div class="error"><p>2FA ist für Administratoren erforderlich!</p></div>';
            } );
        }
    }
}

10.4 Rollenbasierte Admin-Menu-Restriktionen

function wppoland_restrict_admin_menu() {
    if ( ! current_user_can( 'manage_options' ) ) {
        remove_menu_page( 'tools.php' );
        remove_menu_page( 'options-general.php' );
        remove_menu_page( 'plugins.php' );
        remove_menu_page( 'themes.php' );
    }
}
add_action( 'admin_menu', 'wppoland_restrict_admin_menu', 999 );

11. Troubleshooting

11.1 “Sie haben nicht die erforderlichen Rechte”

• Cache leeren (Objekt-Cache, Transients)
• Rollen zurücksetzen mit populate_roles()
• Plugin-Konflikte prüfen

11.2 Benutzerdefinierte Rollen verschwunden

• Datenbank-Tabelle wp_options prüfen (Key: wp_user_roles)
• Backup wiederherstellen
• Rollen neu erstellen

11.3 Berechtigungen werden nicht angewendet

• map_meta_cap auf true setzen
• Capabilities korrekt benennen
• WordPress-Standard-Capabilities als Referenz nutzen

11.4 Multisite-Probleme

• Super-Admin-Status prüfen
• switch_to_blog() / restore_current_blog() verwenden
• Netzwerk-weite Rollen-Synchronisation

12. FAQ

F: Wie viele Rollen sollte eine Website maximal haben? A: Idealerweise 4-6 Rollen. Zu viele Rollen führen zu Verwirrung und Management-Aufwand.

F: Kann ich Standardrollen löschen?

F: Was passiert mit Inhalten eines gelöschten Benutzers?

F: Wie teste ich Berechtigungen als Entwickler?

F: Sind benutzerdefinierte Capabilities sicherer?

F: Wie migriere ich Rollen zwischen Installationen?

F: Können Rollen zeitlich begrenzt sein?

Zusammenfassung

• Prinzip der geringsten Rechte: Geben Sie Benutzern nur das, was sie brauchen.
• Eigene Rollen: Besser als die Rolle ‘Redakteur’ zu hacken.
• Datenbank: Rollen leben in der DB, nicht im Code. Änderungen bleiben bestehen.
• Testen: Immer mit verschiedenen Rollen testen, bevor Sie live gehen.
• Capability-Tests: Prüfen Sie immer auf spezifische Berechtigungen, niemals auf Rollen.
• Meta-Caps: Verwenden Sie map_meta_cap für Custom Post Types.
• Regelmäßige Überprüfung: Auditieren Sie Benutzerrollen mindestens vierteljährlich.

13. Fortgeschrittene Techniken und Szenarien

13.1 Rollenbasierter Content-Zugriff

Oft möchten Sie, dass Benutzer nur ihre eigenen Beiträge sehen können, nicht die aller anderen. Hier ist, wie Sie das implementieren:

<?php
/**
 * Beschränke Autoren auf ihre eigenen Beiträge in der Beitragsliste
 */
function wppoland_restrict_authors_to_own_posts( $query ) {
    global $pagenow;

    // Nur im Admin-Bereich und nur für die Beitragsliste
    if ( ! is_admin() || $pagenow != 'edit.php' ) {
        return $query;
    }

    $current_user = wp_get_current_user();

    // Nur für Autoren und niedrigere Rollen
    if ( in_array( $current_user->ID, array( 1 ) ) ) {
        return $query; // Administratoren sehen alles
    }

    if ( in_array( 'author', $current_user->roles ) ||
         in_array( 'contributor', $current_user->roles ) ) {
        $query->set( 'author', $current_user->ID );
    }

    return $query;
}
add_action( 'pre_get_posts', 'wppoland_restrict_authors_to_own_posts' );

13.2 Zeitlich begrenzte Rollen

Für temporäre Zugriffe, wie Gastautoren oder zeitlich begrenzte Projekte:

<?php
/**
 * Weise einer Rolle ein Ablaufdatum zu
 */
function wppoland_schedule_role_expiry( $user_id, $role, $expiry_date ) {
    if ( ! is_multisite() ) {
        wp_schedule_single_event(
            strtotime( $expiry_date ),
            'wppoland_expire_user_role',
            array( $user_id, $role )
        );
    }
}

/**
 * Rolle nach Ablauf zurücksetzen
 */
function wppoland_expire_user_role( $user_id, $old_role ) {
    $user = new WP_User( $user_id );

    // Prüfen ob Benutzer noch die alte Rolle hat
    if ( in_array( $old_role, $user->roles ) ) {
        $user->set_role( 'subscriber' );
    }
}

add_action( 'wppoland_expire_user_role', 'wppoland_expire_user_role' );

// Beispiel: Rolle "Gastautor" läuft nach 30 Tagen ab
// wppoland_schedule_role_expiry( $user_id, 'guest_author', '+30 days' );

13.3 Rollen basierend auf Benutzer-Metadaten

Manchmal benötigen Sie dynamische Rollen basierend auf Benutzerattributen:

<?php
/**
 * Weise Rollen basierend auf Benutzer-Metadaten zu
 */
function wppoland_assign_role_from_metadata( $user_id ) {
    $department = get_user_meta( $user_id, 'department', true );
    $level = get_user_meta( $user_id, 'access_level', true );

    if ( ! $department || ! $level ) {
        return;
    }

    $role_name = $department . '_' . $level;
    $available_roles = wp_roles()->get_names();

    if ( array_key_exists( $role_name, $available_roles ) ) {
        $user = new WP_User( $user_id );
        $user->set_role( $role_name );
    }
}
add_action( 'user_register', 'wppoland_assign_role_from_metadata' );
add_action( 'profile_update', 'wppoland_assign_role_from_metadata' );

13.4 Bedingte Menüeinträge basierend auf Berechtigungen

Erweitern Sie das Admin-Menü mit rollenbasierten Einträgen:

<?php
/**
 * Füge benutzerdefiniertes Menü für bestimmte Rollen hinzu
 */
function wppoland_add_custom_admin_menu() {
    // Nur für Benutzer mit spezifischer Berechtigung
    if ( ! current_user_can( 'view_dashboard_widgets' ) ) {
        return;
    }

    add_menu_page(
        'Mein Dashboard',
        'Mein Dashboard',
        'view_dashboard_widgets',
        'my-custom-dashboard',
        'wppoland_render_custom_dashboard',
        'dashicons-desktop',
        2
    );
}
add_action( 'admin_menu', 'wppoland_add_custom_admin_menu', 99 );

function wppoland_render_custom_dashboard() {
    echo '<div class="wrap">';
    echo '<h1>Mein Custom Dashboard</h1>';
    echo '<p>Dieser Inhalt ist nur für Benutzer mit der Berechtigung "view_dashboard_widgets" sichtbar.</p>';
    echo '</div>';
}

13.5 Audit-Logging für Berechtigungsänderungen

Verfolgen Sie alle Änderungen an Benutzerrollen:

<?php
/**
 * Logge Rollenänderungen
 */
function wppoland_log_role_changes( $user_id, $role, $old_roles ) {
    $old_roles_str = implode( ', ', $old_roles );

    $log_entry = array(
        'user_id'     => $user_id,
        'old_roles'   => $old_roles_str,
        'new_role'    => $role,
        'changed_by'  => get_current_user_id(),
        'timestamp'   => current_time( 'mysql' ),
        'ip_address'  => $_SERVER['REMOTE_ADDR'],
    );

    // Speichere in Option oder Custom Table
    $logs = get_option( 'wppoland_role_change_logs', array() );
    $logs[] = $log_entry;

    // Behalte nur die letzten 1000 Einträge
    if ( count( $logs ) > 1000 ) {
        array_shift( $logs );
    }

    update_option( 'wppoland_role_change_logs', $logs );
}
add_action( 'set_user_role', 'wppoland_log_role_changes', 10, 3 );

14. Migration und Export/Import von Rollen

14.1 Exportieren von Rollen

<?php
/**
 * Exportiere alle Rollen und Berechtigungen
 */
function wppoland_export_roles() {
    global $wp_roles;

    $roles_data = array();

    foreach ( $wp_roles->roles as $role_name => $role_info ) {
        $roles_data[ $role_name ] = array(
            'name'         => $role_info['name'],
            'capabilities' => $role_info['capabilities'],
        );
    }

    return json_encode( $roles_data, JSON_PRETTY_PRINT );
}

// Verwendung:
$roles_json = wppoland_export_roles();
file_put_contents( 'roles-backup.json', $roles_json );

14.2 Importieren von Rollen

<?php
/**
 * Importiere Rollen aus JSON
 */
function wppoland_import_roles( $json_data ) {
    $roles_data = json_decode( $json_data, true );

    if ( ! $roles_data ) {
        return false;
    }

    foreach ( $roles_data as $role_name => $role_info ) {
        // Überspringe Standardrollen, wenn sie existieren
        if ( get_role( $role_name ) ) {
            continue;
        }

        add_role(
            $role_name,
            $role_info['name'],
            $role_info['capabilities']
        );
    }

    return true;
}

15. Performance-Überlegungen

15.1 Caching von Berechtigungen

WordPress cached Berechtigungen automatisch, aber bei vielen Rollen kann Performance leiden:

<?php
/**
 * Optimiere Rollen-Cache
 */
function wppoland_optimize_role_caching() {
    // Deaktiviere Rollen-Cache während Bulk-Operationen
    add_filter( 'user_has_cap', function( $caps, $cap, $user_id, $args ) {
        // Nur für spezifische Operationen
        if ( defined( 'DOING_BULK_ACTION' ) && DOING_BULK_ACTION ) {
            wp_cache_delete( $user_id, 'user_roles' );
        }
        return $caps;
    }, 10, 4 );
}

15.2 Vermeiden Sie übermäßige Rollen

Jede zusätzliche Rolle erhöht die Komplexität und den Wartungsaufwand. Halten Sie die Anzahl der Rollen überschaubar:

• Kleine Websites: 3-4 Rollen (Admin, Redakteur, Autor, Abonnent)
• Mittlere Websites: 5-6 Rollen (mit spezialisierten Rollen)
• Große Websites: Maximal 8-10 Rollen (mit klarer Hierarchie)

16. Fehlerbehebung bei häufigen Problemen

16.1 Berechtigungen werden nicht gespeichert

<?php
/**
 * Debug-Funktion für Rollenprobleme
 */
function wppoland_debug_roles() {
    if ( ! current_user_can( 'manage_options' ) ) {
        return;
    }

    global $wp_roles;

    echo '<pre>';
    echo 'Aktuelle Rollen und Berechtigungen:\n\n';

    foreach ( $wp_roles->roles as $role_name => $role_info ) {
        echo "Rolle: $role_name\n";
        echo "Berechtigungen: " . implode( ', ', array_keys( $role_info['capabilities'] ) ) . "\n\n";
    }

    echo '</pre>';
}

// Fügen Sie dies zu Ihrer functions.php hinzu und rufen Sie ?debug_roles im Admin auf

16.2 Benutzer kann trotz Berechtigung nicht zugreifen

Prüfen Sie auf Konflikte mit anderen Plugins:

<?php
/**
 * Debug: Zeige alle Berechtigungen eines Benutzers
 */
function wppoland_debug_user_caps() {
    $user = wp_get_current_user();

    echo '<h2>Debug: Benutzerberechtigungen</h2>';
    echo '<p>Benutzer: ' . $user->display_name . '</p>';
    echo '<p>Rollen: ' . implode( ', ', $user->roles ) . '</p>';

    echo '<h3>Alle Berechtigungen:</h3>';
    echo '<ul>';
    foreach ( $user->allcaps as $cap => $value ) {
        $status = $value ? '✅' : '❌';
        echo "<li>$status $cap</li>";
    }
    echo '</ul>';
}

// Fügen Sie dies zu Ihrer Test-Seite hinzu

Fazit

Das Beherrschen spezifischer Berechtigungen entscheidet über eine sichere Seite und eine gehackte. Das WordPress-Rollen- und Berechtigungssystem ist eines der mächtigsten Features der Plattform, aber es wird oft unterschätzt oder falsch verwendet. Durch die konsequente Anwendung des Prinzips der geringsten Rechte, die Erstellung eigener Rollen für spezifische Anwendungsfälle und regelmäßige Überprüfungen können Sie eine sichere und gut strukturierte WordPress-Website aufbauen.

Denken Sie daran: Geben Sie niemals mehr Zugriff als nötig, testen Sie Änderungen immer gründlich, und dokumentieren Sie Ihre Rollenstruktur für zukünftige Wartung und Übergaben. Eine durchdachte Berechtigungsstruktur ist nicht nur ein Sicherheitsmerkmal, sondern auch ein Zeichen professioneller Entwicklung.