API:Login

From mediawiki.org
This page is a translated version of the page API:Login and the translation is 80% complete.
Outdated translations are marked like this.
Languages:

MediaWiki API kann von Deiner Applikation oder Deinem Client verlangen, authentifizierte Benutzer-Credentials für (a) Query-Informationen oder datenmodifizierende Aktionen (b) die große Queries mit höheren Request-per-Limits vorzuweisen.

Zwei Methoden für die Authentifizierung

Es gibt zwei Wege, um sich bei der MediaWiki action API zu authentifizieren:

Methode 1. Login

Bot- und andere nichtinteraktive Applikationen sollten wenn verfügbar owner-only OAuth consumers verwenden, weil das sicherer ist. Wenn nicht verfügbar oder mit dem Client nicht anwendbar, kann die login-Action mit Botpasswörtern verwendet werden.

API-Dokumentation

action=login (lg)

(main | login)
  • This module requires write rights.
  • This module only accepts POST requests.
  • Source: MediaWiki
  • License: GPL-2.0-or-later

Log in and get authentication cookies.

This action should only be used in combination with Special:BotPasswords; use for main-account login is deprecated and may fail without warning. To safely log in to the main account, use action=clientlogin.

Specific parameters:
Other general parameters are available.
lgname

Username.

lgpassword

Password.

lgdomain

Domain (optional).

lgtoken

A "login" token retrieved from action=query&meta=tokens

Example:
Log in.
api.php?action=login&lgname=user&lgpassword=password&lgtoken=123ABC [open in sandbox]

Beispiel

POST-Anfrage

api.php?action=login&lgname=user&lgpassword=secret&lgtoken=123456&format=json [In der ApiSandbox ausprobieren]


lgtoken in in der obigen Abfrage wird abgerufen aus API:Tokens

Antwort

{  
   "login": {  
      "lguserid": 21,
      "result": "Success",
      "lgusername": "William"
   }
}

Beispielcode

MediaWiki JS

/*
	login.js
	MediaWiki API Demos
	Demo of `Login` module: Sending request to login
	MIT License
*/

var api = new mw.Api();

api.login( 'your_bot_username', 'your_bot_password' ).done( function ( data ) {
	console.log( 'You are logged in as ' + data.login.lgusername );
} );

JavaScript

/*
	edit.js

	MediaWiki API Demos
	Demo of `Login` module: Sending post request to login

	MIT license
*/

var request = require( 'request' ).defaults( { jar: true } ),
	url = 'https://test.wikipedia.org/w/api.php';

// Step 1: GET request to fetch login token
function getLoginToken() {
	var params = {
		action: 'query',
		meta: 'tokens',
		type: 'login',
		format: 'json'
	};

	request.get( { url: url, qs: params }, function ( error, res, body ) {
		var data;
		if ( error ) {
			return;
		}
		data = JSON.parse( body );
		loginRequest( data.query.tokens.logintoken );
	} );
}

// Step 2: POST request to log in.
// Use of main account for login is not
// supported. Obtain credentials via Special:BotPasswords
// (https://www.mediawiki.org/wiki/Special:BotPasswords) for lgname & lgpassword
function loginRequest( loginToken ) {
	var params = {
		action: 'login',
		lgname: 'bot_username',
		lgpassword: 'bot_password',
		lgtoken: loginToken,
		format: 'json'
	};

	request.post( { url: url, form: params }, function ( error, res, body ) {
		if ( error ) {
			return;
		}
		console.log( body );
	} );
}

// Start From Step 1
getLoginToken();

PHP

<?php

/*
    login.php

    MediaWiki API Demos
    Demo of `Login` module: Sending post request to login
    MIT license
*/

$endPoint = "https://test.wikipedia.org/w/api.php";

$login_Token = getLoginToken(); // Step 1
loginRequest( $login_Token ); // Step 2

