2012-01-05 5 views
11

Próbowałem "odczytać między wierszami" o oryginalnej (i/lub aktualnej) motywacji dla projektu NetSqlAzMan.NetSqlAzMan vs AzMan vs (?????)

Czy to było napisane?

  1. Adapter dla Menedżera autoryzacji systemu Windows (AzMan). Gdzie metody w NetSqlAzMan po prostu przekazuje połączenia do (Windows Authorization Manager (AzMan)), ale być może z ładniejszymi/czystszymi metodami?

  2. Zamiennik (Menedżer autoryzacji systemu Windows (AzMan)). Gdzie (większość lub wszystkie) funkcje dostępne w (Menedżer autoryzacji systemu Windows (AzMan)) są odtwarzane w NetSqlAzMan, ale kod został opracowany niezależnie. (Być może w celu zapewnienia obsługi DotNet 4.0 ??) (Być może w celu usunięcia zależności od COM)

  3. Aby zapewnić więcej funkcji niż (Windows Authorization Manager (AzMan)). Aka, "inteligentniejsza"/"lepsza" wersja (Windows Authorization Manager (AzMan)).

  4. Przepisywanie, ale także utrzymywanie pół-martwego projektu przy użyciu otwartego oprogramowania. (Jako w, być może (Windows Authorization Manager (AzMan))) jest martwym lub porzuconym projektem Microsoftu).

  5. Inne?

................

Lubię modelu obiektowego NetSqlAzMan. Ale muszę bronić każdej decyzji, aby użyć jej do mojego kierownika projektu i innych programistów. Model obiektowy wydaje się "w sam raz" (pomyśl goldilocks i środkowe łóżko), jeśli chodzi o to, czego pragnę dla bezpieczeństwa. NIE chcę tworzyć zabezpieczeń opartych na rolach. Chcę mieć zabezpieczenia oparte na prawach (lub zadaniach lub uprawnieniach).

(Patrz: http://lostechies.com/derickbailey/2011/05/24/dont-do-role-based-authorization-checks-do-activity-based-checks/ i http://granadacoder.wordpress.com/2010/12/01/rant-hard-coded-security-roles/ )

I w zasadzie wątpliwości, że wymyślił to: "Co jest zaletą korzystania NetSqlAzMan zamiast (Windows Menedżer autoryzacji (AzMan))"

Podrzędne pytanie brzmi: "Czy Menedżer autoryzacji systemu Windows (AzMan) jest martwy?". (I coś podobnego do Long Live NetSqlAzMan!).

..................

My w generalny wymagania to:

użytkowników dla Active-katalog. (W trakcie pracy obsługa Active Directory i/lub LDAP byłaby miła, ale nie jest wymagana). Hasła nie są zapisywane jako zwykły tekst. Umiejętność obsługi PRAW DO kontroli bezpieczeństwa.
Grupuj prawa w dowolnej roli. Przypisywanie ról użytkownikom. (Ale ponownie, kod będzie sprawdzał prawa, a nie rolę podczas wykonywania działania.) Umożliwiają (czasami) uprawnienia do przydzielania użytkownikom. Z nadpisaniem Odmowa. (Aka, pojedynczy użytkownik, który robi coś głupiego (np. "Usuń pracownika") może mieć to prawo unieważnione.) Role i prawa można zachować dla wielu aplikacji.

Inne pomysły są mile widziane.Ale Windows Identity Foundation wydaje się trochę przesadą.

Dzięki.

Odpowiedz

10

końcu znalazłem „Porównaj” artykuł ostatniej nocy.

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

mam zamiar wkleić odpowiedni fragment tutaj (poniżej). (Na wypadek gdyby strona przestała istnieć w przyszłości, mała szansa, wiem, ale nienawidzę linków "Odpowiedź tu jest", a po kliknięciu linku jest martwa.)

Z czego Mogę powiedzieć.

NetSqlAzMan dostarcza (tabela) zdefiniowany przez użytkownika-funkcji, które można przeciążeniem, aby dostarczyć listę użytkowników (być przypisane do ról/zadań). NetSqlAzMan zapewnia nie tylko mapowania "Tak, możesz" (Grant), ale także Odmów i Grant-z-Delegatem. NetSqlAzMan i Azman umożliwiają użytkownikom (grupom) mapowania ról. Tylko NetSqlAzMan umożliwia użytkownikom mapowanie zadań.

Po pobycie w kilku próbkach ... model przedmiotem NetSqlAzMan jest bardzo czyste.

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

Pani Menedżer autoryzacji (AzMan) vs .NET SQL Menedżerze autoryzacji (NetSqlAzMan)

Jak wskazano wcześniej, analogicznego produktu Microsoft już istnieje i nazywa Menedżer autoryzacji (AzMan); AzMan jest obecny, przez domyślnie w systemie Windows Server 2003, a przez setup Admin Pack w Windows XP.

Ważną różnicą pomiędzy AzMan i NetSqlAzMan jest to, że Pierwszym z nich jest oparta na rolach, czyli w oparciu o należącą - koncepcja Rola i pojemnikiem operacji w każdej roli, podczas gdy druga jest Przedmiot oparte (lub jeśli wolisz Operation-based), to użytkownicy lub użytkownicy grupa lub grupa grup, które mogą lub nie mogą należeć do ról lub wykonać takich zadań i/lub operacji (przedmioty).

Oto najważniejsze cechy i różnice między tymi dwoma produktów:

Ms AzMan:

* It's COM. 
* It's 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's 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's .NET 2.0. 
* It's equipped by a MMC 3.0 (.NET) console. 
* Its storage is a Sql Server database(2000/MSDE/2005/Express). 
* It's based on Tdo - Typed Data Object technology. 
* It's 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's time-dependant. 
* It's 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. 

Oto kolejny haczyka.

AzMan przykładowy kod: 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) 
     {} 
    } 
} 

