Come funziona l'autenticazione con MoinMoin

Storicamente MoinMoin ha supportato solamente autenticazione con nome utente/password e sessioni basate su cookie: si esegue l'accesso attraverso la pagina di accesso, moin imposta in cookie e da quel momento in poi il cookie è usato per l'autenticazione fino a quando non ci si disconnette o il cookie viene cancellato (oppure scade).

In molti ambienti questo metodo non è dei più ottimali, dato che le restrizioni di accesso dovrebbero essere basate su database di utenti come LDAP (Active Directory). Per questo motivo, è stata sviluppata per MoinMoin un'autenticazione modulare, configurabile attraverso la variabile auth in cui vengono inseriti una serie di metodi di autenticazione che vengono utilizzati esattamente in quell'ordine.

Quando viene usato un database di utenti esterno, non è utile ricreare tutti gli utenti in moin. Per questo motivo è stata aggiunta l'opzione user_autocreate. Se viene impostata a True un nuovo profilo utente verrà creato automaticamente quando un utente ha superato l'autenticazione (e il sistema di autenticazione supporto la creazione automatica).

Attualmente sono supportati i seguenti metodi di autenticazione:

Configurazione server	Autenticazione	Classe in moin
Tutte	moin via nome utente/password	`MoinMoin.auth.MoinAuth`
	sessione PHP	`MoinMoin.auth.php_session.PHPSessionAuth`
	moin via cookie esterno	Consultare `contrib/auth_externalcookie/`
	OpenID	`MoinMoin.auth.openidrp.OpenIDAuth`
	verifica OpenID da http://botbouncer.com/	`MoinMoin.auth.botbouncer.BotBouncer`
Apache con CGI, modpy o FastCgi	moduli di Apache: HTTP Basic, HTTP Digest, SSPI (NTLM) o LDAP	`MoinMoin.auth.http.HTTPAuth`
Apache con CGI, modpy o FastCgi	moin via LDAP	`MoinMoin.auth.ldap_login.LDAPAuth`
moin attraverso un wiki moin remoto	`MoinMoin.auth.interwiki` (sperimentale)
Apache+SSL con CGI, modpy o FastCgi	Apache via certificazione client SSL	`MoinMoin.auth.sslclientcert.SSLClientCertAuth`
Twisted	HTTP Basic (ma non esegue richieste di autenticazione via header, è utile quindi per automatizzazioni non per i browser)	`MoinMoin.auth.http.HTTPAuth`
IIS	HTTP Basic, SSPI (NTLM), (?)	`MoinMoin.auth.http.HTTPAuth`, (?)

Altre pseudo-autenticazioni

Quelle che seguono non sono propriamente dei metodi di autenticazione, dato che non autenticano alcun utente, ma usano auth per altri scopi:

`MoinMoin.auth.log.AuthLog`	registra i login/logout/request, niente di più
`MoinMoin.auth.smb_mount.SMBMount`	monta delle condivisioni smb usando utente/password di accesso, smonta alla disconnessione

Plug-in forniti

MoinAuth (predefinito)

Questo è il metodo auth predefinito usato da moin (se è richiesto solo questo non è necessario configurarlo).

   1     from MoinMoin.auth import MoinAuth
   2     auth = [MoinAuth()]

Autenticazione HTTP

Per attivare l'autenticazione HTTP è necessario aggiungere quanto segue a wikiconfig.py:

   1     from MoinMoin.auth.http import HTTPAuth
   2     auth = [HTTPAuth()]

Per l'autenticazione HTTP di base usata con un server web come Apache, il server stesso gestisce l'autenticazione prima che venga chiamato moin. È necessario quindi inserire un nome utente e una password validi o l'accesso non viene consentito.

Il sistema di autenticazione HTTP di moin controlla solamente se l'autenticazione è avvenuta e consente l'accesso se è trovato un utente valido con quel nome utente.

Sfortunatamente è un po' più complicato di quanto sembri:

Per i server Twisted l'autenticazione utilizza il nome utente e la password archiviati nel profilo utente di moin e consente agli utenti di modificarli entrambi.
Per NTLM e Negotiate, suddivide tutto quello che si trova prima dell'ultimo backslash (\) (tipicamente "Dominio\nomeutente") e utilizza anche title() per normalizzare "username" in "Username".
Per informazioni specifiche riguardo Win32, consultare HelpOnInstalling/ApacheOnWin32withDomainAuthentication

Autenticazione client certificato SSL

