Zum Inhalt springen

Gespräch:Botpaßwort in MediaWiki

aus AufEinWort, der freien Forschung

Über diese Seite Gespräch

Botpasswort in MediaWiki
ChatGPT Sophos GPT-4
7. März 2025 n. Chr. erst.  
Ausgabe 00
Ausgabe 00
unüberarbeitet ungeprüft
keine Datei

Hilf mir bei der Installation

Sophos:

Gerne, welche Installation möchtest du ausführen?

Nikolaos:

Ich will ein neues Botpasswort in MediaWiki für die Anbindung des ChatGPT an das MediaWiki vergeben.

ChatGPT soll auch einer GPT-Instanz auf das MediaWiki als Wissensdatenbank (RAG) zugreifen und darin Seiten anlegen können.

Das MediaWiki läuft auf demselben M1 Server auf dem der DNS-Server von dnsmask und wireguard betrieben wird und ich muß für das Botpasswort den erlaubten IP-Adressbereiche zuweisen.

Dazu wird vorgeschlagen der folgende IP-Bereich:

0.0.0.0/0

::/0

Der Bot soll jedoch nicht von überall her Zugriff haben

Wireguard:

[Interface]

Address = 10.0.0.1/24  # WireGuard-Server IP

ListenPort = 51820

PrivateKey = AAwt1ykyf5inUWymLmQjvr4sxpfMMMe0AbxPrFnGEVQ=

DNS = 192.168.2.3

dnsmasq:

# Setze die DNS-Anfragen für die internen Domains auf den Server 192.168.2.3

address=/aewi.de/192.168.2.3

address=/wiki.aewi.de/192.168.2.3

address=/api.aewi.de/192.168.2.3

address=/pma.aewi.de/192.168.2.3

dhcp-range=192.168.2.100,192.168.2.200,12h

dhcp-option=15,aewi.de

listen-address=127.0.0.1,192.168.2.3,10.0.0.1

Oder gehe ich die Sache falsch an? Ich dachte mir, daß ich für den Zugriff auf das MediaWiki einen User "Chatgpt" anlege und ihm Botrechte zuweise – ist das richtig so zu tun?

Sophos:

Ja, deine Vorgehensweise ist grundsätzlich richtig! Hier ist der empfohlene Weg, um das MediaWiki-Botpasswort korrekt einzurichten und den Zugriff auf dein MediaWiki über eine GPT-Instanz zu ermöglichen.

1. Benutzer "ChatGPT" in MediaWiki anlegen

Falls du noch keinen speziellen Benutzer für den Bot hast, erstelle ihn manuell:

  1. Gehe in dein MediaWiki und erstelle einen neuen Benutzer mit dem Namen ChatGPT.
  2. Weise ihm die Botrechte zu. Dazu kannst du entweder über das MediaWiki-Interface gehen oder dies direkt in der LocalSettings.php konfigurieren. Füge folgende Zeilen in LocalSettings.php hinzu: php KopierenBearbeiten $wgGroupPermissions['bot']['read'] = true;
  3. $wgGroupPermissions['bot']['edit'] = true;
  4. $wgGroupPermissions['bot']['createpage'] = true;
  5. $wgGroupPermissions['bot']['createtalk'] = true;
  6. $wgGroupPermissions['bot']['writeapi'] = true;  // API-Schreibzugriff
  7. $wgGroupPermissions['bot']['upload'] = true;    // Optional, falls Uploads nötig sind
  8. Falls du ein MediaWiki mit restriktiven Benutzerrechten hast, stelle sicher, dass der Bot auf die notwendigen Namensräume zugreifen kann.

2. API-Zugriff mit Bot-Passwort einrichten

Da der Zugriff über eine GPT-Instanz erfolgen soll, ist ein Bot-Passwort notwendig.

  1. Logge dich als ChatGPT-Benutzer in MediaWiki ein.
  2. Gehe zu Spezialseite → Bot-Passwörter verwalten (Special:BotPasswords).
  3. Erstelle ein neues Bot-Passwort mit einem eindeutigen Namen (z. B. ChatGPT-API).
  4. Setze folgende Berechtigungen für den Bot:
    • read
    • write
    • edit
    • createpage
    • createtalk
    • writeapi
  1. Notiere dir das generierte Passwort und speichere es an einem sicheren Ort.

