Серверные эу для работы с учетными записями пользователей. Элемент управления Login

Аутентификация с помощью форм

Аутентификация с помощью форм - это система аутентификации общего назначения, основанная на двух концепциях. Первая из них - страница входа (login page) , которая может удостоверить действительность пользователей (обычно сверяя комбинацию имени и пароля с базой данных или другим хранилищем данных). Вторая - это механизм предохранения и восстановления контекста безопасности при каждом запросе (обычно с применением cookie-набора). Таким образом, пользователю понадобится войти только один раз.

Как будет показано далее, ASP.NET включает всю необходимую инфраструктуру. Посредством аутентификации с помощью форм платформа ASP.NET создает cookie-набор безопасности для зарегистрированных пользователей, обслуживает их и автоматически поддерживает контекст безопасности для последующих запросов. Лучше всего то, что она управляет этим процессом эффективно и в высшей степени устойчиво противостоит подделкам.

Аутентификация с помощью форм основана на билетах (также называемых маркерами). Это значит, что когда пользователь регистрируется, он получает так называемый билет с базовой информацией о себе. Информация сохраняется в зашифрованном cookie-наборе, который присоединяется к ответу, так что автоматически отправляется в каждом последующем запросе.

Когда пользователь запрашивает страницу ASP.NET, которая не доступна анонимным пользователям, исполняющая среда ASP.NET проверяет, имеется ли билет аутентификации с помощью форм. Если нет, производится автоматическая переадресация на страницу входа. С этого момента начинаются ваши заботы. Вы должны создать эту страницу входа и внутри нее проверить пользовательское удостоверение. Если пользователь успешно прошел проверку, вы просто сообщаете инфраструктуре ASP.NET об успехе операции (вызвав метод класса FormsAuthentication), после чего исполняющая среда автоматически устанавливает cookie-набор аутентификации (который в действительности содержит билет) и переадресует пользователя на запрошенную им страницу. С этим запросом исполняющая среда определяет, что cookie-набор аутентификации с билетом имеется в наличии и открывает доступ к странице.

Этот процесс показан на рисунке ниже. Все, что понадобится сделать - это настроить аутентификацию с помощью форм в файле web.config, создать страницу входа и проверить внутри нее удостоверение пользователя.

Почему стоит использовать аутентификацию с помощью форм?

Аутентификация с помощью форм - привлекательный выбор для разработчиков по нескольким причинам, которые перечислены ниже:

Вы получаете полный контроль над кодом аутентификации.

Вы получаете полный контроль над внешним видом формы входа.

Она работает с любым браузером.

Она позволяет выбирать способ хранения информации о пользователях.

Все эти причины более подробно рассматриваются в последующих разделах.

Контроль над кодом аутентификации

Поскольку аутентификация с помощью форм реализована полностью внутри ASP.NET, вы получаете полный контроль над выполнением аутентификации. Вам не нужно полагаться ни на какую внешнюю систему, как это имеет место при аутентификации Windows. Поведение аутентификации с помощью форм можно настроить под свои нужды.

Контроль над внешним видом формы входа

Вы имеете ту же степень контроля над внешним видом аутентификации с помощью форм, что и над ее функциональностью. Другими словами, входную страницу входа можно оформлять как вам угодно. Однако если вы не хотите заниматься этим, можете воспользоваться высокоуровневым API-интерфейсом членства (Membership API) и элементами управления безопасностью ASP.NET. В число этих элементов управления входит готовый к использованию и в высокой степени настраиваемый элемент управления Login.

Гибкость в настройке внешнего вида при других методах аутентификации недоступна. Аутентификация Windows требует, чтобы браузер запрашивал пользовательское удостоверение.

Работа с любым браузером

Аутентификация с помощью форм использует в качестве пользовательского интерфейса стандартный HTML, так что все браузеры могут его обработать.

Для ввода и отправки пользовательского удостоверения аутентификация с помощью форм использует стандартные формы HTML. Это значит, что для шифрования и безопасной передачи этого удостоверения нужно применять SSL. В противном случае при обратной отправке данных на сервер информация передается как простой текст.

Хранение информации о пользователях

Аутентификация с помощью форм по умолчанию хранит пользователей в файле web.config, но эту информацию можно хранить где угодно. Для этого понадобится только написать код, который обращается к хранилищу данных и извлекает информацию о пользователях. (В случае применения интерфейса Membership API даже этого делать не придется). Общим примером может служить хранение информации о пользователях в базе данных.

Гибкость в хранении информации о пользователях также означает возможность контроля над созданием и администрированием пользовательских учетных записей, а также присоединения дополнительной информации к этим учетным записям, такой как персональные предпочтения по настройке внешнего вида веб-сайта. Можно также присоединить специфические бизнес-детали, такие, например, как зашифрованная информация о кредитной карте, если сайтом является онлайновый магазин.

Когда не следует применять аутентификацию с помощью форм?

До сих пор рассматривались причины, по которым аутентификация с помощью форм становится привлекательным выбором для регистрации пользователей. Однако аутентификация с помощью форм имеет и отрицательные стороны:

Вы должны самостоятельно создавать пользовательский интерфейс для регистрации пользователей. Можно либо целиком создать собственную страницу входа, либо использовать элементы управления безопасностью ASP.NET.

Вы должны поддерживать каталог удостоверений пользователей.

Вы должны предпринимать дополнительные предосторожности против вмешательства в сетевой трафик.

Более подробно об этом пойдет речь в последующих разделах. Первые два недостатка можно устранить за счет применения интерфейса Membership API, предоставляющего предварительно разработанные элементы управления и схему хранения удостоверений с готовым решением на основе SQL Server.

Создание собственного интерфейса регистрации

Как упоминалось ранее, аутентификация с помощью форм предоставляет полный контроль над интерфейсом, через который пользователи входят в ваше веб-приложение. Наряду с преимуществами, этот подход требует дополнительной работы, поскольку вы должны самостоятельно построить страницу входа. Другие варианты аутентификации предлагают готовые формы. Например, если применяется аутентификация Windows, браузер предложит стандартное диалоговое окно. В Passport-аутентификации для регистрации пользователей всегда применяется пользовательский интерфейс сайта Passport.

Создание страницы входа для аутентификации с помощью форм не требует много работы. Следует только отметить, что аутентификация с помощью форм - это только платформа для построения системы аутентификации, а не готовая к применению система.