// Step 1: GET request to fetch login token
function getLoginToken() {
	global $endPoint;

	$params1 = [
		"action" => "query",
		"meta" => "tokens",
		"type" => "login",
		"format" => "json"
	];

	$url = $endPoint . "?" . http_build_query( $params1 );

	$ch = curl_init( $url );
	curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
	curl_setopt( $ch, CURLOPT_COOKIEJAR, "/tmp/cookie.txt" );
	curl_setopt( $ch, CURLOPT_COOKIEFILE, "/tmp/cookie.txt" );

	$output = curl_exec( $ch );
	curl_close( $ch );

	$result = json_decode( $output, true );
	return $result["query"]["tokens"]["logintoken"];
}

// Step 2: POST request to log in. Use of main account for login is not
// supported. Obtain credentials via Special:BotPasswords
// (https://www.mediawiki.org/wiki/Special:BotPasswords) for lgname & lgpassword
function loginRequest( $logintoken ) {
	global $endPoint;

	$params2 = [
		"action" => "login",
		"lgname" => "your_bot_username",
		"lgpassword" => "your_bot_password",
		"lgtoken" => $logintoken,
		"format" => "json"
	];

	$ch = curl_init();

	curl_setopt( $ch, CURLOPT_URL, $endPoint );
	curl_setopt( $ch, CURLOPT_POST, true );
	curl_setopt( $ch, CURLOPT_POSTFIELDS, http_build_query( $params2 ) );
	curl_setopt( $ch, CURLOPT_RETURNTRANSFER, true );
	curl_setopt( $ch, CURLOPT_COOKIEJAR, "/tmp/cookie.txt" );
	curl_setopt( $ch, CURLOPT_COOKIEFILE, "/tmp/cookie.txt" );

	$output = curl_exec( $ch );
	curl_close( $ch );

	echo( $output );
}

Python

#!/usr/bin/python3

"""
    login.py

    MediaWiki API Demos
    Demo of `Login` module: Sending post request to login
    MIT license
"""

import requests

USERNAME = "your_bot_username"
PASSWORD = "your_bot_password"

S = requests.Session()

URL = "https://www.mediawiki.org/w/api.php"

# Retrieve login token first
PARAMS_0 = {
    'action':"query",
    'meta':"tokens",
    'type':"login",
    'format':"json"
}

R = S.get(url=URL, params=PARAMS_0)
DATA = R.json()

LOGIN_TOKEN = DATA['query']['tokens']['logintoken']

print(LOGIN_TOKEN)

# Send a post request to login. Using the main account for login is not
# supported. Obtain credentials via Special:BotPasswords
# (https://www.mediawiki.org/wiki/Special:BotPasswords) for lgname & lgpassword

PARAMS_1 = {
    'action': "login",
    'lgname': USERNAME,
    'lgpassword': PASSWORD,
    'lgtoken': LOGIN_TOKEN,
    'format': "json"
}

R = S.post(URL, data=PARAMS_1)
DATA = R.json()

print(DATA)
assert DATA['login']['result'] == 'Success'
Ab MediaWiki 1.27 wird die Nutzung des Hauptkontos für die Anmeldung nicht unterstützt. Erhalte Anmeldeinformationen über Special:BotPasswords oder nutze die Methode clientlogin. Das Anmelden und angemeldet bleiben erfordert die korrekte Behandlung von HTTP-Cookies durch deinen Client bei allen Abfragen. Im obigen Beispiel zeigen wir, wie ein Sitzungsobjekt requests.Session() dabei hilft, Cookies beizubehalten.

Mögliche Fehler

Code Information
Failed Falscher Benutzername oder falsches Passwort eingegeben. Bitte erneut versuchen.
Failed Du kannst die Anmeldung nicht fortsetzen. Wahrscheinlich wurde deine Sitzung beendet. (oder du handhabst Cookies nicht richtig).
WrongToken Fehlerhaftes Token übergeben
NeedToken `lgtoken` nicht übergeben
Aborted Anmeldung mit dem Hauptpasswort statt mit Botpasswörtern
mustpostparams The following parameters were found in the query string, but must be in the POST body: $1.

Methode 2. action=clientlogin

