##master-page:HelpOnAuthentication
##master-date:2008-10-12 01:38:25
#acl -All:write Default
#format wiki
#language it
= 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''' ||
 ||<|5 (> Tutte || moin via nome utente/password || `MoinMoin.auth.MoinAuth` ||
 || sessione PHP || `MoinMoin.auth.php_session.PHPSessionAuth` ||
 || moin via cookie esterno || Consultare `contrib/auth_externalcookie/` ||
 || [[http://openid.net|OpenID]] || `MoinMoin.auth.openidrp.OpenIDAuth` ||
 || verifica OpenID da http://botbouncer.com/ || `MoinMoin.auth.botbouncer.BotBouncer` ||
 ||<|2 (> Apache con CGI, modpy o Fast``Cgi || moduli di Apache: HTTP Basic, HTTP Digest, SSPI (NTLM) o LDAP || `MoinMoin.auth.http.HTTPAuth` ||
 || moin via LDAP || `MoinMoin.auth.ldap_login.LDAPAuth` ||
 || moin attraverso un wiki moin remoto || `MoinMoin.auth.interwiki` (sperimentale) || ||
 || Apache+SSL con CGI, modpy o Fast``Cgi || 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).

{{{#!python
    from MoinMoin.auth import MoinAuth
    auth = [MoinAuth()]
}}}

=== Autenticazione HTTP ===

Per attivare l'autenticazione HTTP è necessario aggiungere quanto segue a `wikiconfig.py`:
{{{#!python
    from MoinMoin.auth.http import HTTPAuth
    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`:
{{{#!python
    from MoinMoin.auth.sslclientcert import SSLClientCertAuth
    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:
{{{#!python
    from MoinMoin.auth.sslclientcert import SSLClientCertAuth
    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:
{{{#!python
    from MoinMoin.auth.php_session import PHPSessionAuth
    auth = [PHPSessionAuth()]
}}}

PHPSessionAuth ha i seguenti parametri: {{{#!python
    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:
{{{#!python
    from MoinMoin.auth.openidrp import OpenIDAuth
    from MoinMoin.auth.botbouncer import BotBouncer
    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:
 1. È 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.

 2. È 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 ===

{{{#!python
import xmlrpclib

name = "TestUser"
password = "secret"
wikiurl = "http://localhost:8080/"

homewiki = xmlrpclib.ServerProxy(wikiurl + "?action=xmlrpc2", allow_none=True)
auth_token = homewiki.getAuthToken(name, password)

mc = xmlrpclib.MultiCall(homewiki)
mc.applyAuthToken(auth_token)
# you can add more xmlrpc method calls to the multicall here,
# they will run authenticated as user <name>.
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:
{{{#!python
    from MoinMoin.auth import MoinAuth
    from MoinMoin.auth.sslclientcert import SSLClientCertAuth
    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