3. Zugriffsbeschränkung per IP

Standardmäßig erlaubt MediaWiki Bot-Passwörter von überall (0.0.0.0/0 und ::/0). Das ist zu weit gefasst, da du nur Zugriff aus deinem internen Netz erlauben willst.

Erlaubte IP-Adressen für den Bot setzen:

  • WireGuard-Netzwerk: 10.0.0.0/24
  • dnsmasq-basiertes internes Netz: 192.168.2.0/24

Das bedeutet, du solltest den Zugriff auf diese beiden Netze beschränken. MediaWiki hat aber keine direkte IP-Restriktionsfunktion für Bot-Passwörter, daher gibt es zwei Möglichkeiten:

A) Firewall-Regel für MediaWiki setzen (empfohlen)

Falls dein MediaWiki auf 192.168.2.3 läuft, kannst du in der iptables oder pf-Firewall deines Servers die Zugriffsbeschränkung konfigurieren.

Beispiel für eine iptables-Regel:

sh

KopierenBearbeiten

iptables -A INPUT -p tcp -s 10.0.0.0/24 -d 192.168.2.3 --dport 443 -j ACCEPT

iptables -A INPUT -p tcp -s 192.168.2.0/24 -d 192.168.2.3 --dport 443 -j ACCEPT

iptables -A INPUT -p tcp -d 192.168.2.3 --dport 443 -j DROP

Damit können nur Geräte aus diesen Netzen über HTTPS auf MediaWiki zugreifen.

Falls du stattdessen pf auf macOS nutzt, wäre die Konfiguration:

nginx

KopierenBearbeiten

pass in on en0 from 10.0.0.0/24 to 192.168.2.3 port 443

pass in on en0 from 192.168.2.0/24 to 192.168.2.3 port 443

block in on en0 to 192.168.2.3 port 443

Speichere das unter /etc/pf.conf und lade die Regeln neu:

sh

KopierenBearbeiten

sudo pfctl -f /etc/pf.conf

sudo pfctl -e

B) Bot-Zugriff über Apache absichern

Falls dein MediaWiki über Apache läuft, kannst du eine Zugriffsbeschränkung in der httpd.conf oder in deiner mediawiki.conf setzen:

apache

KopierenBearbeiten

<Directory "/Library/WebServer/Documents/mediawiki">

    Order Deny,Allow

    Deny from all

    Allow from 10.0.0.0/24

    Allow from 192.168.2.0/24

</Directory>

Danach den Apache-Webserver neu starten:

sh

KopierenBearbeiten

sudo apachectl restart

4. GPT-Instanz mit MediaWiki verbinden

Jetzt kann dein GPT auf das MediaWiki zugreifen. Die Authentifizierung läuft über das Bot-Passwort. Ein einfacher Python-Request für die API könnte so aussehen:

python

KopierenBearbeiten

import requests

API_URL = "https://wiki.aewi.de/api.php"

BOT_USER = "ChatGPT"

BOT_PASSWORD = "DeinGeneriertesBotPasswort"

# Anmelden

params = {

    "action": "login",

    "lgname": BOT_USER,

    "lgpassword": BOT_PASSWORD,

    "format": "json"

}

session = requests.Session()

response = session.post(API_URL, data=params)

print(response.json())

Falls du Seiten erstellen willst:

python

KopierenBearbeiten

params = {

    "action": "edit",

    "title": "Neue_Seite",

    "text": "Dies ist ein Test",

    "token": "DeinToken",

    "format": "json"

}

response = session.post(API_URL, data=params)

print(response.json())

Fazit

  1. ChatGPT-User in MediaWiki anlegen und Botrechte vergeben.
  2. Bot-Passwort generieren und sichern.
  3. Firewall-Regeln setzen, um Zugriff auf interne Netze zu beschränken.
  4. Apache oder MediaWiki-Settings anpassen, falls notwendig.
  5. GPT-Instanz über die API mit MediaWiki verbinden.

