Potrei sbagliarmi, ma dopo ore di ricerche su Google e ricerche, devo chiedere di nuovo alle brave persone qui su StackOverflow. Sto cercando di aggiungere un controller di accesso a un sito WebForms aspx. Ho fatto quanto segue:
- Aggiunti valori corrispondenti a WebConfig.
- Configurazione del mio database con aspnet_regsql (utilizzo del framework v4.0/Site in esecuzione 4.5 (è un problema?)
- Aggiunto CreateUserWizard e controlla se gli utenti vengono aggiunti al database. (Lavoratore)
- Controlla se l'ID/nome dell'applicazione è lo stesso assegnato agli utenti nel database.
Sono stato il primo a provare modulo di registrazione sul mio sito utilizzando default.aspx
A questo punto sono un po' perso perché non sono presenti errori e non sono sicuro di come continuare a cercare gli errori. Ho anche provato ad aggiungere un secondo sito chiamato "login.aspx" con gli stessi risultati.
La mia WebConfig
Modulo di accesso
<%@ Control Language="C#" AutoEventWireup="true" CodeBehind="ProperLogin.ascx.cs" Inherits="BlacjJack.ProperLogin" %>
CreaUserWizard
<%@ Control Language="C#" AutoEventWireup="true" CodeBehind="ProperRegister.ascx.cs" Inherits="BlacjJack.ProperRegister" %>
Cosa ho provato dopo aver ricevuto alcuni suggerimenti da voi ragazzi:
- Aggiunto un collegamento ad AnonymouseTemplate, supera il test per User.Identity.isAuthenticated e restituisce false. Anche un errore grossolano non si verifica.
- Ho installato Fiddler nello screenshot qui sotto, riceve un cookie quando invio il modulo di accesso.
Passiamo ora a descrivere il processo di autenticazione direttamente all'interno dell'ambiente ASP.NET, dove sono previste 3 tipologie di autenticazione a scelta:
*Autenticazione di Windows
* Forma
* Passaporto
Autenticazione di Windows:
Come suggerisce il nome, questo metodo si basa sull'utilizzo di account Windows. Questo metodo è appropriato se stai creando un'applicazione per una rete locale e tutti gli account e i gruppi validi sono archiviati in un dominio predefinito. Tuttavia, è necessario prestare molta attenzione quando si assegnano i diritti di accesso agli utenti, poiché si assegnano anche i diritti per lavorare in Windows. Per configurare ASP.NET per funzionare in modalità autenticazione Windows, è necessario modificare il file di configurazione del progetto Web Web.config o, se necessario, il file di configurazione dell'intero server, situato in WINDOWS_FOLDERMicrosoft.NET
Versione Framework.NETCONFIGMachine.config. Nel nostro esempio, lavoreremo esclusivamente con il file di progetto - Web.config, in cui è necessario trovare la sezione di autenticazione e impostare il suo attributo mode su Windows:
Ora puoi procedere direttamente alla programmazione e all'implementazione dell'autenticazione basata su Windows. Per aiutarti, la classe WindowsIdentity è progettata specificamente per funzionare con l'autenticazione di Windows. In generale, per l'autenticazione basata su Windows, esistono due classi principali fornite da .NET Framework:
* GenericIdentity – implementa solo l'interfaccia IIdentity e non fa riferimento ad alcun tipo di autenticazione specifico
* WindowsIdentity – è anch'essa un'implementazione dell'interfaccia IIdentity, ma include anche metodi specifici solo per l'autenticazione basata su Windows
Il nome utente e il nome del gruppo vengono archiviati nell'oggetto WindowsIdentity nel formato seguente: DOMAINUserName e DOMAINGroup, rispettivamente. Le uniche eccezioni sono i gruppi predefiniti, ad esempio il gruppo Administrators a cui puoi accedere utilizzando la stringa di connessione tramite WindowsIdentity: BUILTINAdministrators; In alternativa è possibile specificare un gruppo predefinito dall'enumerazione System.Security.Principal.WindowsBuiltInRole.
Dalla fig. 1 mostra che l'oggetto WindowsIdentity consente di ottenere il nome utente; determinare il tipo di autenticazione; determinare se l'autenticazione è stata eseguita in modo anonimo; Puoi anche scoprire se l'utente ha superato l'autenticazione o meno, se è un ospite o un utente di sistema.
Riso. 1 – Oggetto WindowsIdentity
Perché nelle applicazioni ASP.NET, per accedere all'oggetto WindowsIdentity, dovrai costruire la seguente catena:
HttpContext.Current.User.Identity, puoi anche determinare a quale ruolo appartiene l'utente corrente. Ciò è possibile grazie al fatto che la proprietà User in questa catena implementa l'interfaccia Iprincipal, che consente di determinare se un utente appartiene a un ruolo specifico chiamando la funzione IsInRole, che ha la seguente sintassi:
Funzione pubblica sovrascrivibile IsInRole(ByVal ruolo As String) Come membro booleano di: System.Security.Principal.Iprincipal
Ma allontaniamoci per un momento dalla pura teoria e proviamo a realizzare un esempio pratico. A tale scopo, creare un nuovo progetto di applicazione Web ASP.NET e immettere il codice seguente:
Aspx predefinito:
<%@ Page Language="vb" AutoEventWireup="false" Codebehind="default.aspx.vb" Inherits="AuthSample.WebForm1"%>
Predefinito.aspx.vb:
La classe pubblica WebForm1 eredita System.Web.UI.Page #Region " Codice generato da Web Form Designer " 'Questa chiamata è richiesta da Web Form Designer. "Non cancellarlo né spostarlo." Private designerPlaceholderDeclaration As System.Object Private Sub Page_Init(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Init 'CODEGEN: Questa chiamata al metodo è richiesta dal Web Form Designer 'Non modificarlo utilizzando l'editor di codice . InitializeComponent() End Sub #End Region Private Sub Page_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load Dim s As String s = “ Nome: “ & HttpContext.Current.User.Identity.Name & “ Tipo di autenticazione: “ & HttpContext.Current.User.Identity.AuthenticationType.ToString & “È autenticato:
È amministratore:
“ & HttpContext.Current.User.IsInRole(“Amministratore”).ToString & “
" Classe Response.Write(s) End Sub End
Se è stata selezionata la modalità di autenticazione di Windows e le impostazioni IIS non hanno causato conflitti, riceverai le informazioni appropriate sul tuo utente attuale. Se i campi nome utente e tipo di autenticazione sono vuoti, devi solo configurare IIS, per fare ciò segui questi passaggi:
1. Apri IIS e trova la directory virtuale con questa applicazione
Ciò conclude la nostra discussione sull'autenticazione basata su Windows e passa all'autenticazione del modulo.
Autenticazione del modulo:
L'autenticazione tramite modulo, o autenticazione basata su cookie come viene anche chiamata, presenta numerosi vantaggi rispetto all'autenticazione di Windows.
* Innanzitutto hai la possibilità di personalizzare l'aspetto del modulo di registrazione secondo il tuo gusto e colore oppure secondo il gusto e il colore dell'utente invece dello stesso tipo di finestra di registrazione di Windows.
* In secondo luogo, hai il controllo completo sulle informazioni che inserisci
* Le informazioni dell'utente ora possono essere archiviate non solo in SAM o Active Directory, ma anche in qualsiasi altro archivio, in particolare: un database, una directory LDAP, file XML o un file di testo semplice.
* Non è necessario collegare la policy di sicurezza del server alla policy dell'applicazione Web poiché, come menzionato in precedenza, tutte le informazioni dell'utente possono essere inserite in un archivio dati separato senza alcuna sovrapposizione con gli account del sistema operativo.
Ma nonostante l'abbondanza di opzioni di autenticazione basate su moduli, esiste una limitazione significativa: l'utente deve consentire l'uso dei cookie. Se non è presente, l'autenticazione del modulo tramite gli strumenti ASP.NET non funzionerà. Prestare attenzione alla dicitura “...utilizzando gli strumenti ASP.NET...”. Ciò significa che il meccanismo che libera lo sviluppatore dalle operazioni di routine di infiniti controlli non funzionerà, in altre parole, tutte le richieste ricevute da un utente che non ha ancora superato l'autenticazione vengono reindirizzate alla pagina di registrazione, dove inserisce le informazioni necessarie ( solitamente un nome utente e una password). Le informazioni ricevute vengono trasferite nell'ambiente ASP.NET, dove vengono verificate. In caso di esito positivo, all'utente viene inviato un cookie che contiene un ticket di autorizzazione, nome utente e chiave per la successiva ricezione dell'identificatore. Di conseguenza, tutte le successive richieste del browser conterranno informazioni sull'autorizzazione nelle intestazioni, che verranno inviate all'ambiente ASP.NET per la verifica. Pertanto, se l'utente non supporta i cookie, tutti i controlli se ha superato l'autenticazione dovranno essere eseguiti manualmente, ad esempio, nelle versioni precedenti di ASP, ciò veniva fatto utilizzando un oggetto Session, approssimativamente nella seguente forma:
Se non è Session("Registrato") = "1" Allora Response.Redirect("login.asp") Termina se
Per utilizzare l'autenticazione tramite modulo, è necessario prima configurare la configurazione del progetto Web. Per fare ciò, modificare il contenuto del tag
Diamo uno sguardo più da vicino al codice sopra. Attributo della modalità tag
* nome – nome del file cookie in cui verranno inseriti i dati relativi all'avvenuta autenticazione
* loginUrl – definisce l'indirizzo della pagina a cui l'utente verrà reindirizzato per registrarsi
* protezione – accetta i valori All|None|Encryption|Validation e determina la modalità di protezione dei dati nei cookie. Dai valori accettabili è chiaro che non si può fare nulla con i dati ricevuti e accettarli così come sono; puoi confrontarli; può essere crittografato; ed è anche possibile combinare la verifica con la crittografia: questo valore viene utilizzato per impostazione predefinita.
* timeout – definisce il periodo di tempo in secondi durante il quale il cookie sarà disponibile
* path – questo attributo specifica il percorso completo del cookie. Per impostazione predefinita, contiene una barra (/), che espande tutti i percorsi. La modifica di questa impostazione non è consigliata poiché alcuni browser fanno distinzione tra maiuscole e minuscole nel percorso, pertanto la modifica di questa impostazione potrebbe impedire ad alcuni utenti di autenticarsi.
* requireSSL – questo attributo assume il valore True o False (per default) e imposta la necessità di utilizzare il protocollo secure sockets (SSL – Secured Sockets Layer)
* slideExpiration: specifica se il cookie e le credenziali devono essere rigenerati allo scadere del timeout. Accetta i valori true (predefinito) o false.
Tutti i possibili attributi della sezione moduli sono stati descritti sopra, ma affinché l'applicazione funzioni correttamente è sufficiente utilizzarne solo 3, come mostrato nell'elenco seguente:
Autenticazione del modulo utilizzando file XML separati:
Creiamo ora una semplice pagina di registrazione utente che controlli il nome utente e la password immessi rispetto al file XML. Per fare ciò, crea prima un file XML denominato users.xml simile al seguente:
utenti.xml:
La base utenti è pronta: ora puoi iniziare a creare un progetto di registrazione utente di prova. Tutto il codice necessario è riportato di seguito:
Aspx predefinito:
<%@ Page Language=”vb” AutoEventWireup=”false” Codebehind=”default.aspx.vb” Inherits=”FormAuth._default”%>
Predefinito.aspx.vb:
Importa System.Web.Security Classe pubblica _default Inherits System.Web.UI.Page #Region " Codice generato da Web Form Designer " 'Questa chiamata è richiesta da Web Form Designer. "Non cancellarlo né spostarlo."
<%@ Page Language=”vb” AutoEventWireup=”false” Codebehind=”login.aspx.vb” Inherits=”FormAuth.WebForm1”%>
Nome
Private designerPlaceholderDeclaration As System.Object Private Sub Page_Init(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Init 'CODEGEN: Questa chiamata al metodo è richiesta dal Web Form Designer 'Non modificarlo utilizzando l'editor di codice .
InitializeComponent() End Sub #End Region Private Sub btnLogin_Click(ByVal sender As Object, ByVal e As EventArgs) Handles btnLogin.Click Dim xd As New XmlDocument, xr As XmlNodeReader Dim sName As String, sPass As String " Open the XML file xd. Load(Server.MapPath(“users.xml”)) ' Attiva XmlNodeReader xr = Nuovo XmlNodeReader(xd.Item(“users”)) " Cerca l'utente desiderato While xr.Read If xr.Name = “nome” And xr .NodeType = XmlNodeType.Element Then sName = xr.ReadString " Se il nome utente sbagliato, vai a un altro If sName
txtName.Text Then xr.Skip() ElseIf xr.Name = “password” And xr.NodeType = XmlNodeType.Element Then If xr.ReadString() = txtPassword.Text Then " Se le password corrispondono, l'autenticazione ha avuto successo FormsAuthentication.RedirectFromLoginPage ( txtName.Text, True) Else " In caso contrario, passa a un altro utente xr.Skip() End If End If End While " Se questa riga viene eseguita, le informazioni sull'utente sono state inserite in modo errato lbl.Visible = True End Sub End Classe
Conduciamo ora un “debriefing”: il codice sopra contiene 2 pagine. Tutte le azioni iniziano nella pagina default.aspx, che controlla se l'utente corrente ha un nome:Se contesto.Current.User.Identity.Name = "" Allora Response.Redirect("login.aspx") Altrimenti Response.Write("
Ciao " & contesto.Current.User.Identity.Name & "
Se hai eseguito correttamente l'autenticazione e vedi il messaggio di saluto, chiudi la finestra del browser e prova ad avviare nuovamente la pagina default.aspx. Vedrai immediatamente un saluto per l'utente di cui hai inserito il nome l'ultima volta. Il fatto è che durante la registrazione abbiamo salvato un cookie sulla macchina del cliente. Ciò è accaduto nel momento in cui abbiamo chiamato la funzione RedirectFromLoginPage nel codice, passando al suo parametro CreatePersistentCookie il valore True:
FormsAuthentication.RedirectFromLoginPage(txtName.Text, True)
Per impedire l'invio del cookie è sufficiente chiamare questa funzione con il parametro CreatePersistentCookie impostato su False. Oppure c'è un altro modo: nella pagina default.aspx, aggiungi un gestore eventi di scarico della pagina con il seguente codice:
Private Sub Page_Unload(ByVal sender As Object, ByVal e As System.EventArgs) Gestisce MyBase.Unload FormsAuthentication.SignOut() End Sub
Di conseguenza, dopo aver scaricato la pagina principale, l'utente si registrerà per uscire.
Autenticazione del modulo utilizzando il file di configurazione:
Nell'esempio precedente abbiamo archiviato tutti i dati utente in un file XML separato, ma risulta che ASP.NET offre la possibilità di archiviare le informazioni sull'account direttamente nel file di configurazione del progetto Web. Il vantaggio di questo metodo è che richiede molto meno codice da implementare, poiché in questo caso il programmatore non ha bisogno di scansionare manualmente il file XML per trovare corrispondenze, ma chiama semplicemente una singola funzione che risolve l'intero problema. Per comprendere il principio di funzionamento di questo meccanismo, rivolgiamoci ancora una volta al file di configurazione, o meglio al tag form. Oltre agli attributi precedentemente descritti, questo tag può includere anche una sezione
Web.config:
Come si può vedere dall'elenco precedente, il tag delle credenziali contiene un singolo attributo: passwordFormat. Questo parametro determina la modalità di memorizzazione della password e assume i seguenti valori:
* Cancella: la password viene salvata senza alcuna modifica
* SHA1: la password viene sottoposta ad hashing utilizzando il metodo SHA1 (Secure Hash Algorithm versione 1)
* MD5: la password viene sottoposta ad hashing utilizzando il metodo MD5 (Message Digest versione 5)
Se si sceglie uno degli algoritmi di hashing, la password non può più essere memorizzata nella sua forma originale nel file di configurazione: deve prima essere sottoposta ad hashing e solo successivamente assegnare il risultato risultante all'attributo password. Altrimenti, quando ASP.NET esegue l'autenticazione, le password semplicemente non corrisponderanno.
Ora che disponiamo di un nuovo database di account, torniamo all'applicazione precedente e modifichiamo il codice per il gestore eventi clic sul pulsante di registrazione nella pagina login.aspx:
login.aspx.vb:
Private Sub btnLogin_Click(ByVal sender As Object, ByVal e As EventArgs) Gestisce btnLogin.Click If FormsAuthentication.Authenticate(txtName.Text, txtPassword.Text) Then " Se l'utente viene trovato nella sezione dei certificati, la registrazione è avvenuta con successo ' FormsAuthentication. RedirectFromLoginPage( txtName.Text, False) Else " Altrimenti, visualizza un messaggio di errore lbl.Visible = True End If End Sub
Confronta ora questo codice con quello utilizzato nell'esempio precedente. Come puoi vedere, è stato ridotto da molte condizioni e ricerche a una sola query che restituisce Vero o Falso.
Per ora non prenderemo in considerazione specificamente un esempio di codice che funziona con password con hash, per non affrettare le cose. Il fatto è che nella terza parte di questo articolo, che sarà dedicata alla crittografia, imparerai tutte le complessità dell'hashing e della crittografia dei dati e potrai mettere in pratica questi metodi tu stesso.
Autenticazione del modulo tramite database:
Consideriamo ora un esempio di lavoro con un altro archivio dati utente: il database MS SQL Server. La maggior parte dei siti dinamici utilizza database per archiviare il contenuto del sito. Anche le informazioni sugli utenti non fanno eccezione e potrebbero benissimo prendere il loro posto nel pool di dati generale. Per vedere con i nostri occhi come avviene tutto ciò, creiamo un'applicazione di prova, che sarà basata ancora una volta sulla pagina di registrazione che già conosciamo, utilizzata negli esempi precedenti. Prima di tutto è necessario preparare il database; per fare ciò aprire l'utility SQL Query Analyser ed eseguire al suo interno il seguente codice, scritto in tSQL:
FormAuthUsers.sql:
Crea il database 'FormAuthUsers' e aggiungi la tabella 'Users' CREATE DATABASE FormAuthUsers GO USE FormAuthUsers GO CREATE TABLE ( IDENTITY (1, 1) NOT NULL, (50), (50), CONSTRAINT PRIMARY KEY CLUSTERED () ON ) ON GO -- Compila la tabella 'Utenti' INSERT INTO Utenti (Nome Utente, Password) VALUES('John', 'uno') GO INSERT INTO Utenti (Nome Utente, Password) VALUES('Mike', 'due') GO INSERT INTO Utenti (Nome Utente, Password) ) VALUES('Bill', 'tre') GO --Crea procedura 'FindUser' CREATE PROCEDURE FindUser @Name nvarchar(50), @Password nvarchar(50) AS SELECT COUNT(ID) FROM Utenti WHERE UserName = @Name AND Password = @Password VAI
L'esecuzione di questo codice dovrebbe creare un database nel tuo SQL Server denominato "FormAuthUsers" in cui puoi trovare una tabella Users con tre record e una procedura memorizzata FindUser. Questa procedura restituisce il numero di utenti che soddisfano la richiesta, formato dai parametri passati a questa procedura.
Ora che abbiamo il database pronto, possiamo iniziare a creare la pagina che funzionerà con esso. A tale scopo, riprendere gli esempi precedenti e sostituire il gestore dell'evento clic sul pulsante nella pagina login.aspx:
login.aspx.vb:
Importa System.Data.SqlClient Importa System.Web.Security Classe pubblica WebForm1 Eredita System.Web.UI.Page protetto WithEvents txtName come System.Web.UI.WebControls.TextBox protetto WithEvents txtPassword come System.Web.UI.WebControls.TextBox protetto WithEvents lbl As System.Web.UI.WebControls.Label Protected WithEvents btnLogin As System.Web.UI.WebControls.Button #Region “ Codice generato da Progettazione Web Form “ 'Questa chiamata è richiesta da Progettazione Web Form.
"Non cancellarlo né spostarlo."
Private designerPlaceholderDeclaration As System.Object Private Sub Page_Init(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Init 'CODEGEN: Questa chiamata al metodo è richiesta dal Web Form Designer 'Non modificarlo utilizzando l'editor di codice .
InitializeComponent() End Sub #End Region Private Sub btnLogin_Click(ByVal sender As Object, ByVal e As EventArgs) Handles btnLogin.Click Dim cn As New SqlConnection("server=localhost;database=FormAuthUsers;uid=sa;pwd=;") Dim cm As New SqlCommand(“FindUser”, cn) Dim n As Integer " Apri la connessione Prova cn.Open() Catch ex As SqlException Response.Write(ex.Message) Exit Sub End Prova " Imposta il tipo di comando cm.CommandType = CommandType .StoredProcedure " Aggiungi parametri nome Dim prmName = New SqlParameter(“@Name”, SqlDbType.NvarChar, 50) prmName.Value = txtName.Text cm.Parameters.Add(prmName) " Aggiungi parametro password Dim prmPass = New SqlParameter( “@ Password”, SqlDbType.NvarChar, 50) prmPass.Value = txtPassword.Text cm.Parameters.Add(prmPass) " Esegue la richiesta n = cm.ExecuteScalar Se n > 0 Allora " Se è stato trovato qualcuno, la registrazione è avvenuta con successo FormsAuthentication .RedirectFromLoginPage(txtName.Text, False) Else " se non c'è nessuno, allora c'è un errore lbl.Visible = True End If cn.Close() End Sub End Class
Affinché questa pagina funzioni correttamente, assicurati che la stringa di connessione corrisponda alla tua configurazione. Scopriamo cosa sta succedendo qui. Innanzitutto viene creato un oggetto di connessione SqlConnection, passando la stringa di connessione al database come parametro:
Dim cn As New SqlConnection("server=localhost;database=FormAuthUsers;uid=sa;pwd=;")
L'oggetto SqlCommand viene quindi configurato per eseguire la procedura memorizzata e vengono preparati i parametri per eseguirla. Per queste 7 righe di codice, esiste ovviamente un'alternativa di 1 riga di codice:
cm.CommandText = "exec FindUser "" & txtName.Text & "", "" & txtPassword.Text & """
Ma, nonostante questo codice sia più breve, il tempo di esecuzione sarà più lungo. Perché? Il fatto è che con questa riga stai eseguendo una query operativa, cioè stai scrivendo direttamente un comando SQL che richiama una procedura memorizzata. Di conseguenza si trasferiscono dati aggiuntivi sulla rete sotto forma di comando “exec”, che a sua volta occupa spazio nel traffico di rete; Non appena questa richiesta raggiunge il server, verrà prima eseguito il comando “exec” e solo successivamente verrà avviata la procedura memorizzata FindUser di cui abbiamo bisogno. In alternativa, esiste un modo ancora più difficile, che consiste nell'abbandonare le procedure memorizzate e inserire tutto il codice di query necessario direttamente nell'oggetto SqlCommand, il che si traduce nell'invio di ulteriori informazioni sul traffico di rete. Sembrerebbe che si tratti di più o meno un paio di decine di byte, ma cosa succede se devi lavorare con richieste enormi, il cui codice è molto più grande di quello della nostra procedura? Pertanto, il modo migliore è utilizzare le procedure memorizzate, poiché in questo caso si ottiene una chiara separazione dei compiti, in cui la pagina client è responsabile solo dell'input-output dei dati in una forma accessibile all'utente; SQL Server esegue tutte le operazioni sui dati; e IIS funge da intermediario tra il client e il server: qui hai un'architettura a tre livelli. Non caricare le macchine client "delicate" con lavoro non necessario: è meglio affidarlo all'artiglieria pesante, ovvero al server.
Ma torniamo al nostro codice e continuiamo ad analizzarlo: dopo aver determinato il tipo di comando e preparato tutti i parametri, eseguiamo in sicurezza questo comando e notiamo che per l'esecuzione viene utilizzata la funzione ExecuteScalar. Dovrebbe essere utilizzato quando si riceve come risultato un valore scalare, cioè un numero, che è esattamente ciò che accade nella nostra procedura FindUser: restituisce il numero di record che soddisfano una determinata condizione:
Alla fine del codice, ricevuto il numero di record trovati, analizziamo semplicemente questo valore ed eseguiamo le operazioni appropriate.
Autenticazione del modulo utilizzando i servizi Web:
Diciamo che lavori per l'organizzazione XYZ. Ti è stato assegnato il compito di creare un'applicazione che gestisca le informazioni sul personale della tua organizzazione. Stai lavorando a questo progetto da 7 mesi e all'improvviso, per motivi di sicurezza, ti è stato assegnato il compito di ospitare le informazioni dell'utente su un server completamente diverso con cui sta lavorando attivamente un altro dipartimento dell'organizzazione XYZ. Non ti è stato fornito l'accesso diretto al server, quindi il tuo progetto non può accedere direttamente al database utente situato su questo server. Per risolvere questo problema, abbiamo deciso di lasciarti sviluppare un servizio Web attraverso il quale puoi controllare l'autenticazione dell'utente.
Questa storia fittizia rivela un altro modo per eseguire l'autenticazione: l'uso dei servizi Web. I servizi Web diventano particolarmente rilevanti quando tu o i tuoi clienti non avete pieno accesso al server. Inoltre, i servizi Web non sono applicabili solo alle applicazioni Web, ma possono anche essere utilizzati da prodotti software eseguiti su un'ampia varietà di piattaforme. Ciò è stato possibile grazie all'utilizzo della tecnologia SOAP (Simple Object Access Protocol), che utilizza le porte standard TCP/IP e il protocollo HTTP.
Per lavorare con un servizio Web, devi prima crearlo. Per fare ciò, avviare un nuovo progetto di tipo Servizio Web ASP.NET (Fig. 4).
Riso. 4 – Creare un servizio Web
Ora, utilizzando il codice del gestore eventi clic del pulsante Registra dell'esempio precedente, incollalo nel codice sorgente del servizio Web, modificandolo leggermente nel formato seguente:
AuthSrvc.asmx:
Importa System.Web.Services Importa System.Data.SqlClient
Autenticazione funzione pubblica (ByVal UserName As String, ByVal Password As String, ByRef ErrMessage As String) As Boolean Dim cn As New SqlConnection("server=localhost;database=FormAuthUsers;uid=sa;pwd=;") Dim cm As New SqlCommand ("FindUser", cn) Dim n As Integer " Apri la connessione Prova cn.Open() Catch ex As SqlException " Se è presente un'eccezione, passa la sua descrizione al parametro ErrMessage ErrMessage = ex.Message Exit Function End Try " Imposta il tipo di comando cm CommandType = CommandType.StoredProcedure " Aggiungi parametri nome Dim prmName = New SqlParameter("@Name", SqlDbType.NVarChar, 50) prmName.Value = UserName cm.Parameters.Add(prmName) " Aggiungi parametro password Dim. prmPass = New SqlParameter(" @Password", SqlDbType.NVarChar, 50) prmPass.Value = Password cm.Parameters.Add(prmPass) " Esegue la richiesta n = cm.ExecuteScalar " Chiude la connessione cn.Close() " Analizza il risultato Se n > 0 Allora " Se è stato trovato qualcuno, significa che la registrazione è avvenuta con successo Return True Else " se non c'è nessuno, allora c'è un errore Return False End If End Function End Class
Puoi verificare la funzionalità del servizio senza uscire dal registratore di cassa; per farlo è sufficiente eseguirlo in ambiente Visual Studio .NET. Se non ci sono stati errori nel servizio, vedrai davanti a te una schermata con 2 collegamenti ipertestuali. Uno di essi porta alla descrizione di un servizio Web utilizzando WSDL (Web Service Description Language) e l'altro (Autenticazione) consente di testare il servizio. Fare clic sul secondo collegamento ipertestuale e compilare la tabella dei parametri nella pagina visualizzata (Fig. 5). Se inserisci la stringa "John" nel campo UserName e sostituisci "one" alla password, la funzione restituirà True:
VERO
Penso che non abbia senso analizzare in dettaglio il codice di questa funzione, perché per molti aspetti è simile al suo predecessore dell'esempio precedente. Tuttavia, dovresti prestare particolare attenzione al gestore delle eccezioni. Se nell'elenco con il database veniva semplicemente visualizzato un messaggio corrispondente sullo schermo quando si verificavano eventuali eccezioni, nel servizio Web passiamo il messaggio di errore al parametro ErrMessage della funzione Authenticate, che è stato dichiarato per riferimento :.
" Apri la connessione Prova cn.Open() Catch ex As SqlException " Se c'è un'eccezione, passa la sua descrizione al parametro ErrMessage ErrMessage = ex.Message Exit Function End Try
Nelle applicazioni che utilizzeranno questo servizio, inseriremo un controllo per eventuali eccezioni e, se vengono trovate, visualizzeremo un messaggio appropriato.
Riso. 5 – Verifica della funzionalità del servizio Web
Ora creiamo un'applicazione che utilizzerà questo servizio Web, ma questa volta andremo un po' fuori tema e creeremo un'applicazione Windows tanto per cambiare:
1. Creare un nuovo progetto di tipo Applicazione Windows
2. Modificare la forma in modo che assomigli alla forma mostrata in fig. 6, oppure puoi semplicemente sostituire il codice nel costruttore dal seguente elenco.
3. Nella finestra SolutionExplorer, fare clic con il pulsante destro del mouse sulla cartella Riferimenti e selezionare Aggiungi riferimento Web… dal menu contestuale visualizzato.
4. Verrà visualizzata una finestra di dialogo per l'impostazione dei collegamenti ai servizi Web. Inserisci l'indirizzo completo del file .asmx nel campo URL ed esegui una ricerca. Di conseguenza, dovresti vedere qualcosa di simile alla Figura 7.
5. Fare clic sul pulsante Aggiungi riferimento e nel progetto verrà visualizzato un collegamento al servizio Web specificato.
6.
Riso. 6 – Esempio di applicazione di prova
Riso. 7 – Risultati della ricerca del servizio Web
Ora puoi iniziare a scrivere il codice del programma che implementa questo servizio Web. Tutto il codice necessario è riportato di seguito:
AuthSrvcRelease.vb:
Public Class Form1 Inherits System.Windows.Forms.Form #Region " Codice generato da Progettazione Windows Form " Public Sub New() MyBase.New() "Questa chiamata è richiesta da Progettazione Windows Form. InitializeComponent() "Aggiunge qualsiasi inizializzazione dopo InitializeComponent() call End Sub "Il modulo esegue l'override della disposizione per ripulire l'elenco dei componenti. Protected Overloads Overrides Sub Dispose (ByVal disponendo come booleano) Se si dispone Then If Not (components Is Nothing) Then componenti.Dispose() End If End If MyBase. Dispose(disponendo) End Sub "Richiesto da Progettazione Windows Form Componenti privati come System.ComponentModel.IContainer "NOTA: la seguente procedura è richiesta da Progettazione Windows Form "Può essere modificata utilizzando Progettazione Windows Form.
"" Then MsgBox(sErr) Exit Sub End If " - Ora passiamo al controllo principale If bln = True Then MsgBox("Hello " & txtName.Text, MsgBoxStyle.Information) Else MsgBox("Dati errati!", MsgBoxStyle .Exclamation ) End If End Sub Private Sub cmdExit_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Gestisce cmdExit.Click End End Sub End Class
In questo esempio puoi vedere un codice molto semplice, che consiste in una semplice chiamata di funzione che esegue tutte le operazioni necessarie.
Come accennato in precedenza, i servizi Web si basano sulla tecnologia SOAP e pertanto possono essere utilizzati da applicazioni eseguite su una piattaforma completamente diversa. Non andremo troppo lontano nell'abbandonare Windows, ma proveremo a richiamare lo stesso servizio Web senza utilizzare le tecnologie .NET, cioè direttamente tramite SOAP. A tale scopo, creare il seguente file di script in Visual Basic Script Edition (VBScript) ed eseguirlo:
SOAP.vbs:
Come puoi vedere, utilizzando il modello a oggetti SOAP, puoi accedere ai servizi Web utilizzando un'ampia varietà di linguaggi di programmazione (anche script!) e piattaforme.
Ma non tutto è perfetto come sembra. Sotto il bellissimo involucro dei servizi Web si nascondono delle insidie, prima fra tutte la loro stessa sicurezza. I servizi web hanno una struttura XML sicura, che può essere intercettata e i dati trasmessi possono essere facilmente compresi e recuperati. Per eliminare, o meglio ridurre la probabilità di tale fuga di informazioni, è necessario proteggere i servizi web. Esistono numerose tecnologie per questi scopi, ma solo tre sono le più comuni: regole del firewall, Secure Sockets Layer (SSL) e Virtual Private Network (VPN).
Se sai esattamente quali computer accederanno al tuo servizio Web, in questo caso l'opzione di utilizzare le regole del firewall è adatta a te, dove puoi impostare restrizioni e diritti per indirizzi IP specifici, quindi questo metodo è più applicabile per le reti locali, dove non devi preoccuparti troppo della riservatezza delle informazioni trasmesse. Uno strumento molto utile a questo scopo è Microsoft Security and Acceleration (ISA) Server. Offre regole di policy avanzate che consentono di limitare o, al contrario, aprire l'accesso alle informazioni per clienti specifici.
SSL è più adatto per le reti Internet. Quando lo si utilizza, i dati vengono crittografati e trasferiti tra il server e il client; i dati ricevuti vengono quindi autenticati, verificando così se i dati provengono dalla fonte giusta. Ciò accade con l'uso dei certificati, che devono essere conservati sia dal server che dal client, quindi da un lato l'uso dei certificati consente di assicurarsi che i dati cadano nelle mani giuste, ma dall'altro è necessario essere sicuri che il destinatario abbia il certificato appropriato. Quindi, per utilizzare SSL è necessario:
1. Ottenere i certificati: i certificati sono commerciali e di prova. La differenza tra loro è che quello commerciale sarà ufficialmente registrato a nome dell'acquirente e, di conseguenza, costerà denaro, mentre quello di prova può essere ottenuto gratuitamente, ma senza registrazione ufficiale. Il certificato può essere ottenuto al seguente indirizzo: http://www.verisign.com/. Ma indipendentemente dal tipo di certificato che ordini, dovrai comunque scaricarne 2: uno per il server e l'altro per i client (è anche chiamato Autorità di certificazione (CA)).
2. Configurare il server e installare i certificati sui browser client: successivamente, per autenticare con successo le richieste SSL, è necessario aggiungere i certificati sia sul server che sulle macchine client. Inoltre i certificati client non sono destinati al computer ma al browser, cioè se l'utente utilizza sia Internet Explorer che Netscape è consigliabile rilasciargli certificati per entrambi i browser. Tuttavia, i certificati server sono destinati anche a diversi tipi di server (su Verisign puoi trovare certificati per più di 50 tipi di server), ma l'unica differenza è che, di regola, non vengono modificati, a meno che non venga installata una nuova versione .
NOTA
Ma, nonostante la mancanza di registrazione ufficiale, il certificato di prova è legale.
La VPN è un'estensione di una rete locale basata sull'utilizzo di una rete globale, in particolare di Internet. Ad esempio, un utente che lavora su un computer remoto può connettersi a una rete locale tramite VPN mentre utilizza Internet. Con questa tecnologia, puoi inviare dati tra computer tramite una connessione sicura perché una VPN ha le stesse funzionalità di sicurezza di una rete locale. Uno degli svantaggi di una VPN è la necessità di una connessione a lungo termine per funzionare in modo efficace. Per la comunicazione, la VPN funziona con i seguenti protocolli: Microsoft Point-to-Point Tunneling Protocol (PPTP), incluso in Windows NT 4.0 e Windows 2000, o Layer Two Tunneling Protocol (L2TP), disponibile in Windows 2000.
NOTA
L'elenco dei sistemi operativi rilevanti mostra solo quelli dalle cui versioni questi protocolli sono diventati disponibili, cioè questi sistemi operativi dovrebbero includere anche versioni successive, ad esempio Windows XP, Windows 2003 Server.
I servizi Web e la loro sicurezza sono argomenti molto interessanti e rilevanti, dato che la popolarità dei servizi Web è salita alle stelle con l'avvento di .NET Framework e VS.NET. Ma non entreremo ulteriormente nei dettagli, ma torneremo al filone principale di questo articolo. Puoi facilmente padroneggiare tutte queste tecnologie da solo. Per fare questo, hai solo bisogno di un po' di voglia, pazienza e tempo libero. Posso solo darti dei segni guida che possano guidarti lungo la giusta rotta:
* http://www.microsoft.com/technet/treeview/default.asp?url=/technet/security/default.asp
*http://www.microsoft.com/isaserver
* http://support.microsoft.com/default.aspx?scid=kb;EN-US;q307267
* http://www.w3.org/TR/wsdl.html
*http://www.w3.org/TR/SOAP/
Autenticazione del passaporto:
Passport è un sistema Single Sign-On creato da Microsoft e può essere utilizzato su qualsiasi sito Web membro di questa promozione. Un vantaggio importante di questa tecnologia è che l'utente non ha bisogno di ricordare i dati di registrazione per ciascun sito separatamente, cosa che spesso accade quando l'account a cui sei abituato è già occupato su un determinato sito web. Passport ti consente di risolvere questo problema perché utilizza un database comune di utenti, quindi sui siti che supportano .NET Passport inserirai sempre gli stessi dati di registrazione: la tua e-mail e la password.
Il metodo di autenticazione basato su Passport utilizza tecnologie Web standard per facilità d'uso e privacy:
*protocollo SSL sicuro
*biscotti
* JavaScript 1.2
* Crittografia 3DES
Per realizzare tutta la potenza del tuo passaporto, devi seguire questi passaggi:
1. Scaricare .NET Passport SDK dal seguente indirizzo: http://msdn.microsoft.com/library/default.asp?url=/downloads/list/websrvpass.asp
2. Successivamente, dovresti registrare il tuo sito con il servizio .NET Passport: http://go.microsoft.com/fwlink/?LinkID=9732. Se non ti registri, le tue opzioni saranno estremamente limitate e non sarai in grado di ottenere pienamente il risultato atteso, ad esempio, per effettuare il logout (ovvero logout) dovrai chiudere tutte le finestre del browser e quindi eliminare tutti i file cookie con i dati del passaporto
Proprio come quando si utilizzano altri tipi di autenticazione, è necessario prima impostare un file di configurazione del progetto. Il seguente elenco mostra i contenuti di base della sezione di autenticazione del file di configurazione:
In questo codice impostiamo il tipo di autenticazione del passaporto, dopodiché impostiamo un unico parametro che configura l'autenticazione del passaporto: l'indirizzo della pagina a cui l'utente verrà reindirizzato se si presenta la necessità di registrarsi:
Un'altra caratteristica che accomuna tutti i tipi di autenticazione è l'interfaccia IIdendity, sulla base della quale sono state create tutte le classi di informazioni utente per i diversi tipi di autenticazione. Anche l'autenticazione Passport non fa eccezione a questo elenco e lo strumento che implementa tutte le proprietà principali è l'oggetto System.Web.Security.PassportIdentity di .NET Framework.
Per indicare un collegamento alla pagina di registrazione, è consuetudine utilizzare un logo specializzato scaricabile tramite Internet. Poiché questo logo viene in genere utilizzato con una certa frequenza, è preferibile creare un controllo separato che implementi il componente di autenticazione. Per fare ciò, attenersi alla seguente procedura:
1. Creare un nuovo progetto di tipo Applicazione Web ASP.NET in VS.NET
2. Aggiungere un controllo utente Web e denominarlo passaporto.ascx
3. Sostituisci il suo codice sorgente con quanto segue:
passaporto.ascx.vb:
Importa System.Web.Security Public Class Passport Inherits System.Web.UI.UserControl #Region " Codice generato da Progettazione Web Form " "Questa chiamata è richiesta da Progettazione Web Form.
InitializeComponent() End Sub #End Region Private Sub Page_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load Dim id As PassportIdentity " Ottieni dati sull'id utente corrente = CType(context.User.Identity , PassportIdentity) " Visualizza il pulsante di registrazione Response.Write(id.LogoTag()) End Sub End Class 1. Successivamente, modifica il nome della pagina del progetto Web in login.aspx e inserisci il seguente codice di struttura della pagina: login.aspx :
| Login | Tutte le azioni fondamentali per l'autenticazione dell'utente vengono svolte dall'oggetto PassportIdentity, ovvero dal servizio Microsoft Passport, a cui .NET Framework accede tramite l'oggetto PassportIdentity. Ecco perché non devi fare altro che coglierne i benefici, ma per sapere esattamente cosa puoi e dovresti ottenere, fai riferimento alla Tabella 1, che spiega tutti i possibili attributi che descrivono l'utente registrato. |
| Nome dell'attributo | Descrizione Accessibilità |
| Determina se le opzioni di accessibilità devono essere consentite per un dato dato | utente su tutti i siti membri di Microsoft Passport |
| BDay_precisione | Determina la precisione dell'attributo Data di nascita Data di nascita |
| Contiene la data o l'anno di nascita dell'utente, a seconda del valore | Attributo BDay_precision Città |
| GeoID che memorizza le informazioni sulla posizione | Codice paese utente ISO 3166 |
| Direttorio | Non ancora in uso |
| Nome di battesimo | Nome utente |
| Bandiere | Contiene le opzioni del profilo utente |
| Genere | Determina il sesso dell'utente |
| Lang_Preference | LCID della lingua nazionale dell'utente |
| Cognome | Cognome utente |
| ID membroAlto | PUID identificativo utente univoco di alto livello |
| ID membro basso | PUID identificativo utente univoco di basso livello |
| Nomemembro | Contiene il nome utente e il nome del dominio separati da un segno "@". |
| Soprannome | Facile da usare |
| Occupazione | Contiene alcune informazioni aggiuntive sull'utente, in in particolare, tipo di attività |
| Codice Postale | Codice postale dell'utente negli Stati Uniti o in un altro Paese |
| Email preferita | Indirizzo e-mail dell'utente |
| Versione profilo | Versione del profilo utente |
| Regione | GeoID che indica il luogo di residenza dell'utente Paese |
| Fuso orario | Determina il fuso orario in cui risiede l'utente |
| Portafoglio | Determina se l'utente archivia il passaporto in portafoglio |
Tavolo 1 – Opzioni del profilo utente
Esistono due modi per accedere a tutti questi attributi: il metodo GetProfileObject dell'oggetto PassportIdentity e tramite la proprietà Item dello stesso oggetto. Il seguente elenco, scritto in C#, mostra entrambi questi metodi in azione:
default.aspx.cs:
utilizzando System.Web.Security; ... private void Page_Load(mittente oggetto, System.EventArgs e) ( PassportIdentity id; id = (PassportIdentity)User.Identity; Response.Write(id["Nome"] + "
"); Response.Write(id.GetProfileObject("Cognome") + "
");
}
Ora torniamo al nostro progetto con il controllo Passport.ascx e terminiamo la pagina di registrazione. Per fare ciò, modificare i file login.aspx e login.aspx.vb come segue:
accesso.aspx:
<%@ Page Language="vb" AutoEventWireup="false" Codebehind="login.aspx.vb" Inherits="PassAuth.WebForm1"%> <%@ Register TagName="passport" TagPrefix="ctl" src="passport.ascx"%>
Come sapete, la maggior parte dei siti ha lo stesso tipo di layout di pagina generalmente accettato, di cui sono parte integrante l'intestazione e il piè di pagina e, forse...
Controllo dell'accesso
Il controllo Accesso semplifica la creazione di una pagina di accesso per l'autenticazione dei moduli insieme all'API di appartenenza. Fornisce un'interfaccia utente pronta all'uso che richiede il nome e la password dell'utente e offre un pulsante per l'accesso dell'utente. Dietro le quinte, incapsula la funzionalità descritta nell'articolo precedente: verifica dell'identità dell'utente tramite l'API di appartenenza e incapsula funzionalità di autenticazione dei moduli di base, come il reindirizzamento alla pagina originariamente richiesta in un'area sicura dell'applicazione dopo un'operazione riuscita. login.
Ciò significa che Login incapsula elementi come Membership.ValidateUser() o FormsAuthentication.RedirectFromLoginPage(), quindi non devi scrivere tu stesso quel codice. L'immagine seguente mostra il controllo Login in azione:
Ogni volta che l'utente fa clic sul pulsante Accedi, il controllo verifica automaticamente il nome utente e la password utilizzando la funzione Membership.ValidateUser() e quindi chiama FormsAuthenication.RedirectFromLoginPage() se la verifica ha esito positivo. Tutte le opzioni del controllo Login influiscono sull'input fornito a questi metodi. Ad esempio, se selezioni la casella di controllo Ricordami la prossima volta, passerà il valore true nel parametro createPersistentCookie del metodo RedirectFromLoginPage(). Pertanto, FormsAuthenticationModule crea un cookie persistente.
Dietro le quinte, Login è un controllo composito ASP.NET. È completamente estensibile, nel senso che consente di sovrascrivere qualsiasi stile e proprietà di layout e anche di intercettare gli eventi generati per sovrascrivere il comportamento predefinito. Se lasci il controllo così com'è e non intercetti alcun evento, utilizzerà automaticamente il provider di appartenenze configurato per l'applicazione.
La forma più semplice di un controllo Login su una pagina è simile alla seguente:
Sono disponibili diverse proprietà per modificare l'aspetto del controllo Login. Puoi applicare diverse impostazioni di stile come mostrato di seguito:
Puoi anche utilizzare le classi CSS per personalizzare l'aspetto di Login. Ogni proprietà di stile supportata dal controllo Login include una proprietà CssClass. Come con qualsiasi altro controllo ASP.NET, questa proprietà consente di specificare il nome di una classe CSS precedentemente aggiunta al sito Web. Supponiamo che al progetto sia stato aggiunto il seguente foglio di stile CSS, con il nome file MyStyles.css:
MyLoginTextBoxStyle ( cursore: puntatore; colore di sfondo: giallo; allineamento testo: centro; imbottitura: 6px; bordo: nero tratteggiato; famiglia di caratteri: Verdana; allineamento verticale: centro; ) .Login ( display: blocco in linea; ) .Titolo (imbottitura: 6px;)
Questo file di stile può essere incluso nella pagina di login per poter dare uno stile all'elemento Login:
Nella tabella seguente sono elencati gli stili supportati dal controllo Login. Ogni stile funziona allo stesso modo. Le proprietà del carattere e del colore possono essere impostate direttamente oppure puoi utilizzare la proprietà CssClass per specificare la classe CSS desiderata:
| Stile | Tutte le azioni fondamentali per l'autenticazione dell'utente vengono svolte dall'oggetto PassportIdentity, ovvero dal servizio Microsoft Passport, a cui .NET Framework accede tramite l'oggetto PassportIdentity. Ecco perché non devi fare altro che coglierne i benefici, ma per sapere esattamente cosa puoi e dovresti ottenere, fai riferimento alla Tabella 1, che spiega tutti i possibili attributi che descrivono l'utente registrato. |
|---|---|
| CheckBoxStyle | Definisce le proprietà di stile per la casella di controllo Ricordami la prossima volta. |
| FailureStyle | Definisce lo stile del testo visualizzato quando l'accesso non riesce. |
| Stile collegamento ipertestuale | Il controllo Login consente di definire diversi tipi di collegamenti ipertestuali, ad esempio alla pagina di registrazione iniziale. Questo stile specifica l'aspetto di tali collegamenti ipertestuali |
| IstruzioniTextStyle | Il controllo Login consente di specificare il testo della guida che viene visualizzato direttamente all'interno del controllo Login. Questo stile specifica l'aspetto di questo testo |
| EtichettaStyle | Definisce lo stile per le etichette Nome utente e Password. |
| StilePulsanteAccesso | Definisce lo stile del pulsante di accesso |
| TextBoxStyle | Definisce lo stile per i campi di testo Nome utente e Password. |
| TitoloTestoStile | Definisce lo stile del testo dell'intestazione per il controllo Login |
| ValidatoreTextStyle | Definisce gli stili per i controlli utilizzati per convalidare il nome e la password di un utente |
L'interfaccia utente dell'elemento Login non è solo personalizzata tramite questi stili; Altre proprietà aggiuntive sono destinate a parti specifiche del contenuto del controllo, come il pulsante Accedi, che consente anche di personalizzare la GUI.
Ad esempio, puoi scegliere il testo visualizzato sul pulsante di accesso o anche visualizzare un collegamento ipertestuale al posto di questo pulsante (come impostato per impostazione predefinita). Inoltre, puoi aggiungere più collegamenti ipertestuali al controllo Login, ad esempio un collegamento a una pagina della Guida o a una pagina di registrazione. Entrambe le pagine dovrebbero essere aperte all'accesso anonimo, poiché l'aiuto dovrebbe essere offerto anche agli utenti anonimi (ricorda che se qualcuno vede il controllo Login, allora è potenzialmente un utente anonimo). Per includere collegamenti aggiuntivi in Login, modificare la definizione mostrata in precedenza come segue:
Questo codice visualizza due collegamenti aggiuntivi, uno alla pagina della guida e uno alla pagina di registrazione iniziale, e aggiunge anche un breve testo di istruzioni sotto il titolo dell'elemento Login:
Gli stili descritti in precedenza si applicano anche a queste proprietà. La tabella seguente descrive proprietà importanti per la configurazione del controllo Login:
| Proprietà | Tutte le azioni fondamentali per l'autenticazione dell'utente vengono svolte dall'oggetto PassportIdentity, ovvero dal servizio Microsoft Passport, a cui .NET Framework accede tramite l'oggetto PassportIdentity. Ecco perché non devi fare altro che coglierne i benefici, ma per sapere esattamente cosa puoi e dovresti ottenere, fai riferimento alla Tabella 1, che spiega tutti i possibili attributi che descrivono l'utente registrato. |
|---|---|
| Testo del messaggio | |
| TitoloTesto | Testo da visualizzare nel titolo del controllo |
| TestoIstruzioni | Questa proprietà è già stata utilizzata nel frammento di codice precedente. Contiene il testo visualizzato sotto il titolo del controllo |
| Testofallimento | Testo visualizzato dal controllo Login se il tentativo di accesso fallisce |
| NomeUtenteLabelText | Testo visualizzato come etichetta prima del campo di testo del nome utente |
| PasswordLabelText | Testo visualizzato come etichetta prima del campo di testo della password dell'utente |
| Nome utente | Valore iniziale per riempire il campo di testo del nome utente |
| NomeutenteRequiredErrorMessage | Messaggio di errore visualizzato se l'utente non immette un nome |
| Messaggio di errore richiesto dalla password | Messaggio di errore visualizzato se l'utente non ha inserito una password |
| Pulsante di accesso | |
| LoginButtonText | Testo visualizzato sul pulsante di accesso |
| LoginButtonType | |
| LoginButtonImageUrl | Se il pulsante di accesso viene presentato come immagine grafica, è necessario specificare l'URL in cui si trova l'immagine |
| Pagina di accesso | |
| URL pagina di destinazione | Se il tentativo di accesso ha esito positivo, il controllo Login reindirizza l'utente a questa pagina. Per impostazione predefinita, questa proprietà è vuota. Se vuoto, utilizza il framework di autenticazione dei moduli per reindirizzare alla pagina richiesta originale o all'Url predefinito configurato in web.config per l'autenticazione dei moduli |
| Azione di fallimento | Definisce l'azione intrapresa dal controllo dopo un tentativo di accesso non riuscito. Due opzioni valide sono Aggiorna e RedirectToLoginPage. Il primo valore provoca l'aggiornamento solo della pagina corrente, mentre il secondo provoca un reindirizzamento alla pagina di accesso configurata. La seconda opzione è utile se il controllo Login viene utilizzato in un punto diverso dalla pagina di accesso |
| Visibile quando effettuato l'accesso | Se impostato su false, il controllo si nasconde automaticamente se l'utente ha già effettuato l'accesso. Se impostato su true (impostazione predefinita), l'elemento Login viene visualizzato anche se l'utente ha effettuato l'accesso |
| Impostazione di un tag "Ricordami". | |
| VisualizzaRicordami | Ti consente di mostrare o nascondere la casella di controllo Ricordami la prossima volta. Per impostazione predefinita questa proprietà è impostata su true |
| RicordamiSet | Determina il valore predefinito della casella di controllo Ricordami la prossima volta. Per impostazione predefinita, questa proprietà è impostata su false, ovvero la casella di controllo non è selezionata |
| Pagina di registrazione | |
| CreaUserUrl | Definisce un collegamento ipertestuale a una pagina del sito Web che consente di creare (registrare) un utente. Pertanto, questo viene generalmente utilizzato per consentire all'utente l'accesso alla pagina di registrazione iniziale. In genere verrà visualizzato il controllo CreateUserWizard |
| Createstoutente | |
| CreaUserIconUrl | URL dell'immagine visualizzata insieme al testo del collegamento ipertestuale CreateUserUrl |
| Pagina di aiuto | |
| HelpPaginaUrl | URL per reindirizzare l'utente alla pagina della guida |
| HelpPageText | |
| HelpPageIconUrl | L'URL dell'icona visualizzata insieme al testo del collegamento ipertestuale HelpPageUrl |
| Pagina di recupero password | |
| URL di recupero password | L'URL per reindirizzare l'utente alla pagina di recupero della password. Questa pagina viene utilizzata quando l'utente ha dimenticato la password. In genere viene visualizzato il controllo PasswordRecovery |
| TestoRecuperoPassword | |
| PasswordRecoveryIconUrl | L'URL dell'icona visualizzata con il testo del collegamento ipertestuale PasswordRecoveryUrl |
Modelli e controllo Login
Come puoi vedere, tutte queste proprietà rendono il controllo Login altamente personalizzabile. Ma come probabilmente avrai notato, è impossibile definire qualsiasi espressione per verificare la validità dell'input. Naturalmente è possibile implementare la validazione lato server all'interno delle procedure evento offerte dal controllo Login. Quando desideri aggiungere alcuni elementi al controllo composito Login, non puoi farlo tramite le proprietà presentate sopra. Ad esempio, cosa succede se hai bisogno di un secondo campo di testo per un'autenticazione forte con una seconda password o una passkey personalizzata, come fanno alcuni siti governativi?
Fortunatamente, come altri controlli come GridView, l'elemento Login supporta i modelli. I modelli consentono di personalizzare il contenuto del controllo Login senza alcuna restrizione. Puoi aggiungervi eventuali nuovi controlli. Applica un modello speciale al controllo Login utilizzando un handle Modello di layout:
Registrazione
Nome utente:
Password:
Osservando il codice sopra, sorge una domanda: se la personalizzazione di un modello implica la scrittura di così tanto codice dell'interfaccia utente (o la progettazione in un visual designer), perché non scrivere la propria pagina di accesso senza utilizzare un controllo Login?
Questa è una domanda valida. Tuttavia, come spiegato in precedenza, il frontend è solo una parte dell'elemento Login. Ad esempio, quando un utente fa clic su un pulsante di accesso, il controllo Login dispone già di tutto il codice necessario per convalidare automaticamente l'utente rispetto all'archivio appartenenze e reindirizzare l'utente alla pagina originale richiesta tramite il framework di autenticazione dei moduli. Quindi ti verrà sicuramente risparmiata la fatica di scrivere questo codice.
Con i controlli giusti e i valori ID corretti per tali controlli, non sarà necessario scrivere codice di gestione degli eventi. Il codice funziona come al solito, tranne per il fatto che definisci un insieme di controlli e il loro layout. In realtà il controllo Login richiede almeno due campi di testo con gli identificatori UserName e Password. Se questi due campi di testo mancano (o hanno valori ID diversi), Login genererà un'eccezione. Tutti gli altri controlli sono facoltativi, ma se fornisci un valore ID appropriato (come Login per un pulsante di accesso), Login gestirà automaticamente i relativi eventi e si comporterà come se fosse applicato il layout predefinito.
La tabella seguente elenca i valori degli identificatori speciali, i tipi di elementi richiesti e il flag dei requisiti:
Il controllo Login può essere qualsiasi controllo che supporti il bubbling degli eventi e una proprietà CommandName. È importante impostare la proprietà CommandName di questo elemento su Login, perché in caso contrario, il controllo Login non lo riconoscerà durante l'elaborazione dell'evento. Se non aggiungi un controllo con la proprietà CommandName impostata su Login, dovrai gestire tu stesso gli eventi e scrivere il codice appropriato per convalidare nome utente e password e reindirizzare alla pagina richiesta originale.
Puoi anche aggiungere controlli con altri identificatori che non hanno nulla a che fare con Login. Il codice mostrato sopra utilizzava gli elementi RequiredFieldValidator e RegularExpressionValidator per convalidare i campi nome utente e password.
Quando usi un LayoutTemplate, molte delle proprietà native del controllo non sono più disponibili. Quando viene applicato un modello, rimangono disponibili solo le seguenti proprietà:
-
MembershipProvider
URL pagina di destinazione
Visibile quando effettuato l'accesso
Tutte le proprietà di stile e diverse proprietà predefinite delle impostazioni del contenuto del testo dell'elemento non sono più disponibili nell'editor delle proprietà di Visual Studio perché possono essere aggiunte manualmente come controlli individuali o testo statico al modello di elemento Login. Se li aggiungi all'elemento Login in modalità modello, verranno semplicemente ignorati perché il modello sovrascrive l'interfaccia predefinita dell'elemento Login, che utilizza queste proprietà.
Programmazione del controllo di accesso
Il controllo Login supporta diversi eventi e proprietà che puoi utilizzare per personalizzarne il comportamento. Forniscono il controllo completo sulla messa a punto del controllo Login (insieme ad altri strumenti di personalizzazione come modelli e proprietà di stile). Il controllo Login supporta gli eventi elencati nella tabella seguente:
| Evento | Tutte le azioni fondamentali per l'autenticazione dell'utente vengono svolte dall'oggetto PassportIdentity, ovvero dal servizio Microsoft Passport, a cui .NET Framework accede tramite l'oggetto PassportIdentity. Ecco perché non devi fare altro che coglierne i benefici, ma per sapere esattamente cosa puoi e dovresti ottenere, fai riferimento alla Tabella 1, che spiega tutti i possibili attributi che descrivono l'utente registrato. |
|---|---|
| Accesso | Attivato appena prima che il controllo autentichi l'utente |
| Effettuato l'accesso | Attivato dopo che l'utente è stato autenticato dal controllo |
| Errore di accesso | Si attiva quando il tentativo di accesso di un utente fallisce per qualche motivo (ad esempio una password o un nome utente errati) |
| Autenticare | Attivato per autenticare un utente. Se gestisci questo evento, devi autenticare tu stesso l'utente e il controllo Login si baserà interamente sul tuo codice di autenticazione |
I primi tre eventi possono essere gestiti per eseguire alcune azioni prima che l'utente venga autenticato, dopo che l'utente è stato autenticato e se si verifica un errore durante l'autenticazione. Ad esempio, l'evento LoginError può essere utilizzato per reindirizzare automaticamente l'utente a una pagina di recupero della password dopo un certo numero di tentativi di accesso, come mostrato di seguito:
Protected void Page_Load(oggetto mittente, EventArgs e) ( if (!this.IsPostBack) ViewState["LoginErrors"] = 0; ) protetto void Login1_LoginError(oggetto mittente, EventArgs e) ( // Se lo stato LoginErrors non esiste, crea it if (ViewState["LoginErrors"] == null) ViewState["LoginErrors"] = 0; // Aumenta il contatore dei tentativi di accesso falliti int ErrorCount = (int)ViewState["LoginErrors"] + 1; "] = ErrorCount ; // Controlla il numero di tentativi falliti if ((ErrorCount > 3) && (Login1.PasswordRecoveryUrl != string.Empty)) Response.Redirect(Login1.PasswordRecoveryUrl);
Il controllo Login genera eventi nell'ordine mostrato nella figura seguente:
Come accennato in precedenza, se intercetti l'evento Authenticate, devi aggiungere il tuo codice di verifica del nome utente e della password. Proprietà Autenticare supporta un'istanza dell'elenco di parametri AuthenticateEventArgs. Questa classe di argomenti dell'evento supporta una proprietà denominata Authenticated. Se impostato su true, il controllo Login presuppone che l'autenticazione abbia avuto successo e genera l'evento LoggedIn. Se imposti questa proprietà su false, verrà visualizzato FailureText e verrà generato l'evento LoginError:
Void protetto Login1_Authenticate(mittente oggetto, AuthenticateEventArgs e) ( if (Membership.ValidateUser(Login1.UserName, Login1.Password)) ( e.Authenticated = true; ) else ( e.Authenticated = false; ) )
Come puoi vedere, c'è un accesso diretto ai valori inseriti tramite le proprietà UserName e Password, che contengono il testo inserito nei corrispondenti campi di testo. Se utilizzi i controlli modello e desideri ottenere un valore da un altro elemento oltre agli elementi UserName e Password, puoi utilizzare il metodo FindControl() per ottenere quell'elemento aggiuntivo. Questo metodo accetta l'ID dell'elemento desiderato e restituisce un'istanza di System.Web.UI.Control. L'oggetto risultante viene quindi semplicemente convertito nel tipo del controllo desiderato e viene letto il valore richiesto dal metodo di verifica dell'identità dell'utente personalizzato.
- Esercitazione
Scopo della lezione: Studia la modalità di autorizzazione tramite Cookie, l'utilizzo di attributi di accesso standard al titolare e il metodo del titolare. Utilizzo di IPrincipal. Creare il tuo modulo (IHttpModule) e il tuo IActionFilter.
Una piccola digressione: infatti, in asp.net mvc, tutti i libri di testo consigliano di utilizzare un sistema di autorizzazione già inventato chiamato AspNetMembershipProvider, è stato descritto nell'articolo http://habrahabr.ru/post/142711/ (l'accesso è ora chiuso), ma ha spiegato che questo è dal punto di vista di "premere e non capire cosa c'è dentro". Quando ho conosciuto per la prima volta asp.net mvc, questo mi ha confuso. Inoltre, in questo articolo http://habrahabr.ru/post/143024/ si dice che non è possibile utilizzare questo provider. E sono d'accordo con questo. Qui studiamo in modo abbastanza approfondito tutti i tipi di tecniche standard asp.net mvc complicate, quindi questa è una delle lezioni principali.
Biscotti
I cookie sono informazioni inviate dal server al browser, che il browser restituisce al server insieme ad ogni (quasi ogni) richiesta.Il server scrive nell'intestazione della risposta:
Set-Cookie: valore[; scade=data][; dominio=dominio][; percorso=percorso][; sicuro]
Per esempio:
HTTP/1.1 200 OK Tipo di contenuto: text/html Set-Cookie: nome=valore Set-Cookie: nome2=valore2; Scadenza=mercoledì 9 giugno 2021 10:18:14 GMT
Browser (se il cookie non è scaduto) ad ogni richiesta:
GET /spec.html HTTP/1.1 Host: www.example.org Cookie: nome=valore; nome2=valore2 Accetta: */*
Imposta il cookie (/Areas/Default/Controllers/HomeController.cs):
public ActionResult Index() ( var cookie = new HttpCookie() ( Nome ="test_cookie", Valore = DateTime.Now.ToString("dd.MM.yyyy"), Scadenza = DateTime.Now.AddMinutes(10), ); Risposta.SetCookie(cookie); ritorno View();
In Chrome controlliamo l'installazione:
Per ricevere i cookie:
var cookie = Request.Cookies["test_cookie"];
Facciamo un punto di interruzione e controlliamo:
Nota: puoi saperne di più sui cookie al seguente link:
http://www.nczonline.net/blog/2009/05/05/http-cookies-explained/
Autorizzazione
Nel nostro caso l'autorizzazione sarà basata sull'utilizzo dei cookie. Per fare ciò, studiamo le seguenti disposizioni:- FormsAuthenticationTicket– Utilizzeremo questa classe per archiviare i dati di autorizzazione in forma crittografata
- Dobbiamo implementare un'interfaccia IPrincipal e impostare su HttpContext.User per verificare i ruoli e l'interfaccia IIdentity.
- Per interfaccia IIdentità fare un'implementazione
- Uscita a BaseController alla proprietà Utente corrente valore dell'utente attualmente connesso.
Cominciamo.
Creiamo l'interfaccia IAuthentication e la sua implementazione CustomAuthentication (/Global/Auth/IAuthentication.cs):
Interfaccia pubblica IAuthentication ( ///
Accesso utente (login stringa);
public class CustomAuthentication: IAuthentication ( private static NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger(); private const string cookieName = "__AUTH_COOKIE"; public HttpContext HttpContext ( get; set; ) public IRepository Repository ( get; set; ) #region Membri IAuthentication Accesso utente pubblico(string nomeutente, stringa Password, bool isPersistent) ( Utente retUser = Repository.Login(nomeutente, Password); if (retUser != null) ( CreateCookie(nomeutente, isPersistent); ) return retUser; ) Utente pubblico Login(string userName) ( Utente retUser = Repository.Users.FirstOrDefault(p => string.Compare(p.Email, userName, true) == 0); if (retUser != null) ( CreateCookie(userName); ) return retUser; ) private void CreateCookie(string userName, bool isPersistent = false) ( var ticket = new FormsAuthenticationTicket(1, userName, DateTime.Now, DateTime.Now.Add(FormsAuthentication.Timeout), isPersistent, string.Empty, FormsAuthentication.FormsCookiePath );
// Crittografa il ticket.
var encTicket = FormsAuthentication.Encrypt(ticket);
// Crea il cookie.
Accesso utente pubblico(string email, string password) ( return Db.Users.FirstOrDefault(p => string.Compare(p.Email, email, true) == 0 && p.Password == password); )
UserProvider implementa effettivamente l'interfaccia IPrincipal (che ha il controllo dei ruoli e l'accesso a IIdentity).
Considera la classe UserProvider (/Global/Auth/UserProvider.cs):
Classe pubblica UserProvider: IPrincipal ( private UserIndentity userIdentity ( get; set; ) #region Membri IPrincipal public IIdentity Identity ( get ( return userIdentity; ) ) public bool IsInRole(string role) ( if (userIdentity.User == null) ( return false ; ) return userIdentity.User.InRoles(role); ) #endregion public UserProvider(nome stringa, repository IRepository) ( userIdentity = new UserIndentity(); userIdentity.Init(nome, repository); ) public override string ToString() ( return userIdentity.Nome)
Il nostro UserProvider sa che la sua classe IIdentity è UserIdentity , e quindi conosce la classe User, all'interno della quale implementiamo il metodo InRoles(role):
Pubblico bool InRoles(string ruoli) ( if (string.IsNullOrWhiteSpace(roles)) ( return false; ) var roleArray = roles.Split(new ( "," ), StringSplitOptions.RemoveEmptyEntries); foreach (var role in roleArray) ( var hasRole = UserRoles.Any(p => string.Compare(p.Role.Code, role, true) == 0); if (hasRole) ( return true; ) return false)
Nel metodo InRoles, ci aspettiamo che arrivi una richiesta sui ruoli consentiti alla risorsa, separati da una virgola. Cioè, ad esempio, "amministratore, moderatore, editor", se il nostro Utente ha almeno uno dei ruoli, restituiamo il valore "true" (c'è accesso). Il confronto viene eseguito in base al campo Role.Code e non a Role.Name.
Considera la classe UserIdentity (/Global/Auth/UserIdentity.cs):
public class UserIndentity: IIdentity ( public User User ( get; set; ) public string AuthenticationType ( get ( return typeof(User).ToString(); ) ) public bool IsAuthenticated ( get ( return User != null; ) ) public string Nome ( get ( if (Utente != null) ( return Utente.Email; ) //else anonimo restituisce "anonym"; ) ) public void Init(string email, repository IRepository) ( if (!string.IsNullOrEmpty(email)) ( Utente = repository.GetUser(e-mail);
Aggiungiamo un nuovo metodo GetUser(email) a IRepository. Implementazione per SqlRepository.GetUser() (LessonProject.Model:/SqlRepository/User.cs):
Utente pubblico GetUser(string email) ( return Db.Users.FirstOrDefault(p => string.Compare(p.Email, email, true) == 0); )
Quasi tutto è pronto. Visualizziamo CurrentUser in BaseController:
public IAuthentication Auth ( get; set; ) public User CurrentUser ( get ( return ((UserIndentity)Auth.CurrentUser.Identity).User; ) )
Sì, questo non è molto corretto, poiché è coinvolto un forte legame. Quindi, facciamolo, introduciamo un'altra interfaccia IUserProvider , dalla quale richiederemo che ci venga restituito l'Utente autorizzato:
interfaccia pubblica IUserProvider ( Utente Utente ( get; set; ) ) ... classe pubblica UserIndentity: IIdentity, IUserProvider ( ///
Ora proviamo a inizializzare il tutto.
Innanzitutto, aggiungiamo la nostra IAuthentication + CustomAuthentication alla registrazione Ninject (/App_Start/NinjectWebCommon.cs):
Kernel.Bind
Quindi creeremo un modulo che eseguirà un'azione di autorizzazione sull'evento AuthenticateRequest:
public class AuthHttpModule: IHttpModule ( public void Init(contesto HttpApplication) ( context.AuthenticateRequest += new EventHandler(this.Authenticate); ) private void Authenticate(Origine oggetto, EventArgs e) ( HttpApplication app = (HttpApplication)source; HttpContext contesto = app.Context; var auth = DependencyResolver.Current.GetService
auth.HttpContext = contesto;
contesto.Utente = auth.Utentecorrente;
) public void Dispose() ( ) )
- Tutto il sale è nelle righe: auth.HttpContext = context e context.User = auth.CurrentUser . Non appena il nostro modulo di autorizzazione viene a conoscenza del contesto e dei cookie in esso contenuti, ottiene immediatamente l'accesso al nome, utilizzandolo, riceve i dati dell'utente nel repository e li restituisce al BaseController. Ma non tutto in una volta, ma su richiesta.
- Colleghiamo il modulo in Web.config:
- Il piano è:
- In alto mostriamo se l'utente è autorizzato o meno. Se autorizzato, la sua email e un collegamento per disconnettersi, in caso contrario, i collegamenti per accedere e registrarsi
Creazione di un modulo di accesso
Se l'utente ha inserito correttamente i dati, lo autorizziamo e lo rimandiamo alla pagina principale
@RenderBody() HomeController.cs: public ActionResult UserLogin() ( return View(CurrentUser); )
UserLogin.cshtml (/Areas/Default/Views/Home/UserLogin.cshtml):
@model LessonProject.Model.User @if (Modello!= null) (
LoginController Controller di accesso/output (/Areas/Default/Controllers/LoginController.cs):
Classe pubblica LoginController: DefaultController ( public ActionResult Index() ( return View(new LoginView()); ) public ActionResult Index(LoginView loginView) ( if (ModelState.IsValid) ( var user = Auth.Login(loginView.Email, loginView. Password, loginView.IsPersistent); if (utente!= null) ( return RedirectToAction("Index", "Home"); ) ModelState["Password"].Errors.Add("Le password non corrispondono" ) return View( loginView ); ) public ActionResult Logout() ( Auth.LogOut(); return RedirectToAction("Indice", "Home"); ) )
LoginView.cs (/Models/ViewModels/LoginView.cs):
public class LoginView ( public string Email ( get; set; ) public string Password ( get; set; ) public bool IsPersistent ( get; set; ))
Pagina di accesso Index.cshtml (/Areas/Default/Views/Index.cshtml):
@model LessonProject.Models.ViewModels.LoginView @( ViewBag.Title = "Login"; Layout = "~/Areas/Default/Views/Shared/_Layout.cshtml"; } !}
Entrata
@using (Html.BeginForm("Index", "Login", FormMethod.Post, new ( @class = "form-horizontal" ))) ( }Corriamo e controlliamo:
Tutte le fonti si trovano in
Ultimo aggiornamento: 31/10/2015
Il rilascio di ASP.NET MVC 5 è stato contrassegnato dal rilascio di un nuovo sistema di autorizzazione e autenticazione nelle applicazioni .NET denominato ASP.NET Identity. Questo sistema sostituisce i provider di appartenenza semplice introdotti in ASP.NET MVC 4.
Facendo clic sul pulsante Modifica autenticazione possiamo modificare il tipo di autenticazione selezionando una delle seguenti:
Nessuna autenticazione: identità ASP.NET e non esiste un sistema di autenticazione integrato
Account utente individuali: il progetto include per impostazione predefinita il sistema ASP.NET Identity, che consente di autorizzare sia gli utenti all'interno dell'applicazione sia l'utilizzo di servizi esterni come Google, Twitter, ecc.
Account Organizzativi: adatti a siti e applicazioni web di singole aziende e organizzazioni
Autenticazione Windows: un sistema di autenticazione per reti intranet che utilizza account Windows
Lasciamo il valore predefinito, ovvero Account utente individuali, e creiamo un progetto.
Il progetto creato già di default dispone di tutta l'infrastruttura necessaria per l'autorizzazione: modelli, controller, visualizzazioni. Se guardiamo il nodo Riferimenti, vedremo lì una serie di librerie di chiavi, che contengono le classi necessarie per l'autorizzazione e l'autenticazione:
Si tratta di una serie di librerie OWIN che aggiungono funzionalità OWIN al progetto, oltre a tre librerie di ASP.NET Identity stessa:
Microsoft.AspNet.Identity.EntityFramework: contiene classi Entity Framework che utilizzano ASP.NET Identity e comunicano con SQL Server
Microsoft.AspNet.Identity.Core: contiene una serie di interfacce chiave ASP.NET Identity. L'implementazione di queste interfacce ti consentirà di andare oltre MS SQL Server e utilizzare altri DBMS, inclusi i sistemi NoSQL, come archiviazione degli account
Microsoft.AspNet.Identity.OWIN: porta l'autenticazione OWIN a un'applicazione ASP.NET MVC usando ASP.NET Identity
Poiché tutta l'infrastruttura è già nel progetto, avviamo il progetto e troviamo un collegamento nella pagina visualizzata nel browser Registro e fare clic su di esso. Nella pagina di registrazione che si apre, inserisci alcuni dati:
Dopo la registrazione, il login verrà visualizzato nell'angolo in alto a destra della pagina web dell'applicazione web. Completata la registrazione possiamo disconnetterci cliccando su LogOff ed effettuare nuovamente il login. Pertanto, possiamo già iniziare a utilizzare il sistema di autenticazione integrato nell'applicazione ASP.NET MVC 5. Consideriamo ora i suoi punti principali.
Innanzitutto, dove viene archiviato tutto questo? Dove vanno a finire i dati degli utenti registrati?
IN in questo caso Viene utilizzato l'approccio Code First. Il file web.config dispone già di una stringa di connessione predefinita che specifica la directory del database. Se espandiamo la cartella App_Data, possiamo vedere il database creato:
Se all'improvviso il database non è visibile nella cartella, fare clic sul pulsante Mostra tutti i file nella parte superiore della finestra Esplora soluzioni.
Possiamo aprire questo database nella finestra Esplora server e vederne il contenuto:
Di default, al momento della registrazione del primo utente, viene creato il seguente insieme di tabelle:
MigrationHistory: utilizzato da EntityFramework per le migrazioni del database
AspNetRoles: contiene le definizioni dei ruoli
AspNetUserClaims: tabella che memorizza un insieme di attestazioni. L'attestazione presenta un modello di autorizzazione diverso rispetto ai ruoli. In parole povere, un reclamo contiene alcune informazioni sull'utente, ad esempio indirizzo email, accesso, età, ecc. E queste informazioni consentono di identificare l'utente e assegnargli i diritti di accesso appropriati.
AspNetUserLogins: tabella degli accessi utente
AspNetUserRoles: tabella che imposta ruoli specifici per gli utenti
AspNetUsers: la tabella utente effettiva. Se lo apriamo, vedremo i dati dell'utente registrato
Gli oggetti chiave in AspNet Identity sono utenti e ruoli. Tutte le funzionalità per la creazione, l'eliminazione degli utenti e l'interazione con l'archivio utenti sono archiviate nella classe UserManager. Per lavorare con i ruoli e la loro gestione, AspNet Identity definisce la classe RoleManager. Le classi UserManager e RoleManager si trovano nella libreria Microsoft.AspNet.Identity.Core.
Ogni utente di un UserManager rappresenta un oggetto interfaccia IUser. E tutte le operazioni di gestione degli utenti vengono eseguite tramite l'archiviazione rappresentata dall'oggetto IUserStore.
Ogni ruolo rappresenta un'implementazione dell'interfaccia IRole e i ruoli vengono gestiti dalla classe RoleManager tramite IRoleStore.
Un'implementazione diretta delle interfacce IUser, IRole, IUserStore e IRoleStore è fornita dallo spazio dei nomi Microsoft.AspNet.Identity.EntityFramework:
La classe IdentityUser è un'implementazione dell'interfaccia IUser. E la classe dell'archivio utenti, UserStore, implementa l'interfaccia IUserStore.
Allo stesso modo, la classe IdentityRole implementa l'interfaccia IRole e la classe dell'archivio ruoli RoleStore implementa l'interfaccia IRoleStore.
E per interagire con il database, la classe di contesto IdentityDbContext è definita nello spazio dei nomi Microsoft.AspNet.Identity.EntityFramework
In un'applicazione ASP.NET MVC non lavoreremo direttamente con le classi IdentityUser e IdentityDbContext. Per impostazione predefinita, al progetto viene aggiunto un file nella cartella Modelli IdentityModels.cs, che contiene le definizioni delle classi utente e del contesto dei dati:
Classe pubblica ApplicationUser: IdentityUser ( public async Task
Nell'applicazione non lavoriamo direttamente con le classi IdentityUser e IdentityDbContext, ma piuttosto con le classi eredi.
La classe ApplicationUser eredita tutte le proprietà da IdentityUser. Inoltre aggiunge un metodo GenerateUserIdentityAsync(), che crea un oggetto ClaimsIdentity chiamando UserManager.CreateIdentityAsync. Questo oggetto contiene informazioni su questo utente.
Questa architettura consente di prendere funzionalità già pronte e, se necessario, aggiungerne di nuove, ad esempio aggiungere una nuova proprietà per l'utente o aggiungere una nuova tabella al database.
Non descriverò nel dettaglio tutte le funzionalità di AspNet Identity, che viene aggiunto al progetto di default; ne delineerò brevemente solo le funzionalità principali;
Innanzitutto, per abilitare AspNet Identity, vengono aggiunti due file al progetto nella cartella App_Start. File Startup.Auth.cs contiene la classe di avvio dell'applicazione OWIN. Poiché AspNet Identity utilizza l'infrastruttura OWIN, questa classe è una delle chiavi e necessaria per il lavoro.
File IdentityConfig.cs contiene una serie di classi ausiliarie aggiuntive: servizi per la convalida a due fattori tramite posta elettronica e telefono EmailService e SmsService , la classe gestore utenti ApplicationUserManager , che aggiunge una serie di funzioni aggiuntive a UserManager, e la classe ApplicationSignInManager, utilizzata per accedere e disconnettersi del sito.
La funzionalità principale del sistema di autenticazione e gestione degli account si trova in due controller: AccountController e ManageController
AccountController definisce le modalità di login, registrazione, verifica di un codice inviato via email o SMS, reset password, promemoria password, accesso al sito utilizzando servizi esterni. Il controller ManageController viene utilizzato per gestire l'account e offre la possibilità di modificare la password e gestire i numeri di telefono nel sistema. Per entrambi i controller, tutte le viste necessarie e i modelli di vista speciali vengono generati per impostazione predefinita.
Nonostante per impostazione predefinita ci siano già fornite funzionalità già pronte, in alcuni casi, ad esempio, per inviare SMS o e-mail, è necessaria una configurazione aggiuntiva. Vediamo ora i punti principali del sistema AspNet Identity.