Interaktive Anwendungen wie benutzerdefinierte Editoren oder Kontroll-Anwendungen, die einen Service anbieten, ohne die Webseite vollständig ersetzen zu wollen oder mobile Anwendungen, die den Zugriff auf die webbasierte Benutzeroberfläche komplett ersetzen wollen, sollten clientlogin nutzen. Jedoch sollte die Nutzung von OAuth bevorzugt werden, wenn es möglich ist, das Tool zu authentifizieren, da dies einfacher und sicherer ist. Dieses Modul ist seit MediaWiki 1.27 verfügbar.

API-Dokumentation

action=clientlogin (login)

(main | clientlogin)
  • This module requires write rights.
  • This module only accepts POST requests.
  • Source: MediaWiki
  • License: GPL-2.0-or-later

Log in to the wiki using the interactive flow.

The general procedure to use this module is:

  1. Fetch the fields available from action=query&meta=authmanagerinfo with amirequestsfor=login, and a login token from action=query&meta=tokens.
  2. Present the fields to the user, and obtain their submission.
  3. Post to this module, supplying loginreturnurl and any relevant fields.
  4. Check the status in the response.
    • If you received PASS or FAIL, you're done. The operation either succeeded or it didn't.
    • If you received UI, present the new fields to the user and obtain their submission. Then post to this module with logincontinue and the relevant fields set, and repeat step 4.
    • If you received REDIRECT, direct the user to the redirecttarget and wait for the return to loginreturnurl. Then post to this module with logincontinue and any fields passed to the return URL, and repeat step 4.
    • If you received RESTART, that means the authentication worked but we don't have a linked user account. You might treat this as UI or as FAIL.
Specific parameters:
Other general parameters are available.
loginrequests

Only use these authentication requests, by the id returned from action=query&meta=authmanagerinfo with amirequestsfor=login or from a previous response from this module.

Separate values with | or alternative.
Maximum number of values is 50 (500 for clients that are allowed higher limits).
loginmessageformat

Format to use for returning messages.

One of the following values: html, none, raw, wikitext
Default: wikitext
loginmergerequestfields

Merge field information for all authentication requests into one array.

Type: boolean (details)
loginpreservestate

Preserve state from a previous failed login attempt, if possible.

Type: boolean (details)
loginreturnurl

Return URL for third-party authentication flows, must be absolute. Either this or logincontinue is required.

Upon receiving a REDIRECT response, you will typically open a browser or web view to the specified redirecttarget URL for a third-party authentication flow. When that completes, the third party will send the browser or web view to this URL. You should extract any query or POST parameters from the URL and pass them as a logincontinue request to this API module.

logincontinue

This request is a continuation after an earlier UI or REDIRECT response. Either this or loginreturnurl is required.

Type: boolean (details)
logintoken

A "login" token retrieved from action=query&meta=tokens

This parameter is required.
*
This module accepts additional parameters depending on the available authentication requests. Use action=query&meta=authmanagerinfo with amirequestsfor=login (or a previous response from this module, if applicable) to determine the requests available and the fields that they use.
Examples:
Start the process of logging in to the wiki as user Example with password ExamplePassword.
api.php?action=clientlogin&username=Example&password=ExamplePassword&loginreturnurl=http://example.org/&logintoken=123ABC [open in sandbox]
Continue logging in after a UI response for two-factor auth, supplying an OATHToken of 987654.
api.php?action=clientlogin&logincontinue=1&OATHToken=987654&logintoken=123ABC [open in sandbox]

Beispiel 1: Prozess für ein Wiki ohne spezielle Authentifizierungserweiterungen

POST-Anfrage

api.php?action=clientlogin&loginreturnurl=http://example.com/&logintoken=29590a3037d325be70b93fb8258ed29257448cfb%2B%5C&username=William&password=secret [In der ApiSandbox ausprobieren]


Das Login-Token in der Abfrage oben wird über API:Tokens erhalten.

Antwort

{  
   "clientlogin":{  
      "status":"PASS",
      "username":"William"
   }
}

Beispielcode

clientlogin.py
#!/usr/bin/python3