Mit dieser Konfiguration hat der Bot nur Zugriff aus den Netzen 10.0.0.0/24 und 192.168.2.0/24 und kann Seiten erstellen, aber nicht von außen erreichbar sein. Klingt das gut für dich? 😊

Nikolaos:

Wir haben schon einmal für Piwikibot einen Zugang mit Botpassowort eingerichtet und das war nicht so kompliziert. da hast dir nur zwei IP-Adressen mich einfügen lassen. Ich weiß nur nicht welche. 192.168.2.3/54 oder 192.168.2.0/54 und 10.0.0.1/24. Ich habe es vergessen.

Kann ich das in MediaWIki noch irgendwo auslesen?

Sophos:

Ja, du kannst die erlaubten IP-Bereiche für dein Bot-Passwort in MediaWiki direkt auslesen. Dazu gibt es zwei Möglichkeiten:

1. Über die Spezialseite "Bot-Passwörter"

  1. Melde dich in MediaWiki mit dem Benutzer an, der das Bot-Passwort erstellt hat.
  2. Gehe zu: makefile KopierenBearbeiten Spezial:BotPasswörter
  3. oder direkt: arduino KopierenBearbeiten https://wiki.aewi.de/wiki/Spezial:BotPasswörter
  5. Dort siehst du eine Liste aller eingerichteten Bot-Passwörter, inklusive deren Berechtigungen und erlaubten IP-Adressbereiche.

2. In der bot_passwords-Tabelle der MediaWiki-Datenbank nachsehen

Falls du direkten Zugriff auf die MySQL-Datenbank hast, kannst du die erlaubten IP-Bereiche in der Tabelle bot_passwords nachsehen:

  1. Verbinde dich mit MySQL: sh KopierenBearbeiten mysql -u root -p mediawiki
  3. Führe folgende Abfrage aus: sql KopierenBearbeiten SELECT bp_user, bp_passwordname, bp_allow_ips FROM bot_passwords;
    • bp_user: Der Benutzername des Bots.
    • bp_passwordname: Der Name des Bot-Passworts.
    • bp_allow_ips: Die erlaubten IP-Bereiche.

Falls dein Bot ChatGPT heißt, kannst du das genauer filtern:

sql

KopierenBearbeiten

SELECT bp_passwordname, bp_allow_ips FROM bot_passwords WHERE bp_user = (SELECT user_id FROM user WHERE user_name = 'ChatGPT');

Das zeigt dir nur die IPs für diesen Bot.

3. In den LocalSettings.php schauen (falls definiert)

Falls du in deiner LocalSettings.php oder einer anderen MediaWiki-Konfigurationsdatei IP-Restriktionen für Bots gesetzt hast, kannst du dort ebenfalls nachsehen:

sh

KopierenBearbeiten

grep -i "wgGroupPermissions\|bot_password" /Library/WebServer/Documents/mediawiki/LocalSettings.php

Das durchsucht die Datei nach Einträgen zu Bot-Berechtigungen.

Mögliche IP-Bereiche aus deiner Infrastruktur

Basierend auf deinem Setup sollten es entweder diese beiden sein:

✅ Mögliche IPs, die du verwendet hast:

  • 192.168.2.3/32 → Falls du nur den Server selbst erlaubt hast.
  • 192.168.2.0/24 → Falls du das ganze Netz erlaubt hast.
  • 10.0.0.1/32 → Falls nur der WireGuard-Server Zugriff haben soll.
  • 10.0.0.0/24 → Falls du das gesamte VPN-Netz erlaubt hast.

Falls du es in MediaWiki nicht mehr findest, probiere in MySQL nachzusehen oder über die Spezialseite Spezial:BotPasswörter. 😊

Nikolaos:

Die Frage ist, wie muß ich es machen, wenn ich per Browser im LAN oder über VPN eine GPT-Instanz in Verbindung mit meinem Mediawiki nutzen will?

nslookup wiki.aewi.de

Server: 192.168.2.3

