NetSqlAzMan против AzMan vs (?????)

Ответ 1

Я наконец нашел статью "сравнить" вчера вечером.

http://www.c-sharpcorner.com/uploadfile/a.ferendeles/netsqlazman12122006123316pm/netsqlazman.aspx

Я собираюсь вставить соответствующую часть здесь (ниже). (На всякий случай, когда сайт перестанет существовать в будущем. Небольшая вероятность, я знаю, но я ненавижу ссылки "Ответ здесь", и когда вы нажимаете на ссылку, она мертвая.)

Из того, что я могу сказать.

NetSqlAzMan предоставляет (таблицу) пользовательскую функцию, которую вы можете перегрузить, чтобы предоставить список пользователей (которым назначены роли/задачи). NetSqlAzMan предоставляет не только сопоставления "Да, вы можете" (грант), но также Deny и Grant-With-Delegate. NetSqlAzMan и Azman позволяют пользователям (группам) сопоставлять роли. Только NetSqlAzMan позволяет пользователям сопоставлять задачи.

После просмотра нескольких образцов... объектная модель NetSqlAzMan очень чиста.

=============================================== ========

Менеджер авторизации Ms (AzMan) и диспетчер авторизации .NET Sql (NetSqlAzMan)

Как уже указывалось ранее, аналогичный продукт Microsoft уже существует и называется диспетчером авторизации (AzMan); AzMan присутствует, по умолчанию, в Windows Server 2003 и через установку пакета администрирования в Windows XP.

Важным отличием AzMan от NetSqlAzMan является то, что сначала основано на ролях, то есть на основе концепции принадлежности к ролям и контейнер операций в каждой роли, а второй - Элемент (или если вы предпочитаете операцию), то есть пользователи или пользователи группа или группа групп, которые могут или не могут принадлежать Ролям или выполнять такие задачи и/или операции (элементы).

Здесь наиболее важные особенности и различия между двумя продукты:

Ms AzMan:

* It COM.
* It equipped by a MMC 2.0 (COM) console.
* Its storage can be an XML file or ADAM (Active Directory Application Mode - e un LDAP).
* It role-based.
* It supports static/dynamic applicative groups, members/not-members.
* Structure based on Roles -> Tasks -> Operations. (Hierarchical Roles and Tasks , none Operations).
* Authorizations can be added only to Roles.
* It doesn't implement the "delegate" concept.
* It doesn't manage authorizations "in the time".
* It doesn't trigger events.
* The only type of authorization is "Allow".
  (to "deny" it needs to remove the user/group from his Role).
* It supports Scripting / Biz rules.
* It supports Active Directory users/groups and ADAM users.

NetSqlAzMan:

* It .NET 2.0.
* It equipped by a MMC 3.0 (.NET) console.
* Its storage is a Sql Server database(2000/MSDE/2005/Express).
* It based on Tdo - Typed Data Object technology.
* It Item-based.
* Structure based on Roles -> Tasks -> Operations. (all hierarchical ones).
* Authorizations can be added to Roles, Task and Operations.
* It supports static/dynamic applicative groups, members/not-members.
* LDAP query testing directly from console.
* It time-dependant.
* It delegate-compliant.
* It triggers events (ENS).
* It supports 4 authorization types:
      o Allow with delegation (authorized and authorized to delegate).
      o Allow (authorized).
      o Deny (not authorized).
      o Neutral (neutral permission, it depends on higher level Item permission).