"""
    clientlogin.py

    MediaWiki Action API Code Samples
    Demo of `clientlogin` module: Sending post request to login

    This demo app uses Flask (a Python web development framework).

    MIT license
"""

import requests
from flask import Flask, render_template, flash, request

S = requests.Session()
URL = "https://en.wikipedia.org/w/api.php"

# App config.
DEBUG = True
APP = Flask(__name__)
APP.config.from_object(__name__)
APP.config['SECRET_KEY'] = 'enter_your_secret_key'


@APP.route("/", methods=['GET', 'POST'])
def show_form():
    """ Render form template and handle form submission request """

    if request.method == 'POST':
        username = request.form['username']
        password = request.form['password']
        start_client_login(username, password)

    return render_template('clientlogin_form.html')

def start_client_login(username, password):
    """ Send a post request along with login token, user information
    and return URL to the API to log in on a wiki """

    login_token = fetch_login_token()

    response = S.post(url=URL, data={
        'action': "clientlogin",
        'username': username,
        'password': password,
        'loginreturnurl': 'http://127.0.0.1:5000/',
        'logintoken': login_token,
        'format': "json"
    })

    data = response.json()

    if data['clientlogin']['status'] == 'PASS':
        flash('Login success! Welcome, ' + data['clientlogin']['username'] + '!')
    else:
        flash('Oops! Something went wrong -- ' + data['clientlogin']['messagecode'])

def fetch_login_token():
    """ Fetch login token via `tokens` module """

    response = S.get(
        url=URL,
        params={
            'action': "query",
            'meta': "tokens",
            'type': "login",
            'format': "json"})
    data = response.json()
    return data['query']['tokens']['logintoken']

if __name__ == "__main__":
    APP.run()
form.html
<!DOCTYPE html>
  <title>MediaWiki Log in</title>
  <link rel="stylesheet" href="static/bootstrap/css/bootstrap.min.css">

<div class="container">
  <h2>MediaWiki Log in</h2>
  <form action="" method="post" role="form">
    <div class="form-group">
      <div class="form-field">
        <div class="label-field">Username</div>
        <input name="username">
      </div>
      <div class="form-field">
        <div class="label-field">Password</div>
        <input type="password" name="password">
      </div>
    </div>
    <button type="submit" class="btn btn-success">Log in</button>
  </form>
  <br>
  {% with messages = get_flashed_messages(with_categories=true) %}
  {% if messages %}
  {% for message in messages %}
  <div class="alert alert-info">
    {{ message[1] }}
  </div>
  {% endfor %}
  {% endif %}
  {% endwith %}
</div>
<br>
</div>
</div>

Beispiel 2: Prozess für ein Wiki mit speziellen Authentifizierungserweiterungen

Ein Wiki mit speziellen Authentifizierungserweiterungen wie ConfirmEdit (Captchas), Erweiterung:OpenID Connect oder Erweiterung:OATHAuth (Zwei-Faktor-Authentifizierung) kann einen komplizierteren Authentifizierungsprozess enthalten. In diesem Fall können bestimmte Felder erforderlich sein, deren Beschreibung aus der API:Authmanagerinfo -Abfrage entnommen werden kann.

Schritt 1: Beantwortung des CAPTCHA und Auswahl der OpenID-Authentifikation

This documentation is an example and does not reflect the behavior of any specific currently-available OpenID extension.

api.php?action=clientlogin&loginreturnurl=http://example.com/authenticating.php&logintoken=29590a3037d325be70b93fb8258ed29257448cfb%2B%5C&captchaId=12345&captchaWord=MediaWikiIsCool&rememberMe=1&openIdProvider=openid.example.net&useOpenId=1 [In der ApiSandbox ausprobieren]