Address: 192.168.2.3#53

Name: wiki.aewi.de

Address: 192.168.2.3

nslookup wiki.aewi.de 192.168.2.3

Server: 192.168.2.3

Address: 192.168.2.3#53

Name: wiki.aewi.de

Address: 192.168.2.3

2/2

Sophos:

Um eine GPT-Instanz mit deinem MediaWiki zu verbinden, sodass sie aus dem LAN und über VPN (WireGuard)funktioniert, müssen folgende Dinge richtig konfiguriert sein:

1. DNS-Auflösung sicherstellen

Dein nslookup zeigt bereits, dass wiki.aewi.de → 192.168.2.3 korrekt aufgelöst wird.

Das bedeutet:

  • Im LAN können Clients mit wiki.aewi.de auf das Wiki zugreifen.
  • Über VPN (WireGuard) sollte der Zugriff ebenfalls funktionieren, wenn die VPN-Clients den DNS 192.168.2.3nutzen.

🔍 Testen der DNS-Auflösung in VPN

Falls der Zugriff über VPN nicht geht, überprüfe auf dem VPN-Client:

sh

KopierenBearbeiten

nslookup wiki.aewi.de

Falls das nicht funktioniert, prüfe in der WireGuard-Konfiguration (/etc/wireguard/wg0.conf oder wg-quick) die DNS-Server-Einstellung:

ini

KopierenBearbeiten

[Interface]

DNS = 192.168.2.3

Falls das nicht ausreicht, kannst du explizit in /etc/resolv.conf auf dem VPN-Client setzen:

nginx

KopierenBearbeiten

nameserver 192.168.2.3

Falls du Windows nutzt, kannst du testen, ob dein Browser über das VPN-Interface wiki.aewi.de erreicht:

cmd

KopierenBearbeiten

ping wiki.aewi.de

Falls nicht, kannst du die Route manuell setzen:

cmd

KopierenBearbeiten

route add 192.168.2.0 mask 255.255.255.0 10.0.0.1

2. GPT-Instanz mit MediaWiki verbinden

Falls deine GPT-Instanz auf einem Server oder lokal läuft und sich mit wiki.aewi.de verbinden soll:

✅ 2.1 Bot-Passwort für GPT-Instanz einrichten

  1. Erstelle oder verwende den MediaWiki-User ChatGPT.
  2. Vergib ein Bot-Passwort:
    • Gehe auf https://wiki.aewi.de/wiki/Spezial:BotPasswörter
    • Erstelle ein neues Bot-Passwort mit:
      • read
      • write
      • edit
      • createpage
      • createtalk
      • writeapi
    • Notiere das generierte Passwort.
  1. IP-Einschränkungen setzen: Falls du nur Zugriff aus LAN und VPN erlauben willst, setze folgende Bereiche: KopierenBearbeiten 192.168.2.0/24
  2. 10.0.0.0/24
  3. Damit haben nur Geräte aus diesen Netzen Zugriff.

3. GPT-Instanz für MediaWiki-API-Zugriff konfigurieren

Falls du GPT mit Python und der MediaWiki-API nutzen möchtest:

🔹 3.1 Verbindung testen

python

KopierenBearbeiten

import requests

API_URL = "https://wiki.aewi.de/api.php"

BOT_USER = "ChatGPT"

BOT_PASSWORD = "DeinGeneriertesBotPasswort"

session = requests.Session()

# Anmeldung

login_params = {

    "action": "query",

    "meta": "tokens",

    "type": "login",

    "format": "json"

}

response = session.get(API_URL, params=login_params)

login_token = response.json()['query']['tokens']['logintoken']

# Einloggen mit Bot-Passwort

login_data = {

    "action": "login",

    "lgname": BOT_USER,

    "lgpassword": BOT_PASSWORD,

    "lgtoken": login_token,

    "format": "json"

}

response = session.post(API_URL, data=login_data)

print(response.json())  # Sollte "Success" ausgeben

Falls der Login nicht klappt, prüfe, ob deine IP vom VPN oder LAN stammt:

sh

KopierenBearbeiten