* Hierarchical authorizations.
* It supports Scripting / Biz rules (compiled in .NET - C# - VB - and not interpreted)
* It supports Active Directory users/groups and custom users defined in SQL Server Database.

Здесь еще раз.

Пример кода Азмана: http://channel9.msdn.com/forums/sandbox/252978-AzMan-in-the-Enterprise-Sample-Code http://channel9.msdn.com/forums/sandbox/252973-Programming-AzMan-Sample-Code

using System;
using System.Security.Principal;
using System.Runtime.InteropServices;
using AZROLESLib;

namespace TreyResearch {
    public class AzManHelper : IDisposable {

        AzAuthorizationStore store;
        IAzApplication app;
        string appName;

        public AzManHelper(string connectionString, string appName) {

            this.appName = appName;

            try {
                // load and initialize the AzMan runtime
                store = new AzAuthorizationStore();
                store.Initialize(0, connectionString, null);

                // drill down to our application
                app = store.OpenApplication(appName, null);
            }
            catch (COMException x) {
                throw new AzManException("Failed to initizlize AzManHelper", x);
            }
            catch (System.IO.FileNotFoundException x) {
                throw new AzManException(string.Format("Failed to load AzMan policy from {0} - make sure your connection string is correct.", connectionString), x);
            }
        }

        public void Dispose() {
            if (null == app) return;

            Marshal.ReleaseComObject(app);
            Marshal.ReleaseComObject(store);

            app = null;
            store = null;
        }

        public bool AccessCheck(string audit, Operations op,
                                WindowsIdentity clientIdentity) {

            try {
                // first step is to create an AzMan context for the client
                // this looks at the security identifiers (SIDs) in the user's
                // access token and maps them onto AzMan roles, tasks, and operations
                IAzClientContext ctx = app.InitializeClientContextFromToken(
                    (ulong)clientIdentity.Token.ToInt64(), null);

                // next step is to see if this user is authorized for
                // the requested operation. Note that AccessCheck allows
                // you to check multiple operations at once if you desire
                object[] scopes = { "" };
                object[] operations = { (int)op };
                object[] results = (object[])ctx.AccessCheck(audit, scopes, operations,
                                                             null, null, null, null, null);
                int result = (int)results[0];
                return 0 == result;
            }
            catch (COMException x) {
                throw new AzManException("AccessCheck failed", x);
            }
        }

        public bool AccessCheckWithArg(string audit, Operations op,
                                       WindowsIdentity clientIdentity,
                                       string argName, object argValue) {

            try {
                // first step is to create an AzMan context for the client
                // this looks at the security identifiers (SIDs) in the user's
                // access token and maps them onto AzMan roles, tasks, and operations
                IAzClientContext ctx = app.InitializeClientContextFromToken(
                    (ulong)clientIdentity.Token.ToInt64(), null);

                // next step is to see if this user is authorized for
                // the requested operation. Note that AccessCheck allows
                // you to check multiple operations at once if you desire
                object[] scopes = { "" };
                object[] operations = { (int)op };
                object[] argNames = { argName };
                object[] argValues = { argValue };
                object[] results = (object[])ctx.AccessCheck(audit, scopes, operations,
                                                             argNames, argValues,
                                                             null, null, null);
                int result = (int)results[0];
                return 0 == result;
            }
            catch (COMException x) {
                throw new AzManException("AccessCheckWithArg failed", x);
            }
        }

        // use this to update a running app
        // after you change the AzMan policy
        public void UpdateCache() {
            try {
                store.UpdateCache(null);
                Marshal.ReleaseComObject(app);
                app = store.OpenApplication(appName, null);
            }
            catch (COMException x) {
                throw new AzManException("UpdateCache failed", x);
            }
        }
    }

    public class AzManException : Exception {
        public AzManException(string message, Exception innerException)
          : base(message, innerException)
        {}
    }
}

Это код помощника Азмана. Это уродливый COM/Interopish.: & Л;

Теперь проверьте образцы кода NetSqlAzMan:

http://netsqlazman.codeplex.com/wikipage?title=Samples

/// <summary>
/// Create a Full Storage through .NET code
/// </summary>
private void CreateFullStorage()
{
    // USER MUST BE A MEMBER OF SQL DATABASE ROLE: NetSqlAzMan_Administrators

    //Sql Storage connection string
    string sqlConnectionString = "data source=(local);initial catalog=NetSqlAzManStorage;user id=netsqlazmanuser;password=password";
    //Create an instance of SqlAzManStorage class
    IAzManStorage storage = new SqlAzManStorage(sqlConnectionString);
    //Open Storage Connection
    storage.OpenConnection();
    //Begin a new Transaction
    storage.BeginTransaction(AzManIsolationLevel.ReadUncommitted);
    //Create a new Store
    IAzManStore newStore = storage.CreateStore("My Store", "Store description");
    //Create a new Basic StoreGroup
    IAzManStoreGroup newStoreGroup = newStore.CreateStoreGroup(SqlAzManSID.NewSqlAzManSid(), "My Store Group", "Store Group Description", String.Empty, GroupType.Basic);
    //Retrieve current user SID
    IAzManSid mySid = new SqlAzManSID(WindowsIdentity.GetCurrent().User);
    //Add myself as sid of "My Store Group"
    IAzManStoreGroupMember storeGroupMember = newStoreGroup.CreateStoreGroupMember(mySid, WhereDefined.Local, true);
    //Create a new Application
    IAzManApplication newApp = newStore.CreateApplication("New Application", "Application description");
    //Create a new Role
    IAzManItem newRole = newApp.CreateItem("New Role", "Role description", ItemType.Role);
    //Create a new Task
    IAzManItem newTask = newApp.CreateItem("New Task", "Task description", ItemType.Task);
    //Create a new Operation
    IAzManItem newOp = newApp.CreateItem("New Operation", "Operation description", ItemType.Operation);
    //Add "New Operation" as a sid of "New Task"
    newTask.AddMember(newOp);
    //Add "New Task" as a sid of "New Role"
    newRole.AddMember(newTask);
    //Create an authorization for myself on "New Role"
    IAzManAuthorization auth = newRole.CreateAuthorization(mySid, WhereDefined.Local, mySid, WhereDefined.Local, AuthorizationType.AllowWithDelegation, null, null);
    //Create a custom attribute
    IAzManAttribute<IAzManAuthorization> attr = auth.CreateAttribute("New Key", "New Value");
    //Create an authorization for DB User "Andrea" on "New Role"
    IAzManAuthorization auth2 = newRole.CreateAuthorization(mySid, WhereDefined.Local, storage.GetDBUser("Andrea").CustomSid, WhereDefined.Local, AuthorizationType.AllowWithDelegation, null, null);
    //Commit transaction
    storage.CommitTransaction();
    //Close connection
    storage.CloseConnection();
}

Это само по себе рассказывает историю.

Ответ 2

Я думаю, что причина отсутствия обновлений от Microsoft в их блогах и в их SDK имеет отношение к ним, и они уже перемещают все свои инструменты и проекты в сторону "модели претензий в социальной сети/федерации":

http://msdn.microsoft.com/en-us/magazine/ee335707.aspx

По сравнению с любым из вариантов AzMan, на низком уровне работы AzMan (что требует код, чтобы отделить его от остальных), у нас есть только требование типа разрешения. Этот новый стиль операции - это просто имя/название URN, выданное из любого доверенного поставщика/службы претензий, проверенных подписями, которые вы (или более поздняя переконфигурация) определяете. Они представляют собой просто плоский список ролей в пользовательской идентичности, поэтому их легко проверить с помощью общих методов IsInRole.

Обоснование этого ясно. Современные интернет-решения (и, возможно, некоторые будущие приложения корпоративной интрасети после улучшения законов о конфиденциальности) требуют многодоменной аутентификации и авторизации, например. это учетная запись пользователя StackOverflow.com и связанная учетная запись Facebook или любая учетная запись OpenID, которую вы могли связать.

Итак, для авторизации теперь вы можете использовать правила CODE, которые отображают между внешними утверждениями и внутренними "требованиями к разрешению" (аналогичными операциям AzMan). Однако нет стандартного формата, иерархии или инструмента администрирования.

Возможно, гибридное решение Claims Service (Аутентификация) + AzMan XML/SQL (сопоставление ролей с претензиями) + Требование о разрешении претензий - это путь вперед. Все образцы, которые я нашел до сих пор, имеют только код в середине. Я хочу увидеть что-то с рекурсивным членством в группе из Active Directory, разрешенным для "Роли к задачам", к заявкам (операциям), которые мы уже имеем с AzMan.

Необходимы дополнительные исследования для достижения "старой доброй", но по-прежнему важной модели с "основанной на ролях" с новейшей технологией...

Если вы хотите начать, направляйтесь к Microsoft Windows Identity Foundation (WIF), который впервые появился в .NET 3.5.1, но с тех пор был интегрирован в среду .NET 4.5.

http://msdn.microsoft.com/en-us/library/hh377151 (v = vs .110).aspx