Per attivare l'autenticazione client attraverso un certificato SSL è necessario aggiungere quanto segue al file wikiconfig.py:

   1     from MoinMoin.auth.sslclientcert import SSLClientCertAuth
   2     auth = [SSLClientCertAuth()]

L'autenticazione client SSL deve essere utilizzata con un server web come Apache in grado di gestire SSL e presentare solo alcune variabili a Moin.

Il sistema di autenticazione SSLClientCertAuth dispone di alcuni parametri che vanno passati al costruttore:

Parametro	Valore predefinito	Significato
`authorities`	`None`	Un elenco di autorità accettate oppure `None` per accettarle tutte
`email_key`	`True`	Indica se l'email nel certificato deve essere usata per trovare l'utente
`name_key`	`True`	Indica se il nome nel certificato deve essere usato per trovare l'utente
`use_email`	`False`	Se impostato a `True`, l'email dell'account non può essere modificato e rimane quello del certificato
`use_name`	`False`	Se impostato a `True`, il nome dell'account non può essere modificato e rimane quello del certificato
`autocreate`	`False`	Se impostato a `True`, l'utente viene creato automaticamente

Per esempio, per accettare solo i certificati verificati da Apache e firmati da un'autorità specifica, usare:

   1     from MoinMoin.auth.sslclientcert import SSLClientCertAuth
   2     auth = [SSLClientCertAuth(authorities=['my.authority.tld'])]

PHP Session

Per attivare l'integrazione Single-Sign-On con le applicazioni PHP, utilizzare questo modulo. Legge i file di sessione PHP e si integra direttamente con i sistemi di autenticazione esistenti di PHP.

Per usare questo modulo, aggiungere quanto segue nel file di configurazione:

   1     from MoinMoin.auth.php_session import PHPSessionAuth
   2     auth = [PHPSessionAuth()]

PHPSessionAuth ha i seguenti parametri:

   1     PHPSessionAuth(apps=['egw'], s_path="/tmp", s_prefix="sess_")

apps è un elenco di applicazioni abilitate
s_path è il percorso dei file di sessione PHP
s_prefix è il prefisso dei file di sessione PHP

L'unica applicazione PHP supportata è eGroupware 1.2, ma dovrebbe essere abbastanza semplice aggiungere qualche riga di codice che recupera le informazioni necessarie dalla sessione PHP. Nel caso lo aveste fatto, segnalatecelo e inviateci anche una patch.

OpenID (con BotBouncer)

Il plug-in di autenticazione OpenID consente agli utenti di iscriversi utilizzando il proprio OpenID e collegare tale OpenID a un nuovo o esistente account di Moin. Affinché gli utenti possano autenticarsi con OpenID, aggiungere il plug-in all'elenco auth o per richiedere la verifica OpenID con http://botbouncer.com usare:

   1     from MoinMoin.auth.openidrp import OpenIDAuth
   2     from MoinMoin.auth.botbouncer import BotBouncer
   3     auth = [OpenIDAuth(), BotBouncer("la-tua-chiave-API-botbouncer")]

L'autenticazione OpenID richiede le sessioni anonime: impostare anonymous_session_lifetime a un valore maggiore di zero. Consultare AiutoSuConfigurazione per i dettagli. Per OpenID è richiesto un tempo molto breve.

Configurazione avanzata di OpenID RP

Il codice OpenID RP può essere configurato per due casi d'uso:

È possibile forzare un fornitore di accesso OpenID specifico. Può essere fatto in due modi:
- Configurare semplicemente l'autenticatore OpenIDAuth in questo modo:
```
auth = OpenIDAuth(forced_service='http://myopenid.com/')
```
- Creare un oggetto OpenIDServiceEndpoint e usarlo per il parametro forced_service:
```
fs = OpenIDServiceEndpoint()
fs.type_uris = OPENID_2_0_TYPE
fs.server_url = 'http://localhost:8000/openidserver'
fs.claimed_id = 'http://specs.openid.net/auth/2.0/identifier_select'

auth = OpenIDAuth(forced_service=fs)
```
Nell'ultimo caso, non è necessario eseguire alcuna scoperta.
È possibile specificare le funzioni da chiamare in diversi passi del processo di autenticazione OpenID per esempio per implementare "Attribute Exchange". Al momento questo non è documentato, è necessario controllare il file MoinMoin/auth/openidrp.py.

Autenticazione via LDAP