С другой стороны, новый интерфейс Membership API включает предварительно подготовленный элемент управления Login, который может применяться либо на отдельной странице входа, либо в составе любой страницы веб-приложения. Пользовательский интерфейс является настраиваемым и при входе пользователя автоматически взаимодействует с Membership API. Элемент управления берет на себя большую часть работы по созданию настраиваемых страниц входа.

В большинстве случаев создание собственной страницы входа не требует ничего кроме добавления к решению страницы.aspx, содержащей этот элемент управления. Если поведение по умолчанию этого элемента управления устраивает (что бывает в большинстве случаев), то перехватывать какие-либо события или писать собственный код не придется.

Обслуживание информации о пользователях

Применяя аутентификацию с помощью форм, вы возлагаете на себя ответственность за сопровождение подробной информации о пользователях, имеющих доступ к вашей системе. Наиболее важные детали - это удостоверения, которые пользователи должны предъявлять для входа в систему. Потребуется не только выбрать способ хранения их, но также обеспечить безопасность хранения. К тому же придется предоставить административные инструменты определенного рода для управления данными о пользователях в хранилище.

Платформа Membership API поставляется с предварительно созданной схемой для хранения удостоверений в базе данных SQL Server. За счет использования этой готовой схемы можно сэкономить массу времени. Более того, схема является расширяемой. Однако вы отвечаете за безопасное резервное копирование хранилища удостоверений - так, чтобы его можно было восстановить в случае сбоя системы.

Все сказанное не касается большинства других типов аутентификации. При Windows-аутентификации за хранение удостоверений пользователя отвечает лежащая в основе операционная система. В Windows реализовано множество приемов для автоматического обеспечения их безопасного хранения, так что выполнять дополнительную работу не придется. При аутентификации Passport удостоверения безопасно хранятся на специальных серверах Passport.

Перехват сетевого трафика

Когда пользователь вводит информацию удостоверения при аутентификации с помощью форм, она пересылается от браузера на сервер в формате простого текста. Это значит, что любой, кто ее перехватит, сможет ее прочитать. Очевидно, что такая ситуация небезопасна.

Обычное решение этой проблемы заключается в применении SSL (как было описано в предыдущей статье). На этом этапе может возникнуть желание использовать SSL для защиты только регистрационной страницы, а не всего приложения. Аутентификацию с помощью форм можно сконфигурировать так, чтобы она шифровала и подписывала cookie-наборы, в результате существенно затрудняя злоумышленнику задачу получения информации от нее. Вдобавок cookie-наборы не должны содержать никакой важной информации, и потому они не включают пароли, введенные при аутентификации.

Но что если злоумышленник перехватит незашифрованный трафик, извлечет из него cookie-набор (который уже зашифрован) и воспользуется им в своих целях? Расшифровывать его ему не понадобится - достаточно просто снабдить им собственные пересылаемые запросы. Противостоять такой атаке повтором можно только за счет применения SSL для всего сайта.

Другие механизмы аутентификации не требуют дополнительной работы. При Windows-аутентификации можно использовать протокол, который автоматически обеспечивает безопасный процесс регистрации (однако с одним предостережением - он поддерживается не всеми браузерами и не всеми сетевыми средами). При Passport-аутентификации процесс регистрации прозрачно обрабатывается Passport-серверами, которые всегда используют SSL.

Почему бы ни реализовать cookie-аутентификацию самостоятельно?

В зависимости от конфигураций, о которых вы узнаете в последующих статьях, аутентификация с помощью форм использует cookie-наборы для выдачи билетов аутентификации клиентам и пользователям. Более общий термин для обозначения такого подхода называется cookie-аутентификацией. Аутентификация с применением cookie-наборов на первый взгляд кажется весьма простой системой. Может возникнуть вопрос: а почему бы ни реализовать ее самостоятельно, применяя cookie-наборы и переменные сеанса?

Причина - та же, по которой разработчики не реализуют другие средства ASP.NET, от состояния сеанса до платформы веб-элементов управления. Дело не только в том, что среда ASP.NET избавляет от забот, но также и в том, что она предлагает безопасную, хорошо протестированную и расширяемую реализацию. Ниже перечислены некоторые преимущества реализации аутентификации с помощью форм ASP.NET:

Cookie-наборы аутентификации являются защищенными.

Аутентификация с помощью форм - тщательно протестированная система.

Аутентификация с помощью форм интегрирована с классами безопасности.NET.

Обеспечение безопасности cookie-наборов аутентификации

Аутентификация средствами cookie-наборов выглядит простой, но если ее реализовать неправильно, получится незащищенная система. Сами по себе cookie-наборы не являются безопасным местом хранения информации, поскольку злоумышленник может легко просмотреть и отредактировать данные cookie-набора. Если аутентификация основана на незащищенных cookie-наборах, хакер может легко подвергнуть опасности систему.

По умолчанию модуль аутентификации с помощью форм шифрует аутентифицирующую информацию перед помещением ее в cookie-набор. Он также снабжает ее хеш-кодом и проверяет cookie-набор при возврате на сервер, чтобы убедиться, что он не подвергался изменениям. Комбинация этих двух процессов обеспечивает безопасность cookie-наборов и избавляет от необходимости писать собственный код защиты. Большинство примеров доморощенных cookie-аутентификаций гораздо менее безопасны.

Аутентификация с помощью форм тщательно протестирована

Аутентификация с помощью форм - неотъемлемая часть ASP.NET, и как таковая используется во множестве веб-приложений и на множестве веб-сайтов. Когда столько людей применяют одну и ту же систему, все недостатки очень быстро выявляются, публикуются и разрешаются. До тех пор, пока вы вовремя устанавливаете все заплаты, можете считать себя в безопасности. С другой стороны, если вы создаете собственную систему аутентификации на основе cookie-наборов, то лишаетесь преимуществ такого массового тестирования. И первый случай обнаружения уязвимости будет связан с взломом вашей работающей системы.

Интеграция с платформой безопасности ASP.NET

Все типы аутентификации ASP.NET являются частью общей согласованной платформы. Аутентификация с помощью форм полностью интегрирована с этой платформой безопасности. Например, она наполняет объект контекста безопасности (IPrincipal), как и должна это делать. Это позволяет легко настроить поведение аутентификации с помощью форм по своему усмотрению.

Классы аутентификации с помощью форм