Vom Client wird erwartet, den Browser des Benutzers zum bereitgestellten redirecttarget weiterzuleiten. Der OpenID-Anbieter sollte authentifizieren und zu Special:OpenIDConnectReturn im Wiki weiterleiten, was die OpenID-Antwort validieren würde und dann weiterleiten zur loginreturnurl, die im ersten POST an die API bereitgestellt wurde, mit angehängten code- und state-Parametern. Der Client erhält an diesem Punkt die Konktrolle über den Prozess zurück und macht seine nächste API-Anfrage.
Antwort
{
    "clientlogin": {
        "status": "REDIRECT",
        "redirecttarget": "https://openid.example.net/openid-auth.php?scope=openid&response_type=code&client_id=ABC&redirect_uri=https://wiki.example.org/wiki/Special:OpenIDConnectReturn&state=XYZ123",
        "requests": [
            {
                "id": "OpenIdConnectResponseAuthenticationRequest",
                "metadata": {},
                "required": "required",
                "provider": "OpenID Connect at example.net",
                "account": "",
                "fields": {
                    "code": {
                        "type": "string",
                        "label": "OpenID Code",
                        "help": "OpenID Connect code response"
                    },
                    "state": {
                        "type": "string",
                        "label": "OpenID State",
                        "help": "OpenID Connect state response"
                    },
                }
            }
        ]
    }
}
Nun muss der Client die Benutzer bitten, ihre Zwei-Faktor-Authentifizierungs-App für den aktuellen Code zu prüfen und dies zurück an den Server zu übermitteln, um den Authentifizierungsprozess fortzusetzen.
Antwort
{
    "clientlogin": {
        "status": "UI",
        "message": "Two-factor authentication",
        "requests": [
            {
                "id": "TwoFactorAuthenticationRequest",
                "metadata": {},
                "required": "required",
                "provider": "",
                "account": "",
                "fields": {
                    "code": {
                        "type": "string",
                        "label": "Code",
                        "help": "Two-factor authentication code"
                    }
                }
            }
        ]
    }
}
Beachte: In bestimmten Fällen ist es möglich, eineRESTART-Antwort zu erhalten, zum Beispiel, wenn die OpenID Connect-Erweiterung kein Mappung für den OpenID-Account eines lokalen Benutzers findet. In diesem Fall kann der Client dien Loginprozess ganz von vorn neustarten oder zur Accounterstellung wechseln wollen. In beiden Fällen gibt er den loginpreservestate- oder den createpreservestate-Parameter mit, um einige Status zu erhalten. In this case the client might restart the login process from the beginning or might switch to account creation, in either case passing the loginpreservestate or createpreservestate parameter to preserve some state.
Antwort
{
    "clientlogin": {
        "status": "PASS",
        "username": "Alice"
    }
}

Zusätzliche Anmerkungen

  • In Wikis, die anonymes Bearbeiten erlauben ist möglich, mit der API zu bearbeiten, ohne sich einzuloggen, aber es ist sehr empfehlenswert, dass Du dich einloggst. In privaten Wikis ist das Einloggen für jeder API-Funktinalität erforderlich.
  • Es wird empfohlen, ein separates Benutzerkonto für Ihre Anwendung zu erstellen. Dies ist besonders wichtig, wenn Ihre Anwendung eine automatisierte Bearbeitung durchführt oder große oder leistungsintensive Abfragen aufruft. Auf diese Weise ist es einfach, von der Anwendung vorgenommene Änderungen zu verfolgen und Sonderrechte auf das Konto der Anwendung anzuwenden. This is especially important if your application is carrying out automated editing or invoking large or performance-intensive queries. With that, it is easy to track changes made by the application and apply special rights to the application's account.
  • Wenn du eine Abfrage sendest, die von einem angemeldeten Benutzer gestellt werden soll, füge der Abfrage, die du sendest, den Parameter assert=user hinzu, um zu prüfen, ob der Benutzer angemeldet ist. Wenn der Benutzer nicht angemeldet ist, wird ein assertuserfailed Fehlercode zurückgegeben. See API:Assert for details.
  • Um zu prüfen, ob das Konto Bot-Rechte hat, füge der Abfrage den Parameter assert=bot hinzu. Wenn der Benutzer keine Bot-Rechte hat, wird ein Fehlercode assertbotfailed zurückgegeben. Siehe API:Assert für Details.

Siehe auch

Retrieved from "https://www.mediawiki.org/w/index.php?title=API:Login/de&oldid=6334413"