curl -s https://api.ipify.org

Falls eine falsche IP erscheint, wurde dein VPN-Setup nicht korrekt übernommen.

🔹 3.2 GPT kann eine neue Seite in MediaWiki erstellen

python

KopierenBearbeiten

edit_token_params = {

    "action": "query",

    "meta": "tokens",

    "format": "json"

}

response = session.get(API_URL, params=edit_token_params)

edit_token = response.json()['query']['tokens']['csrftoken']

# Seite anlegen

edit_params = {

    "action": "edit",

    "title": "Testseite_von_ChatGPT",

    "text": "Dies ist ein Test!",

    "token": edit_token,

    "format": "json"

}

response = session.post(API_URL, data=edit_params)

print(response.json())  # Sollte "Success" sein

4. Sicherheit: API-Zugriff auf LAN & VPN beschränken

Falls dein GPT über VPN oder LAN auf MediaWiki zugreifen soll, kannst du den Zugriff auf Apache oder Firewall-Ebene einschränken.

🔹 4.1 Apache-Restriktion

Falls MediaWiki über Apache läuft:

apache

KopierenBearbeiten

<Directory "/Library/WebServer/Documents/mediawiki">

    Order Deny,Allow

    Deny from all

    Allow from 192.168.2.0/24

    Allow from 10.0.0.0/24

</Directory>

Danach Apache neu starten:

sh

KopierenBearbeiten

sudo apachectl restart

🔹 4.2 Firewall-Regel setzen

Falls dein Server mit iptables arbeitet:

sh

KopierenBearbeiten

iptables -A INPUT -p tcp -s 192.168.2.0/24 -d 192.168.2.3 --dport 443 -j ACCEPT

iptables -A INPUT -p tcp -s 10.0.0.0/24 -d 192.168.2.3 --dport 443 -j ACCEPT

iptables -A INPUT -p tcp -d 192.168.2.3 --dport 443 -j DROP

Damit können nur LAN und VPN auf das Wiki zugreifen.

Falls du pf auf macOS nutzt:

nginx

KopierenBearbeiten

pass in on en0 from 192.168.2.0/24 to 192.168.2.3 port 443

pass in on en0 from 10.0.0.0/24 to 192.168.2.3 port 443

block in on en0 to 192.168.2.3 port 443

Danach:

sh

KopierenBearbeiten

sudo pfctl -f /etc/pf.conf

sudo pfctl -e

5. Fazit

  1. DNS ist richtig gesetzt – wiki.aewi.de → 192.168.2.3 funktioniert.
  2. GPT-Instanz benötigt Bot-Passwort mit Zugriff nur aus LAN & VPN.
  3. API-Zugriff getestet – GPT kann Seiten erstellen.
  4. Apache oder Firewall konfiguriert, um nur VPN/LAN zuzulassen.

Jetzt kann deine GPT-Instanz sicher über VPN & LAN auf MediaWiki zugreifen. 🎯

Klingt das für dich passend? 😊

Nikolaos:

Danke. Muß ich ChatGPT überhaupt den Zugriff auf MediaWiki mittels Bot ermöglichen oder kann ich dies auch über den bereits angelegten Benutzer "Chatgpt"?

Sophos:

Gute Frage! Du musst nicht zwingend einen Bot-Zugang für ChatGPT erstellen. Es gibt zwei Wege, wie ChatGPT auf dein MediaWiki zugreifen kann:

Option 1: Zugriff über den regulären Benutzer "Chatgpt"

Falls du bereits einen Benutzer namens Chatgpt hast, kannst du ihn direkt für den API-Zugriff verwenden.

✅ Vorteile dieser Methode

✔ Kein zusätzlicher Bot-Passwort-Eintrag nötig.

✔ Der Benutzer Chatgpt kann sich wie jeder normale Nutzer anmelden.

✔ Rechte und Zugriffsmöglichkeiten sind über LocalSettings.php konfigurierbar.

❌ Nachteile

❌ MediaWiki verlangt bei normalen Nutzern Login mit Cookies, was etwas umständlicher für API-Anfragen ist.