Наиболее важная часть платформы аутентификации с помощью форм - FormsAuthenticationModule. Это класс HttpModule, который обнаруживает билеты аутентификации с помощью форм, присутствующие в запросе. Если такой билет недоступен, а пользователь запросил защищенный ресурс, то запрос автоматически перенаправляется на страницу входа, указанную в файле web.config, еще до того, как исполняющая среда даже просто коснется этого защищенного ресурса.

Если билет присутствует, модуль автоматически создает контекст безопасности, инициализируя свойство HttpContext.Current.User экземпляром GenericPrincipal по умолчанию, который включает экземпляр FormsIdentity с именем текущего зарегистрированного пользователя. В основном напрямую работать с этим модулем не придется. Интерфейс для взаимодействия с модулем состоит из классов, перечисленных в таблице ниже, которые определены в пространстве имен System.Web.Security:

Классы платформы аутентификации с помощью форм

Имя класса	Описание
FormsAuthentication	Основной класс для взаимодействия с инфраструктурой аутентификации с помощью форм. Он предоставляет базовую информацию о конфигурации и позволяет создавать билет, устанавливать cookie-наборы и перенаправлять со страницы входа на исходную запрошенную страницу в случае успешной проверки удостоверения пользователя
FormsAuthenticationEventArgs	FormsAuthenticationEventArgs инициирует событие Authenticate, которое можно перехватить. Соглашения о передаваемых аргументах события инкапсулируются в экземпляре этого класса. Содержит базовую информацию об аутентифицированном пользователе
FormsAuthenticationTicket	Этот класс предоставляет информацию о пользователе, которая будет зашифрована и помещена в cookie-набор аутентификации
FormsIdentity	Этот класс реализует интерфейс IIdentity и является специфичным для аутентификации с помощью форм. Ключевым дополнением класса FormsIdentity, кроме членов, необходимых для реализации интерфейса IIdentity, является свойство Ticket, представляющее билет аутентификации. Это позволяет сохранять и извлекать дополнительную информацию из билета, такую как кэшированная информация о роли для простых сценариев
FormsAuthenticationModule	Ядро инфраструктуры аутентификации с помощью форм, устанавливающее контекст безопасности и выполняющее при необходимости автоматическое перенаправление на страницу входа

Большей частью придется использовать классы FormsAuthentication и FormsIdentity, которые представляют успешно аутентифицированного пользователя приложения. Далее будет показано, как применять аутентификацию с помощью форм в разрабатываемых приложениях.

Возможно, я ошибаюсь, но после нескольких часов поиска в Интернете и поиска я снова должен попросить прекрасных людей здесь, в StackOverflow. Я пытаюсь добавить контроллер входа на сайт aspx WebForms. Я сделал следующее:

Добавлены соответствующие значения в WebConfig.
Настройка мою базу данных с aspnet_regsql (Использование рамки v4.0/Сайт работает под управлением 4.5 (Является ли это проблемой?)
Добавлен CreateUserWizard и проверяется, если пользователи добавляются в базу данных. (Рабочий)
Проверено, если идентификатор приложения/Имя такое же, как пользователи получает назначение в базе данных.

Я первый попытался иметь регистрационную форму на моем сайте, используя default.aspx в сочетании с & . Если я поставляю форма с учетными данными, которые соответствуют пользователю, зарегистрированному в Creat eUserWizard, я не получаю ошибки и перенаправляет меня. Но я все еще не вошел в систему. Если я поставлю ложные учетные данные, он дает мне «Неверную ошибку имени пользователя/пароля», поэтому он должен иметь возможность подключаться и проверять учетные данные.

Я немного потерял в этой точке, потому что ошибок не представлено, и я не уверен, как я должен продолжить поиск ошибок. Я также попытался добавить второй сайт под названием «login.aspx» с теми же результатами.

Мой WebConfig

Войти Форма

<%@ Control Language="C#" AutoEventWireup="true" CodeBehind="ProperLogin.ascx.cs" Inherits="BlacjJack.ProperLogin" %>

CreateUserWizard

<%@ Control Language="C#" AutoEventWireup="true" CodeBehind="ProperRegister.ascx.cs" Inherits="BlacjJack.ProperRegister" %>

Что TRIE d после получения несколько советов от вас, ребят:

Добавлен ярлык, в AnonymouseTemplate , она проходит тест на User.Identity.isAuthenticated , и она возвращает ложь. Даже грубая ошибка не возникает.
Я установил скрипач на скриншот ниже, он получает файл cookie, когда я отправляю форму для входа.

Tutorial

Цель урока : Изучить способ авторизации через Cookie, использование стандартных атрибутов доступа к контроллеру и методу контроллера. Использование IPrincipal. Создание собственного модуля (IHttpModule) и собственного фильтра IActionFilter.

Небольшое отступление: На самом деле в asp.net mvc все учебники рекомендуют пользоваться уже придуманной системой авторизации, которая называется AspNetMembershipProvider, она была описана в статье http://habrahabr.ru/post/142711/ (сейчас доступ уже закрыт), но обьяснено это с точки зрения «нажимай и не понимай, что там внутри». При первом знакомстве с asp.net mvc меня это смутило. Далее, в этой статье http://habrahabr.ru/post/143024/ - сказано, что пользоваться этим провайдером – нельзя. И я согласен с этим. Здесь же, мы достаточно глубоко изучаем всякие хитрые asp.net mvc стандартные приемы, так что это один из основных уроков.

Кукисы

Кукисы – это часть информации, отсылаемая сервером браузеру, которую браузер возвращает обратно серверу вместе с каждым (почти каждым) запросом.

Сервер в заголовок ответа пишет:
Set-Cookie: value[; expires=date][; domain=domain][; path=path][; secure]
Например:

HTTP/1.1 200 OK Content-type: text/html Set-Cookie: name=value Set-Cookie: name2=value2; Expires=Wed, 09-Jun-2021 10:18:14 GMT
Браузер (если не истекло время действия кукиса) при каждом запросе:
GET /spec.html HTTP/1.1 Host: www.example.org Cookie: name=value; name2=value2 Accept: */*

Устанавливаем cookie (/Areas/Default/Controllers/HomeController.cs):
public ActionResult Index() { var cookie = new HttpCookie() { Name ="test_cookie", Value = DateTime.Now.ToString("dd.MM.yyyy"), Expires = DateTime.Now.AddMinutes(10), }; Response.SetCookie(cookie); return View(); }

В Chrome проверяем установку:

Для получения кукисов:
var cookie = Request.Cookies["test_cookie"];

Делаем точку остановки и проверяем:

Примечание: подробнее можно изучить кукисы по следующей ссылке:
http://www.nczonline.net/blog/2009/05/05/http-cookies-explained/

Авторизация

В нашем случае авторизация будет основана на использовании кукисов. Для этого изучим следующие положения:

FormsAuthenticationTicket – мы воспользуемся этим классом, чтобы хранить данные авторизации в зашифрованном виде
Нужно реализовать интерфейс IPrincipal и установить в HttpContext.User для проверки ролей и IIdentity интерфейса.
Для интерфейса IIdentity сделать реализацию
Вывести в BaseController в свойство CurrentUser значение пользователя, который сейчас залогинен.

Приступим.
Создадим интерфейс IAuthentication и его реализацию CustomAuthentication (/Global/Auth/IAuthentication.cs):

Public interface IAuthentication { ///

/// Конекст (тут мы получаем доступ к запросу и кукисам) ///

HttpContext HttpContext { get; set; } User Login(string login, string password, bool isPersistent); User Login(string login); void LogOut(); IPrincipal CurrentUser { get; } }

Реализация (/Global/Auth/CustomAuthentication.cs):
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 IAuthentication Members public User Login(string userName, string Password, bool isPersistent) { User retUser = Repository.Login(userName, Password); if (retUser != null) { CreateCookie(userName, isPersistent); } return retUser; } public User Login(string userName) { User 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); // Encrypt the ticket. var encTicket = FormsAuthentication.Encrypt(ticket); // Create the cookie. var AuthCookie = new HttpCookie(cookieName) { Value = encTicket, Expires = DateTime.Now.Add(FormsAuthentication.Timeout) }; HttpContext.Response.Cookies.Set(AuthCookie); } public void LogOut() { var httpCookie = HttpContext.Response.Cookies; if (httpCookie != null) { httpCookie.Value = string.Empty; } } private IPrincipal _currentUser; public IPrincipal CurrentUser { get { if (_currentUser == null) { try { HttpCookie authCookie = HttpContext.Request.Cookies.Get(cookieName); if (authCookie != null && !string.IsNullOrEmpty(authCookie.Value)) { var ticket = FormsAuthentication.Decrypt(authCookie.Value); _currentUser = new UserProvider(ticket.Name, Repository); } else { _currentUser = new UserProvider(null, null); } } catch (Exception ex) { logger.Error("Failed authentication: " + ex.Message); _currentUser = new UserProvider(null, null); } } return _currentUser; } } #endregion }

Суть сводится к следующему, мы, при инициализации запроса, получаем доступ к HttpContext.Request.Cookies и инициализируем UserProvider:

Var ticket = FormsAuthentication.Decrypt(authCookie.Value); _currentUser = new UserProvider(ticket.Name, Repository);

Для авторизации в IRepository добавлен новый метод IRepository.Login. Реализация в SqlRepository:
public User Login(string email, string password) { return Db.Users.FirstOrDefault(p => string.Compare(p.Email, email, true) == 0 && p.Password == password); }

UserProvider, собственно, реализует интерфейс IPrincipal (в котором есть проверка ролей и доступ к IIdentity).
Рассмотрим класс UserProvider (/Global/Auth/UserProvider.cs):

Public class UserProvider: IPrincipal { private UserIndentity userIdentity { get; set; } #region IPrincipal Members 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(string name, IRepository repository) { userIdentity = new UserIndentity(); userIdentity.Init(name, repository); } public override string ToString() { return userIdentity.Name; }

Наш UserProvider знает про то, что его IIdentity классом есть UserIdentity , а поэтому знает про класс User , внутри которого мы реализуем метод InRoles(role) :

Public bool InRoles(string roles) { if (string.IsNullOrWhiteSpace(roles)) { return false; } var rolesArray = roles.Split(new { "," }, StringSplitOptions.RemoveEmptyEntries); foreach (var role in rolesArray) { var hasRole = UserRoles.Any(p => string.Compare(p.Role.Code, role, true) == 0); if (hasRole) { return true; } } return false; }

В метод InRoles мы ожидаем, что придет запрос о ролях, которые допущены к ресурсу, разделенные запятой. Т.е., например, “admin,moderator,editor”, если хотя бы одна из ролей есть у нашего User – то возвращаем зачение «истина» (доступ есть). Сравниваем по полю Role.Code, а не Role.Name.
Рассмотрим класс 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 Name { get { if (User != null) { return User.Email; } //иначе аноним return "anonym"; } } public void Init(string email, IRepository repository) { if (!string.IsNullOrEmpty(email)) { User = repository.GetUser(email); } } }
В IRepository добавляем новый метод GetUser(email) . Реализация для SqlRepository.GetUser() (LessonProject.Model:/SqlRepository/User.cs):

Public User GetUser(string email) { return Db.Users.FirstOrDefault(p => string.Compare(p.Email, email, true) == 0); }

Почти все готово. Выведем CurrentUser в BaseController:
public IAuthentication Auth { get; set; } public User CurrentUser { get { return ((UserIndentity)Auth.CurrentUser.Identity).User; } }

Да, это не очень правильно, так как здесь присутствует сильное связывание. Поэтому сделаем так, введем еще один интерфейс IUserProvider , из которого мы будем требовать вернуть нам авторизованного User:
public interface IUserProvider { User User { get; set; } } … public class UserIndentity: IIdentity, IUserProvider { ///

/// Текщий пользователь ///

public User User { get; set; } … public IAuthentication Auth { get; set; } public User CurrentUser { get { return ((IUserProvider)Auth.CurrentUser.Identity).User; } }
А теперь попробуем инициализировать это всё.
Вначале добавим наш IAuthentication + CustomAuthentication в регистрацию к Ninject (/App_Start/NinjectWebCommon.cs):

Kernel.Bind().To().InRequestScope();

Потом создадим модуль, который будет на событие AuthenticateRequest совершать действие авторизации:
public class AuthHttpModule: IHttpModule { public void Init(HttpApplication context) { context.AuthenticateRequest += new EventHandler(this.Authenticate); } private void Authenticate(Object source, EventArgs e) { HttpApplication app = (HttpApplication)source; HttpContext context = app.Context; var auth = DependencyResolver.Current.GetService(); auth.HttpContext = context; context.User = auth.CurrentUser; } public void Dispose() { } }

Вся соль в строках: auth.HttpContext = context и context.User = auth.CurrentUser . Как только наш модуль авторизации узнает о контексте и содержащихся в нем кукисах, ту же моментально получает доступ к имени, по нему он в репозитории получает данныепользователя и возвращает в BaseController. Но не сразу всё, а по требованию.
Подключаем модуль в Web.config:
…

План таков:

Наверху показываем, авторизован пользователь или нет. Если авторизован, то его email и ссылка на выход, если нет, то ссылки на вход и регистрацию
Создаем форму для входа
Если пользователь правильно ввел данные – то авторизуем его и отправляем на главную страницу
Если пользователь выходит – то убиваем его авторизацию

Поехали. Добавляем Html.Action(“UserLogin”, “Home”) – это partial view (т.е. кусок кода, который не имеет Layout) – т.е. выводится где прописан, а не в RenderBody().
_Layout.cshtml (/Areas/Default/Views/Shared/_Layout.cshtml):

@RenderBody() HomeController.cs: public ActionResult UserLogin() { return View(CurrentUser); }

UserLogin.cshtml (/Areas/Default/Views/Home/UserLogin.cshtml):

@model LessonProject.Model.User @if (Model != null) {

@Model.Email

@Html.ActionLink("Выход", "Logout", "Login")

} else {

@Html.ActionLink("Вход", "Index", "Login")

@Html.ActionLink("Регистрация", "Register", "User")

}

Контроллер входа выхода LoginController (/Areas/Default/Controllers/LoginController.cs):

Public class 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 (user != null) { return RedirectToAction("Index", "Home"); } ModelState["Password"].Errors.Add("Пароли не совпадают"); } return View(loginView); } public ActionResult Logout() { Auth.LogOut(); return RedirectToAction("Index", "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; } }

Страница для входа Index.cshtml (/Areas/Default/Views/Index.cshtml):

@model LessonProject.Models.ViewModels.LoginView @{ ViewBag.Title = "Вход"; Layout = "~/Areas/Default/Views/Shared/_Layout.cshtml"; }

Вход

@using (Html.BeginForm("Index", "Login", FormMethod.Post, new { @class = "form-horizontal" })) {

Вход

@Html.TextBox("Email", Model.Email, new { @class = "input-xlarge" })

Введите Email

@Html.ValidationMessage("Email")

Пароль

@Html.Password("Password", Model.Password, new { @class = "input-xlarge" }) @Html.ValidationMessage("Password")

}

Запускаем и проверяем:

Все исходники находятся по адресу

Последнее обновление: 31.10.2015

Релиз ASP.NET MVC 5 ознаменовался выходом новой системой авторизации и аутентификации в.NET приложениях под названием ASP.NET Identity. Эта система пришла на смену провайдерам Simple Membership, которые были введены в ASP.NET MVC 4.

Нажав на кнопку Change Authentication , мы можем изменить тип аутентификации, выбрав одно из следующих:

No Authentication : ASP.NET Identity и встроенная система аутентификации отсутствует

Individual User Accounts : проект по умолчанию включает систему ASP.NET Identity, которая позволяет авторизовать как пользователей внутри приложения, так и с помощью внешних сервисов, как google, твиттер и т.д.

Organizational Accounts : подходит для сайтов и веб-приложений отдельных компаний и организаций

Windows Authentication : система аутентификации для сетей intranet с помощью учетных записей Windows

Оставим значение по умолчанию, то есть Individual User Accounts и создадим проект.

Созданный проект уже по умолчанию имеет всю необходимую для авторизации инфраструктуру: модели, контроллеры, представления. Если мы заглянем в узел References (Библиотеки), то увидим там ряд ключевых библиотек, которые и содержит необходимые для авторизации и аутентификации классы:

Это ряд библиотек OWIN, которые добавляют функциональность OWIN в проект, а также три библиотеки собственно ASP.NET Identity:

Microsoft.AspNet.Identity.EntityFramework : содержит классы Entity Framework, применяющие ASP.NET Identity и осуществляющие связь с SQL Serveroм

Microsoft.AspNet.Identity.Core : содержит ряд ключевых интерфейсов ASP.NET Identity. Реализация этих интерфейсов позволит выйти за рамки MS SQL Server и использовать в качестве хранилища учетных записей другие СУБД, в том числе системы NoSQL

Microsoft.AspNet.Identity.OWIN : привносит в приложение ASP.NET MVC аутентификацию OWIN с помощью ASP.NET Identity

Поскольку вся инфраструктура уже имеется в проекте, запустим проект, на отобразившейся в браузере странице найдем ссылку Register и нажмем на нее. На открывшейся странице регистрации введем какие-нибудь данные:

После регистрации логин будет отображаться в правом верхнем углу веб-страницы веб-приложения. Осуществив регистрацию, мы можем разлогиниться, нажав на LogOff, и снова войти в систему. Таким образом, мы можем уже начать пользоваться встроенной системой аутентификации в приложении ASP.NET MVC 5. Теперь же рассомотрим ее основные моменты.

Во-первых, где это все хранится? Куда попадают данные зарегистрированных пользователей?

В данном случае используется подход Code First. В файле web.config уже имеется строка подключения по умолчанию, которая задает каталог базы данных. Если мы раскроем папку App_Data, то сможем увидеть созданную базу данных:

Если вдруг в папке база данных не видна, нажмем вверху окна Solution Explorer на кнопку Show All Files (Показать все файлы).

Мы можем открыть эту базу данных в окне Server Explorer и увидеть ее содержимое:

По умолчанию при регистрации первого пользователя создается следующий набор таблиц:

MigrationHistory : используется EntityFramework для миграций БД

AspNetRoles : содержит определения ролей

AspNetUserClaims : таблица, хранящая набор клеймов (claim). Claim представляет иную модель авторизации по сравнению с ролями. Грубо говоря, claim содержит некоторую информацию о пользователе, например, адрес электронной почты, логин, возраст и т.д. И эта информация позволяет идентифицировать пользователя и наделить его соответствующими правами доступа.

AspNetUserLogins : таблица логинов пользователя

AspNetUserRoles : таблица, устанавливающая для пользователей определенные роли

AspNetUsers : собственно таблица пользователей. Если мы ее откроем, то увидим данные зарегистрированного пользователя

Ключевыми объектами в AspNet Identity являются пользователи и роли . Вся функциональность по созданию, удалению пользователей, взаимодействию с хранилищем пользователей хранится в классе UserManager . Для работы с ролями и их управлением в AspNet Identity определен класс RoleManager . Классы UserManager и RoleManager находятся в библиотеке Microsoft.AspNet.Identity.Core.

Каждый пользователь для UserManager представляет объект интерфейса IUser. А все операции по управлению пользователями производятся через хранилище, представленное объектом IUserStore.

Каждая роль представляет реализацию интерфейса IRole, а управление ролями классом RoleManager происходит через хранилище IRoleStore.

Непосредственную реализацию интерфейсов IUser, IRole, IUserStore и IRoleStore предоставляет пространство имен Microsoft.AspNet.Identity.EntityFramework:

Класс IdentityUser является реализацией интерфейса IUser. А класс хранилища пользователей - UserStore реализует интерфейс IUserStore.

Подобным образом класс IdentityRole реализует интерфейс IRole, а класс хранилища ролей - RoleStore реализует интерфейс IRoleStore.

А для взаимодействия с базой данных в пространстве имен Microsoft.AspNet.Identity.EntityFramework определен класс контекста IdentityDbContext

В приложении ASP.NET MVC мы не будем работать напрямую с классами IdentityUser и IdentityDbContext. По умолчанию в проект в папку Models добавляется файл IdentityModels.cs , который содержит определения классов пользователей и контекста данных:

Public class ApplicationUser: IdentityUser { public async Task GenerateUserIdentityAsync (UserManager manager) { var userIdentity = await manager.CreateIdentityAsync(this, DefaultAuthenticationTypes.ApplicationCookie); return userIdentity; } } public class ApplicationDbContext: IdentityDbContext { public ApplicationDbContext() : base("DefaultConnection", throwIfV1Schema: false) { } public static ApplicationDbContext Create() { return new ApplicationDbContext(); } }

В приложении мы не работаем напрямую с классами IdentityUser и IdentityDbContext, а имеем дело с классами-наследниками.

Класс ApplicationUser наследует от IdentityUser все свойства. И кроме того добавляет метод GenerateUserIdentityAsync() , в котором с помощью вызова UserManager.CreateIdentityAsync создается объект ClaimsIdentity . Данный объект содержит информацию о данном пользователе.

Подобная архитектура позволяет взять уже готовый функционал и при необходимости добавить новый, например, добавить для пользователя новое свойство или добавить новую таблицу в бд.

Я не буду подробно расписывать весь функционал AspNet Identity, который по умолчанию добавляется в проект, обозначу вкратце лишь основные возможности.

Во-первых, чтобы задействовать AspNet Identity, в проект в папку App_Start добавляются два файла. Файл Startup.Auth.cs содержит класс запуска приложения OWIN. Поскольку AspNet Identity использует инфраструктуру OWIN, то данный класс является одним из ключевых и необходимых для работы.

Файл IdentityConfig.cs содержит ряд дополнительных вспомогательных классов: сервисы для двухфакторной валидации с помощью email и телефона EmailService и SmsService , класс менеджера пользователей ApplicationUserManager , добавляющий к UserManager ряд дополнительных функций, и класс ApplicationSignInManager , используемый для входа и выхода с сайта.

Базовая функциональность системы аутентификации и управления учетными записями расположена в двух контроллерах: AccountController и ManageController

В AccountController определены методы для логина, регистрации, верификации кода, отправленного по email или по смс, сброс пароля, напоминание пароля, вход на сайт с помощью внешних сервисов. Контроллер ManageController используется для управления учетной записью и предполагает возможности по смене пароля и управлению телефонными номерами в системе. Для обоих контроллеров уже по умолчанию генерируются все необходимые представления и специальные модели представлений.

Несмотря на то, что по умолчанию нам уже предоставляется готовый функционал, однако в ряде случаев, например, для отправки смс или электронной почты необходима дополнительная настройка. Теперь рассмотрим основные моменты системы AspNet Identity.

Элемент управления Login

Элемент управления Login упрощает создание страницы входа для аутентификации с помощью форм в сочетании с Membership API. Он предоставляет готовый к применению пользовательский интерфейс, запрашивающий имя и пароль пользователя и предлагающий кнопку для входа пользователя. "За кулисами" он инкапсулирует функциональность, которая была описана в предыдущей статье: проверку удостоверений пользователей через Membership API и инкапсуляцию базовой функциональности аутентификации с помощью форм, такой как перенаправление к изначально запрошенной странице в защищенной области приложения после успешного входа.

Это значит, что Login инкапсулирует такие вещи, как Membership.ValidateUser() или FormsAuthentication.RedirectFromLoginPage(), поэтому писать этот код самостоятельно не придется. На рисунке ниже показан элемент управления Login в действии:

Всякий раз, когда пользователь щелкает на кнопке Log In (Войти), элемент управления автоматически проверяет имя и пароль, применяя для этого функцию Membership.ValidateUser(), а затем вызывает FormsAuthenication.RedirectFromLoginPage(), если проверка прошла успешно. Все опции элемента управления Login влияют на ввод, доставляемый им в эти метода. Например, если отметить флажок Remember me next time (Запомнить учетные данные), он передаст значение true в параметре createPersistentCookie метода RedirectFromLoginPage(). Поэтому FormsAuthenticationModule создает постоянный cookie-набор.

"За кулисами" Login представляет собой составной элемент управления ASP.NET. Он полностью расширяем - в том смысле, что позволяет переопределять любые стили компоновки и свойства, а также перехватывать генерируемые события для переопределения его поведения по умолчанию. Если оставить элемент управления без изменений, как он есть, и не перехватывать никаких событий, то он автоматически будет использовать поставщик членства, сконфигурированный для приложения.

Простейшая форма элемента управления Login на странице выглядит следующим образом:

Для изменения внешнего вида элемента управления Login предназначено несколько свойств. Можно применять разные установки стилей, как показано ниже:

Кроме того, для настройки внешнего вида Login можно использовать классы CSS. Каждое свойство стиля, поддерживаемое элементом управления Login, включает свойство CssClass. Как и в случае любого другого элемента управления ASP.NET, это свойство позволяет указать имя класса CSS, который был добавлен ранее к веб-сайту. Предположим, что в проект добавлена следующая таблица стилей CSS с именем файла MyStyles.css:

MyLoginTextBoxStyle { cursor: pointer; background-color: yellow; text-align: center; padding:6px; border: dotted black; font-family: Verdana; vertical-align: middle; } .Login { display:inline-block; } .Title { padding: 6px; }

Этот файл стиля можно включить в страницу входа, чтобы иметь возможность использовать стиль для элемента Login:

В таблице ниже перечислены стили, поддерживаемые элементом управления Login. Каждый стиль работает одним и тем же способом. Свойства шрифта и цвета можно устанавливать непосредственно или применять свойство CssClass для указания нужного класса CSS:

Стили, поддерживаемые элементом управления Login

Стиль	Описание
CheckBoxStyle	Определяет свойства стиля для флажка Remember me next time (Запомнить учетные данные)
FailureStyle	Определяет стиль для текста, который отображается а случае неудачного входа
HyperLinkStyle	Элемент управления Login позволяет определить несколько типов гиперссылок, например, на страницу начальной регистрации. Этот стиль задает внешний вид таких гиперссылок
InstructionTextStyle	Элемент управления Login позволяет указать текст справки, отображаемый непосредственно в нем самом. Этот стиль задает внешний вид этого текста
LabelStyle	Определяет стиль для меток User Name (Имя пользователя) и Password (Пароль)
LoginButtonStyle	Определяет стиль кнопки входа
TextBoxStyle	Определяет стиль для текстовых полей User Name (Имя пользователя) и Password (Пароль)
TitleTextStyle	Определяет стиль текста заголовка для элемента управления Login
ValidatorTextStyle	Определяет стили для элементов управления, используемых для проверки имени и пароля пользователя

Пользовательский интерфейс элемента Login настраивается не только через эти стили; другие дополнительные свойства предназначены для определенных частей содержимого элемента управления, таких как кнопка Log In, которые также позволяют настроить графический интерфейс.

Например, можно выбрать текст, отображаемый на кнопке входа, либо вообще отображать вместо этой кнопки (как установлено по умолчанию) гиперссылку. Более того, к элементу управления Login можно добавить несколько гиперссылок, таких как ссылка на страницу справки или на страницу регистрации. Обе страницы должны быть открыты для анонимного доступа, поскольку справка должна предлагаться также анонимным пользователям (вспомните, что если кто-то видит элемент управления Login, то он - потенциально анонимный пользователь). Чтобы включить дополнительные ссылки в Login, модифицируйте ранее показанное определение следующим образом:

...

Этот код приводит к отображению двух дополнительных ссылок - на страницу справки и на страницу первоначальной регистрации, а также добавляет текст краткой инструкции под заголовком элемента Login:

Стили, описанные ранее, применимы и к этим свойствам. В таблице ниже описаны важные свойства для настройки элемента управления Login:

Важные свойства для настройки элемента управления Login

Свойство	Описание
Текст сообщений
TitleText	Текст, отображаемый в заголовке элемента управления
InstructionText	Это свойство уже использовалось в предыдущем фрагменте кода. Содержит текст, отображаемый ниже заголовка элемента управления
FailureText	Текст, отображаемый элементом управления Login, если попытка входа не удалась
UserNameLabelText	Текст, отображаемый в виде метки перед текстовым полем имени пользователя
PasswordLabelText	Текст, отображаемый в виде метки перед текстовым полем пароля пользователя
UserName	Начальное значение, заполняющее текстовое поле имени пользователя
UsernameRequiredErrorMessage	Сообщение об ошибке, отображаемое, если пользователь не ввел имя
PasswordRequiredErrorMessage	Сообщение об ошибке, отображаемое, если пользователь не ввел пароль
Кнопка входа
LoginButtonText	Текст, отображаемый на кнопке входа
LoginButtonType
LoginButtonImageUrl	Если кнопка входа представлена как графическое изображение, необходимо указать URL, где находится это изображение
Страница входа
DestinationPageUrl	Если попытка входа была успешной, элемент управления Login перенаправляет пользователя на эту страницу. По умолчанию это свойство пусто. При пустом значении используется инфраструктура аутентификации с помощью форм для перенаправления либо на исходную запрошенную страницу, либо на defaultUrl, сконфигурированный в web.config для аутентификации с помощью форм
FailureAction	Определяет действие, которое элемент управления выполняет после неудачной попытки входа. Два допустимых варианта - Refresh и RedirectToLoginPage. Первое значение приводит к обновлению только текущей страницы, а второе - к перенаправлению на сконфигурированную страницу входа. Второй вариант полезен, если элемент управления Login используется где-то в другом месте, а не на странице входа
VisibleWhenLoggedIn	Если установлено в false, то элемент управления автоматически скрывает себя, если пользователь уже вошел. Если установлено в true (по умолчанию), то элемент Login отображается, даже если пользователь совершил вход
Настройка метки "Запомнить меня"
DisplayRememberMe	Позволяет показывать или скрывать флажок Remember me next time (Запомнить меня). По умолчанию это свойство установлено в true
RememberMeSet	Определяет значение по умолчанию флажка Remember me next time. По умолчанию это свойство установлено в false, т.е. флажок не отмечен
Страница регистрации
CreateUserUrl	Определяет гиперссылку на страницу веб-сайта, которая позволяет создавать (регистрировать) пользователя. Таким образом, это обычно используется для открытия пользователю доступа к странице первичной регистрации. Обычно при этом отображается элемент управления CreateUserWizard
CreateUserText
CreateUserIconUrl	URL-адрес графического изображения, выводимого вместе с текстом гиперссылки CreateUserUrl
Страница помощи
HelpPageUrl	URL-адрес для перенаправления пользователя на страницу справки
HelpPageText
HelpPageIconUrl	URL-адрес значка, отображаемого вместе с текстом гиперссылки HelpPageUrl
Страница восстановления пароля
PasswordRecoveryUrl	URL-адрес для перенаправления пользователя на страницу восстановления пароля. Эта страница применяется, когда пользователь забыл пароль. Обычно она отображает элемент управления PasswordRecovery
PasswordRecoveryText
PasswordRecoveryIconUrl	URL-адрес значка, отображаемого вместе с текстом гиперссылки PasswordRecoveryUrl

Шаблоны и элемент управления Login

Как видите, благодаря всем этим свойствам элемент управления Login настраивается очень гибко. Но как вы, скорее всего, обратили внимание, определить какое-нибудь выражение для проверки достоверности ввода невозможно. Конечно, можно реализовать проверку достоверности на стороне сервера внутри процедур событий, предлагаемых элементом управления Login. Когда требуется добавить какие-то элементы к составному элементу управления Login, это не получится сделать через представленные выше свойства. Например, что если понадобится второе текстовое поле для надежной аутентификации со вторым паролем или пользовательским ключом доступа, как это делается на некоторых правительственных сайтах?

К счастью, подобно другим элементам управления, таким как GridView, элемент Login поддерживает шаблоны. С помощью шаблонов можно настраивать содержимое элемента управления Login без каких-либо ограничений. К нему можно добавлять любые новые элементы управления. Применяется специальный шаблон к элементу управления Login с помощью дескриптора LayoutTemplate :

Войти в систему

Имя пользователя:
Пароль:

Если посмотреть на приведенный код, то возникает один вопрос: если при настройке шаблона приходится писать настолько много кода пользовательского интерфейса (или проектировать его в визуальном конструкторе), так почему бы ни написать собственную страницу входа, не применяя элемента управления Login?

Это правильный вопрос. Однако, как объяснялось ранее, интерфейсная часть - это только одна часть элемента Login. Например, на случай, когда пользователь щелкает на кнопке входа, элемент управления Login уже имеет весь необходимый код для автоматической проверки пользователя по хранилищу членства и перенаправляет его на исходную запрошенную им страницу через инфраструктуру аутентификации с помощью форм. Так что вы определенно избавлены от необходимости написания этого кода.

С правильными элементами управления и корректными значениями идентификаторов для этих элементов управления не понадобится писать код обработки событий. Код работает обычным образом, за исключением того, что вы определяете набор элементов управления и их компоновку. В действительности элемент управления Login требует как минимум двух текстовых полей с идентификаторами UserName и Password. Если эти два текстовых поля отсутствуют (или имеют другие значения идентификатора), то Login сгенерирует исключение. Все остальные элементы управления не обязательны, но если вы указываете соответствующее значение идентификатора (такое как Login для кнопки входа), то Login автоматически обработает их события, и будет вести себя так, как тогда, когда применяется компоновка по умолчанию.

В таблице ниже перечислены специальные значения идентификаторов, требуемые для них типы элементов и признак обязательности:

Элементом управления с идентификатором Login может быть любой, поддерживающий пузырьковое распространение событий и свойство CommandName. Важно установить свойство CommandName этого элемента в Login, т.к. в противном случае элемент управления Login не будет распознавать его в процессе обработки событий. Если не добавить элемент управления со свойством CommandName, установленным в Login, придется обрабатывать события самостоятельно и писать соответствующий код для проверки имени пользователя и пароля, а также перенаправления на исходную запрошенную страницу.

Можно также добавлять элементы управления с другими идентификаторами, которые вообще не имеют отношения к Login. В показанном выше коде применялись элементы RequiredFieldValidator и RegularExpressionValidator для проверки полей имени пользователя и пароля.

При использовании LayoutTemplate многие свойства, изначально присущие элементу управления, становятся недоступными. Когда применяется шаблон, остаются доступными только следующие свойства:

DestinationPageUrl

VisibleWhenLoggedIn

MembershipProvider

Все свойства стиля и несколько свойств настройки текстового содержимого элементов по умолчанию больше не доступны в редакторе свойств Visual Studio, поскольку их можно добавить вручную как отдельные элементы управления или статический текст к шаблону элемента Login. Если вы будете добавлять их к элементу Login в режиме шаблона, они просто будут игнорироваться, потому что шаблон переопределяет интерфейс по умолчанию элемента Login, который пользуется этими свойствами.

Программирование элемента управления Login

Элемент управления Login поддерживает несколько событий и свойств, которые можно применять для настройки его поведения. Они предоставляют полный контроль над тонкой настройкой элемента управления Login (наряду с другими средствами настройки, такими как шаблоны и свойства стиля). Элемент управления Login поддерживает события, перечисленные в таблице ниже:

События элемента управления Login

Событие	Описание
LoggingIn	Инициируется непосредственно перед аутентификацией пользователя элементом управления
LoggedIn	Инициируется после того, как пользователь аутентифицирован элементом управления
LoginError	Инициируется при неудачной попытке входа пользователя по какой-либо причине (например, из-за неправильного пароля или имени пользователя)
Authenticate	Инициируется для аутентификации пользователя. Если вы обрабатываете это событие, то должны аутентифицировать пользователя самостоятельно, и элемент управления Login будет полностью полагаться на ваш код аутентификации

Первые три события можно обрабатывать для выполнения некоторых действий перед аутентификацией пользователя, после аутентификации и в случае возникновения ошибки во время осуществления аутентификации. Например, событие LoginError можно использовать для автоматического перенаправления пользователя на страницу восстановления пароля после определенного количества попыток входа, как показано ниже:

Protected void Page_Load(object sender, EventArgs e) { if (!this.IsPostBack) ViewState["LoginErrors"] = 0; } protected void Login1_LoginError(object sender, EventArgs e) { // Если состояние LoginErrors не существует, создать его if (ViewState["LoginErrors"] == null) ViewState["LoginErrors"] = 0; // Увеличить счетчик неудачных попыток входа int ErrorCount = (int)ViewState["LoginErrors"] + 1; ViewState["LoginErrors"] = ErrorCount; // Проверить количество неудачных попыток if ((ErrorCount > 3) && (Login1.PasswordRecoveryUrl != string.Empty)) Response.Redirect(Login1.PasswordRecoveryUrl); }

Элемент управления Login генерирует события в порядке, представленном на рисунке ниже:

Как упоминалось ранее, если вы перехватываете событие Authenticate, то должны добавить собственный код проверки имени пользователя и пароля. Свойство Authenticate поддерживает экземпляр AuthenticateEventArgs списка параметров. Этот класс аргумента события поддерживает одно свойство по имени Authenticated. Если установить его в true, то элемент управления Login предполагает, что аутентификация прошла успешно, и инициирует событие LoggedIn. Если же установить это свойство в false, будет отображен FailureText и инициировано событие LoginError:

Protected void Login1_Authenticate(object sender, AuthenticateEventArgs e) { if (Membership.ValidateUser(Login1.UserName, Login1.Password)) { e.Authenticated = true; } else { e.Authenticated = false; } }

Как видите, имеется прямой доступ к введенным значениям через свойства UserName и Password, которые содержат текст, введенный в соответствующие текстовые поля. Если вы используете шаблонные элементы управления и хотите получить значение из другого элемента, в дополнение к элементам с идентификаторами UserName и Password, то для этого можете использовать метод FindControl() для получения этого дополнительного элемента. Этот метод принимает идентификатор нужного элемента и возвращает экземпляр System.Web.UI.Control. Затем полученный объект просто приводится к типу требуемого элемента управления и читается значение, необходимое специальному методу проверки удостоверения пользователя.