L'autenticatore LDAP di MoinMoin abilita la funzione single-sign-on (SSO), basta che ci sia già una directory LDAP con gli utenti, password e indirizzi email. Su Linux questo può essere un server OpenLDAP, su Windows (tipicamente il controllore del dominio) è chiamato "Active Directory".

Funziona in questo modo:

L'utente inserisce il proprio nome e password attraverso l'azione di accesso di moin e fa clic sul pulsante per accedere.
In fase di accesso ldap_login.LDAPAuth controlla nome utente/password con LDAP.
- Se nome utente o password sono validi per LDAP, crea o aggiorna il profilo utente con i valori da LDAP (nome, pseudonimo, email) e crea un oggetto utente nel processo di MoinMoin, quindi passa il tutto all'autenticatore successivo.
- Se nome utente o password non sono validi per LDAP, viete e termina l'accesso (non viene controllato nessun altro autenticatore).
Se l'accesso viene eseguito con successo, moin stabilisce una sessione per quell'utente.

Installazione / Configurazione LDAP auth

È necessario installare il modulo python-ldap (e tutto quello da cui dipende, consultarne la documentazione).

È necessario anche un server LDAP o Active Directory.

Consultare wiki/config/more_samples/ldap_wikiconfig_snippet.py nell'archivio di moin per un esempio di codice da poter usare nella propria configurazione del wiki.

Consultare anche il file README presente in quella directory.

Problemi con LDAP auth?

Chi offre supporto per MoinMoin non conosce la configurazione dei server LDAP degli utenti, prima di chiedere aiuto seguire questi passi:

Configurare la registrazione di DEBUG per MoinMoin.auth.ldap_login e trovarne l'output.
Verificare le proprie impostazione e il proprio utente/password usando per esempio ldapsearch per interrogare il server LDAP.
- $/!\$ Finché non si riesce a interrogare il server LDAP con quello strumento è inutile provare con MoinMoin.
Chiedere agli amministratori del server LDAP/AD maggiore aiuto e per modificare le impostazioni.
Consultare anche MoinMoin/auth/ldap_login.py per risolvere i problemi.

$/!\$ Chiedere supporto a MoinMoin solo è stato usato ldapsearch con successo, è stata controllata approfonditamente la configurazione del wiki e ancora non funziona.

XMLRPC auth

   1 import xmlrpclib
   2 
   3 name = "TestUser"
   4 password = "secret"
   5 wikiurl = "http://localhost:8080/"
   6 
   7 homewiki = xmlrpclib.ServerProxy(wikiurl + "?action=xmlrpc2", allow_none=True)
   8 auth_token = homewiki.getAuthToken(name, password)
   9 
  10 mc = xmlrpclib.MultiCall(homewiki)
  11 mc.applyAuthToken(auth_token)
  12 # you can add more xmlrpc method calls to the multicall here,
  13 # they will run authenticated as user <name>.
  14 result = mc()

Utilizzare diversi metodi di autenticazione

Per utilizzare l'autenticazione SSL assieme a quella con nome utente/password, è necessario che il file wikiconfig.py contenga quanto segue:

   1     from MoinMoin.auth import MoinAuth
   2     from MoinMoin.auth.sslclientcert import SSLClientCertAuth
   3     auth = [SSLClientCertAuth(), MoinAuth()]

In questo caso, qualsiasi certificato client che l'utente fornisce verrà usato per consentire l'accesso, ma se non ne viene fornito uno sarà sempre possibile eseguire l'accesso con nome utente e password.

Scrivere il proprio metodo di autenticazione

Consultare il file contrib/auth_externalcookie/ e MoinMoin/auth/*.py negli archivi per degli esempi su come eseguire l'autenticazione. Inoltre, le docstring in MoinMoin/auth/__init__.py contengono una spiegazione su cosa è possibile fare e come farlo.

Gli autenticatori possono:

usare il modulo di accesso normale come interfaccia per inserire nome e password
usare l'azione normale per disconnettersi
proibire la disconnessione (come l'autenticazione SSl che controlla ogni singola richiesta)
cercare tra gli utenti esistenti un utente particolare (la corrispondenza non deve per forza essere il nome, può essere anche l'email o qualche cosa dello pseudonimo)
creare un oggetto utente e lasciargli ricordare quali attributi erano determinati dall'autenticatore (e per questo non dovrebbero essere presentate nelle preferenze utente)
aggiornare i valori nel profilo utente da dati esterni
creare automaticamente profili utente