To AzMan kod pomocnika. To brzydkie rzeczy COM/Interopish.: <

teraz sprawdzić NetSqlAzMan próbki kodu:

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(); 
} 

który opowiada historię w sobie.

+0

Chciałem tylko zwrócić uwagę, że artykuł i uwagami o AzMan były z artykułu pisał w 2006 AzMan został zaktualizowany i poprawie (escpecially wsparcie API i SQL Server Store), gdy system Windows Server 2008 wyszedł. Nadal jednak wydaje się, że Azman został porzucony. Ostatnia aktualizacja blogu zespołu Azman pochodzi z 2008 roku. – Haydar

+0

Dzięki za napiwek. Nie ładować Azmana, ale fakt, że jest on powiązany z konkretnymi wersjami O/S ...... to także kłopotliwe miejsce dla mnie. Ale to mogła być jedna z tych rzeczy, która była inspiracją dla czegoś lepszego ... – granadaCoder

+0

Czy NETSQL Azman jest zależny od Windows Azman w jakikolwiek sposób. Ponieważ Azman może być przestarzały w przyszłych wersjach Windows, czy to znaczy, że AzSQL NETSQL nie zadziała, kiedy to się stanie? – Donny

2

Myślę, że powodem braku aktualizacji firmy Microsoft na swoich blogach i w ich SDK ma coś z nimi już porusza wszystkie swoje narzędzia i wzory kierunku social network/federacji przyjazny „twierdzi model”:

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

W porównaniu do dowolnego z wariantów AzMana, na niskim poziomie operacji AzMan (czego wymaga kod oddzielający go od reszty) mamy tylko roszczenie dotyczące uprawnień. Ten nowy styl działania jest po prostu ciągiem znaków/nazwy URN wydanych od dowolnego zaufanego dostawcy/usługi sprawdzonej przez podpisy, które ty (lub późniejsze zmiany konfiguracji) definiują. Są one po prostu płaską listą ról w tożsamości użytkownika, którą można łatwo sprawdzić przy użyciu typowych metod IsInRole.

Uzasadnienie tego jest jasne. Nowoczesne rozwiązania internetowe (i być może niektóre przyszłe korporacyjne aplikacje intranetowe po poprawieniu przepisów dotyczących prywatności) wymagają uwierzytelnienia i autoryzacji w wielu domenach, np. to konto użytkownika StackOverflow.com i powiązane konto Facebooka lub dowolne konto OpenID, które być może połączone.

W celu uzyskania autoryzacji można teraz stosować reguły CODE, które mapują między roszczeniami zewnętrznymi a wewnętrznymi "roszczeniami o pozwolenie" (analogicznie do operacji AzMan). Jednak nie ma standardowego formatu, hierarchii ani narzędzia administracyjnego.

Być może hybrydowe rozwiązanie usługi roszczeń (uwierzytelnianie) + AzMan XML/SQL (mapowanie ról na roszczenia) + żądanie pozwoleń jest sposobem na przyszłość. Wszystkie próbki, które znalazłem do tej pory, mają kod w środku. Chcę zobaczyć coś z rekurencyjnymi członkostwami grup z Active Directory rozwiązanymi na role do zadań dla roszczeń (operacji), które już mamy z AzManem.

Więcej dochodzenie jest niezbędne do osiągnięcia „starych dobrych”, ale nadal istotną „opartą na rolach bezpieczeństwa” wzór z nowszych technologii ...

Jeśli szukasz zacząć, głową w kierunku systemu Windows Identity Foundation Microsoft (WIF), który po raz pierwszy pojawił się w .NET 3.5.1, ale od tego czasu został zintegrowany z platformą .NET 4.5.

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

+0

Dla przyszłych czytelników ... Całkowicie porzuciłem "starą szkołę" i teraz używam autoryzacji roszczeń. Lekki garb, aby się przedostać, ale na końcu kończy się. – granadaCoder