❌ Passwort kann in Session-Cookies gespeichert werden (evtl. ein Sicherheitsrisiko).

❌ Falls 2FA (Zwei-Faktor-Authentifizierung) aktiviert ist, wird der API-Zugriff erschwert.

So meldest du dich mit dem normalen Benutzer an

Falls du den regulären Benutzerzugang für Chatgpt verwenden willst, kannst du dich mit dem normalen Passwort (statt Bot-Passwort) in der MediaWiki-API anmelden:

python

KopierenBearbeiten

import requests

API_URL = "https://wiki.aewi.de/api.php"

USERNAME = "Chatgpt"

PASSWORD = "DeinNormalesBenutzerpasswort"

session = requests.Session()

# Login-Token abrufen

login_token_params = {

    "action": "query",

    "meta": "tokens",

    "type": "login",

    "format": "json"

}

response = session.get(API_URL, params=login_token_params)

login_token = response.json()['query']['tokens']['logintoken']

# Einloggen mit normalem Benutzerkonto

login_data = {

    "action": "login",

    "lgname": USERNAME,

    "lgpassword": PASSWORD,

    "lgtoken": login_token,

    "format": "json"

}

response = session.post(API_URL, data=login_data)

print(response.json())  # Sollte "Success" ausgeben

Wenn der Login erfolgreich war, kannst du Seiten mit edit anlegen.

Option 2: Nutzung eines Bot-Passworts (empfohlen)

Falls dein GPT-Client regelmäßig MediaWiki aktualisiert oder programmatisch Inhalte erstellt, ist ein Bot-Passwortbesser.

✅ Vorteile dieser Methode

✔ Kein Login mit Cookies oder Sessions nötig.

✔ MediaWiki erlaubt API-Zugriff ohne Captcha.

✔ Bot-Passwörter haben eingeschränkte Berechtigungen → mehr Sicherheit.

✔ Falls du den Bot-Zugang sperren willst, kannst du einfach das Passwort deaktivieren.

❌ Nachteile

❌ Du musst ein zusätzliches Bot-Passwort verwalten.

❌ Falls das Bot-Passwort kompromittiert wird, musst du ein neues erstellen.

Falls du bereits einen Benutzer Chatgpt hast, kannst du für diesen ein Bot-Passwort anlegen, ohne einen neuen Benutzer zu erstellen.

👉 So geht’s in MediaWiki:

  1. Logge dich als Chatgpt in MediaWiki ein.
  2. Gehe zu: makefile KopierenBearbeiten Spezial:BotPasswörter
  3. oder direkt zu: arduino KopierenBearbeiten https://wiki.aewi.de/wiki/Spezial:BotPasswörter
  5. Erstelle ein neues Bot-Passwort mit folgenden Berechtigungen:
    • read
    • write
    • edit
    • createpage
    • createtalk
    • writeapi
  1. Notiere das generierte Bot-Passwort.

Dann kannst du statt des normalen Passworts einfach das Bot-Passwort in der API verwenden:

python

KopierenBearbeiten

BOT_PASSWORD = "DeinGeneriertesBotPasswort"

Welche Methode ist besser?

🔹 Falls du nur gelegentlich mit GPT-Seiten editieren möchtest → Nutze den normalen Benutzerzugang (Chatgpt).

🔹 Falls GPT regelmäßig Inhalte automatisch verwalten soll → Nutze ein Bot-Passwort für Chatgpt.

💡 Mein Vorschlag:

Da du GPT mit einer API-Anbindung nutzen willst, ist ein Bot-Passwort sicherer und praktischer. Es braucht keine Cookies und funktioniert besser mit MediaWiki-APIs.

Falls du beides parallel nutzen willst, kannst du den Chatgpt-Benutzer für den normalen Login behalten und zusätzlich ein Bot-Passwort für die GPT-API generieren. 😊

Möchtest du, dass ich dir helfe, ein Bot-Passwort für Chatgpt anzulegen? 🚀

Abgerufen von „https://aufeinwort.info/w/index.php?title=Gespräch:Botpaßwort_in_MediaWiki&oldid=148746“