Translate this page now :



»Programação
»Programação.NET
»Banco de Dados
»Webdesign
»Office
» Certificações Microsoft 4
»Treinamentos4
»Programação 4
»Webdesign«
»Office & User Tips«
»Grupos de Usuários
»Células Acadêmicas«
intcontpiada : 118
Vá dormir
Você já está cadastrado e participa do grupo de usuários de sua cidade ? Se não, comente o porque.
 
 
Faça um pequeno teste com 10 questões de VB
.:.
Teste seus conhecimentos em Visual Basic, SQL Server e ASP 3.0 com nossas provas on-line
.:.
Aprimore seus conhecimentos em programação com nosso treinamento on-line de lógica de programação
.:.
Veja nosso calendário de treinamentos
Gostou da Página?
Então

para um amigo!
 





Por Dennes Torres
dennes@bufaloinfo.com.br
Dennes Torres possui as certificações MCAD, MCSD,MCSE, MCDBA e MCT. Atualmente atua Como diretor da Búfalo Informática, líder do grupo de usuários DevASPNet no Rio de Janeiro e membro da liderança dos grupos getWindows e devSQL, também do Rio de Janeiro, podendo sempre ser encontrado na lista de discussão do grupo DevASPNet (devaspnet-subscribe@yahoogrupos.com.br) bem como nas reuniões do grupo. Mantém dois blogs em http://cidadaocarioca.blogspot.com

Manipulando ACLs com o Framework .NET

Pesquisa personalizada
Pesquisar Dicas:






Uma das novidades que o framework 2.0 traz em relação a segurança são novas classes que nos permitem manipular ACLs - Access Control List - através da própria class library do framework.

Um exemplo de ACL são as listas de permissão nas pastas e arquivos. Através do framework podemos agora manipular estas permissões, tanto consulta-las como altera-las.

Para demonstrar a manipulação das ACLs no framework, vamos criar uma aplicação windows simples.

Primeiro Passo : Montagem do formulário

Vamos no formulário inserir um label e uma listView. O label mostrará a pasta que estamos consultado e o listView mostrará as permissões existentes nesta pasta.

Precisaremos também de um FolderBrowserDialog, uma caixa de diálogo para perguntar ao usuário de qual pasta ele deseja visualizar as permissões. Antigamente tinhamos que disparar esse diálogo via API, agora temos um objeto para fazer isso, fica na toolbox.

Vamos chamar o label de lblPasta e o FolderBrowserDialog de FBD.

 

Precisaremos também configurar as coluna da listView para que sejam exibidas corretamente. Fazemos isso através da propriedade columns. As 4 colunas se chamarão "Usuário", "Herdado", "Permissão" e "Tipo".

Segundo Passo : Perguntando ao usuário qual pasta deseja visualizar

A aplicação será simples, então vamos fazer isso diretamente no load do formulário. Basta utilizar o FBD, ele fará a pergunta ao usuário e nos trará a resposta.

   46         If FBD.ShowDialog = Windows.Forms.DialogResult.OK Then

   47 

   48             lblPasta.Text = FBD.SelectedPath

   49             exibirACLs()

   50         Else

   51             Me.Close()

   52         End If

Observe que neste trecho de código fazemos uma chamada a função "exibirACLs", que irá realizar o passo seguinte, exibir a ACL da pasta.


Terceiro Passo : Exibir a ACL

Precisaremos realizar 3 imports para fazer este 3o passo :

    1 Imports System.IO

    2 Imports System.Security.AccessControl

    3 Imports System.Security.Principal

O primeiro contem a classe DirectoryInfo, para manipularmos pastas no disco, o 2o as classes para nos permitir acessar a ACL e o 3o classes com a identificação do usuário, afinal a ACL é uma lista de quem tem ou não acesso a um recurso, ou seja, uma lista de usuários.

Nossa função, exibirAcls, irá utilizar alguns objetos que serão também necessários quando formos realizar a alteração da ACL. Dois deles são DirectoryInfo e DirectorySecurity. DirectoryInfo nos traz informações sobre uma pasta enquanto que DirectorySecurity é obtida a partir da DirectoryInfo, trazendo-nos a ACL da pasta.

Para fazermos uma consulta - exibirmos a ACL - precisamos obter a coleção de regras, permissões atribuidas. Essa coleção é do tipo AuthorizationRuleCollection. Essa coleção é o que exibiremos na listView e precisaremos dela em outros momentos, então será outra variável a ser definida a nível de form.

Veja como ficam as variáveis a nível de form :

    8     Dim colecao As AuthorizationRuleCollection

    9     Dim di As DirectoryInfo

   10     Dim acl As DirectorySecurity

Dentro da função vamos primeiramente criar as instâncias de DI e ACl, veja :

   63     Public Sub exibirACLs()

   64         If di Is Nothing Then

   65             di = New DirectoryInfo(lblPasta.Text)

   66 

   67             acl = di.GetAccessControl

   68         End If

   69 

   70         ListView1.Items.Clear()


Só precisamos fazer isso uma vez, depois as instâncias serão mantidas a nível de form. Observe que também tomei o cuidado de limpar a listView, desta forma a função exibirACLs terá o efeito de um refresh.

Dando continuidade a criação da função, vamos preencher a variável coleção :

   72         colecao = acl.GetAccessRules(True, True, GetType(NTAccount))

Os dois primeiros parâmetros são uma filtragem sobre o que será incluido, as permissões explicitamente definidas para o objeto ou as permissões herdadas em uma hierarquia. No nosso caso, solicitei os dois.

O 3o parâmetro trata da identidade do usuário. Os objetos dentro desta coleção (AuthorizationRuleCollection) possuem uma propriedade chamada IdentityReference. Ocorre que como as ACLs podem ser aplicadas em inúmeros locais diferentes, esta propriedade também pode devolver objetos de tipos diferentes, diferentes formas de identificar o usuário.

Assim sendo o método GetAccessRules nos permite especificar de que tipo desejamos que sejam devolvidas as identidades do usuário. Para ACLs do sistema o melhor é o NTAccount.

Após termos obtido a coleção, precisamos percorre-la para preencher a listview. Assim sendo precisamos fazer um for/each.

Oficialmente o tipo de dados devolvido pela AuthorizationRuleCollection é uma classe AuthorizationRule. Mas AuthorizationRule é na verdade uma classe que serve como base de diversas outras, mais específicas. Uma delas é a FileSystemAccessRule que utilizaremos no nosso caso, já que estamos trabalhando com permissões de pastas no disco. Veja como fica o laço :

   63         For Each si As FileSystemAccessRule In colecao

   64 

   65         Next

Vamos então criar um novo listViewItem e acrescentar o item na listView, veja como fica :

   79         For Each si As FileSystemAccessRule In colecao

   80 

   81             Dim li As New ListViewItem

   82             li.Text = si.IdentityReference.Value

   83             li.SubItems.Add(si.IsInherited.ToString)

   84             li.SubItems.Add(si.FileSystemRights.ToString)

   85             li.SubItems.Add(si.AccessControlType.ToString)

   86             ListView1.Items.Add(li)

   87 

   88         Next

 

Veja o significado de cada item :

IdentityReference.Value : O nome do usuário. Mas lembre-se que pedimos a classe como NTAccount, esse valor pode variar.

IsInherited : Se a permissão é herdada ou não

FileSystemRights : As permissões que foram atribuidas

AccessControlType : O tipo de atribuição, Allow ou Deny

Veja então a função completa :

   68     Public Sub exibirACLs()

   69         If di Is Nothing Then

   70             di = New DirectoryInfo(lblPasta.Text)

   71 

   72             acl = di.GetAccessControl

   73         End If

   74 

   75         ListView1.Items.Clear()

   76 

   77         colecao = acl.GetAccessRules(True, True, GetType(NTAccount))

   78 

   79         For Each si As FileSystemAccessRule In colecao

   80 

   81             Dim li As New ListViewItem

   82             li.Text = si.IdentityReference.Value

   83             li.SubItems.Add(si.IsInherited.ToString)

   84             li.SubItems.Add(si.FileSystemRights.ToString)

   85             li.SubItems.Add(si.AccessControlType.ToString)

   86             ListView1.Items.Add(li)

   87 

   88         Next

   89     End Sub

Neste ponto já podemos executar a aplicação e veremos a lista de permissões de uma pasta.

 

Quarto passo : Criar um formulário para a exibição de detalhes

Cada item de permissão que exibimos na listView pode na verdade se referir a várias permissões atribuidas a um mesmo usuário. Para permitir que o usuário altere as permissões vamos criar um 2o form para a exibição dos detalhes das permissões.

Neste 2o form vamos inserir um DataGridView para exibir as permissões. Precisaremos também de um botão para realizar a gravação das alterações nas permissões.

Precisamos ainda configurar as 3 colunas da DataGridView para garantir que sejam exibidas corretamente. Faremos isso através da propriedade Columns da DataGridView.


Quinto passo : Codificar a exibição do 2o formulário

Vamos fazer com que o formulário de detalhes seja exibido a partir do duplo clique na listview. O usuário estará clicando em uma FileSystemAccessRule e o objetivo do formulário de detalhes é mostrar detalhadamente as permissões contidas na FileSystemAccessRule e permitir a alteração delas.

Para isso precisaremos transmitir para o 2o form o objeto FileSystemAccessRule no qual o usuário deu duplo clique.

A alteração da ACL não pode ser feita apenas com a FileSystemAccessRule. Então vamos fazer com que o 2o formulário possa disparar a realização da alteração pelo 1o. Para fazer isso vamos utilizar delegates. O form 1 transmite para o form 2 o ponteiro para uma sub que seja responsável pela atualização.

Para que isso seja possível precisamos fazer algumas definições no 2o form, a nível de form. Veja como fica :

   13     Public far As FileSystemAccessRule

   14     Public Delegate Sub alteracao(ByVal Permissao As FileSystemAccessRule, ByVal Negacao As FileSystemAccessRule)

   15 

   16 

   17     Public Alterar As alteracao

As variáveis FAR e ALTERAR precisarão ser preenchidas no momento da chamada ao form2. Veja como fica :

   99     Private Sub ListView1_DoubleClick(ByVal sender As Object, ByVal e As System.EventArgs) Handles ListView1.DoubleClick

  100 

  101 

  102         Dim f As New Form2

  103         f.far = colecao(ListView1.SelectedItems(0).Index)

  104         f.Alterar = AddressOf GravarAtualizacao

  105         f.Show()

  106     End Sub

Muito simples : Criamos uma instância do form, preenchemos os dois parâmetros e só depois chamamos o método show para exibição do formulário. Na variável do tipo delegate passamos o endereço de uma sub que o form 2 deverá disparar para completar a alteração da ACL.

 

Sexto passo : Criação de uma classe para exibição no dataGridView

Para exibir os dados no dataGridView vamos criar uma classe personalizada que represente uma permissão específica a qual o usuário tem permissão ou não. Assim poderemos fazer uma coleção desta classe e vincula-la na dataGridView.

  110 Public Class ItemSeguranca

  111     Dim ballow As Boolean

  112     Dim bDeny As Boolean

  113     Dim sPermissao As String

  114 

  115 

  116     Public Sub New(ByVal Direito As String, ByVal Permite As Boolean, ByVal nega As Boolean)

  117 

  118 

  119         sPermissao = Direito

  120         Allow = Permite

  121         Deny = nega

  122     End Sub

  123 

  124     Public ReadOnly Property ValorPermissao() As FileSystemRights

  125         Get

  126             Return ([Enum].Parse(GetType(FileSystemRights), sPermissao))

  127 

  128 

  129         End Get

  130     End Property

  131 

  132 

  133     Public Property Deny() As Boolean

  134         Get

  135             Return (bDeny)

  136         End Get

  137         Set(ByVal value As Boolean)

  138             bDeny = value

  139         End Set

  140     End Property

  141 

  142     Public Property Allow() As Boolean

  143         Get

  144             Return (ballow)

  145         End Get

  146         Set(ByVal value As Boolean)

  147             ballow = value

  148         End Set

  149     End Property

  150 End Class

Nossa classe, ItemSeguranca, tem exatamente 3 propriedades, as 3 que desejaremos exibir na grid : A permissão e duas propriedades boolean, indicando a atribuição de Allow ou Deny para o usuário.

Sétimo Paso : Criação da coleção a ser exibida

Precisamos agora fazer uma coleção que possa receber elementos do tipo ItemSegurança. Vamos aproveitar os recursos de Generics e criar essa coleção a nível de formulário :

    8     Dim ar As New Generic.List(Of ItemSeguranca)

Vamos então preencher essa coleção. A intenção é que essa coleção tenha todas as permissões que o usuário pode vir a receber, marcadas como true ou false.

No nosso caso, as permissões que o usuário pode vir a receber estão em um Enum em System.Security.AccessControl.FileSystemRights . Então podemos obter o nome dos elementos deste enum em um array e utiliza-lo para gerar a coleção.

Normalmente utilizariamos o método GetNames para obter os nomes dos elementos de um Enum, mas o enum FileSystemRights possui uma caracteristica especial. Este Enum possui vários elementos com nomes diferentes e mesmos valores. Isso porque algumas permissões são tão interligadas entre si que atribuindo uma, a outra é atribuida também. Pode-se também interpretar isso como nomes diferentes para a mesma permissão.

Cabe então a nossa aplicação cuidar em código das implicações disso. Por exemplo, Se exibirmos as duas, então quando uma for marcada a outra deve ser também. Mas quando formos gravar alterações, se somarmos o valor das duas estaremos gerando um resultado totalmente diferente, ambas precisam ser tratadas como uma só.

Para simplificar, em nosso exemplo vamos excluir as permissões com valores duplicados. Para fazer isso vamos criar uma função chamada ListaNomes. Veja como fica :

  112     Private Function ListaNomes() As ArrayList

  113         Dim ar As New ArrayList

  114         Dim valores As FileSystemRights()

  115         valores = [Enum].GetValues(GetType(System.Security.AccessControl.FileSystemRights))

  116 

  117 

  118 

  119         For Each s As FileSystemRights In valores

  120 

  121 

  122             If ar.IndexOf(s.ToString) = -1 Then

  123                 ar.Add(s.ToString)

  124             End If

  125         Next

  126 

  127         Return (ar)

  128     End Function


Utilizamos o GetValues para obter um array de valores do enum e percorremos o array de valores, adicionando-os em um arrayList. O truque é que antes de adiciona-los no arrayList testamos para ver se já existem ou não, eliminando assim os valores duplicados.

Voltando ao Load do formulário, vamos chamar esta função para obter a lista de nomes do Enum e fazer um laço através desta lista :

  111         Dim nomes As ArrayList

  112         nomes = ListaNomes()

  113         For Each s As String In nomes

  114 

  115         Next

O laço está sendo feito no arrayList de strings com os nomes das permissões. A partir desta string "s" precisamos recuperar de volta o valor deste elemento do enum e verificar se está contido na FileSystemAccessRule que este formulário recebeu.

  113         For Each s As String In nomes

  114             Dim r As FileSystemRights

  115             r = [Enum].Parse(GetType(FileSystemRights), s)

  116 

  117 

  118             If (far.FileSystemRights And r) = r Then

  119 

  120             Else

  121 

  122             End If

  123         Next

Observe a variávei r definida como FileSystemRights, para recuperarmos o valor do Enum e o IF utilizando um AND para descobrir se a permissão R está ou não entre as permissões atribuidas ao usuário.

O If determinará a forma como criaremos a instância da classe ItemSeguranca. Observe que esta classe tem dois booleans, Allow e Deny, que são definidos no construtor. Um deles estará marcado caso a permissão r esteja contida nas permissões do usuário. Caso não (else) , ambos estarão como false.

  113         For Each s As String In nomes

  114             Dim r As FileSystemRights

  115             r = [Enum].Parse(GetType(FileSystemRights), s)

  116 

  117 

  118             If (far.FileSystemRights And r) = r Then

  119 

  120             Else

  121                 ar.Add(New ItemSeguranca(s, False, False))

  122 

  123 

  124             End If

  125         Next

No caso do r estar contido nas permissões do usuário, então precisamos descobrir se definiremos Allow como true ou Deny como true. Isso depende das permissões do usuário que foram passadas para este formulário, se são uma atribuição (Allow) ou uma negação (Deny).

  113         For Each s As String In nomes

  114             Dim r As FileSystemRights

  115             r = [Enum].Parse(GetType(FileSystemRights), s)

  116 

  117 

  118             If (far.FileSystemRights And r) = r Then

  119 

  120 

  121                 If far.AccessControlType = AccessControlType.Allow Then

  122 

  123 

  124                     ar.Add(New ItemSeguranca(s, True, False))

  125 

  126                 Else

  127                     ar.Add(New ItemSeguranca(s, False, True))

  128 

  129                 End If

  130             Else

  131                 ar.Add(New ItemSeguranca(s, False, False))

  132 

  133             End If

  134         Next

Após o laço temos nossa coleção montada, então podemos vincula-la na dataGridView. Veja como fica a função completa :

  158     Private Sub Form2_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load

  159 

  160 

  161         Dim nomes As ArrayList

  162         nomes = ListaNomes()

  163 

  164         For Each s As String In nomes

  165             Dim r As FileSystemRights

  166             r = [Enum].Parse(GetType(FileSystemRights), s)

  167 

  168 

  169             If (far.FileSystemRights And r) = r Then

  170 

  171 

  172                 If far.AccessControlType = AccessControlType.Allow Then

  173 

  174 

  175                     ar.Add(New ItemSeguranca(s, True, False))

  176 

  177                 Else

  178                     ar.Add(New ItemSeguranca(s, False, True))

  179 

  180                 End If

  181             Else

  182                 ar.Add(New ItemSeguranca(s, False, False))

  183 

  184             End If

  185         Next

  186         DataGridView1.DataSource = ar

  187     End Sub

Neste ponto o formulário já pode ser exibido. Rodando a aplicação e dando um duplo clique na listview veremos os detalhes do item em questão

Oitavo Passo : Criando a gravação

Agora que fizemos a exibição, vamos criar uma gravação dos dados. Alterar, o usuário já pode alterar normalmente, a DataGridView permite, mas precisamos criar um botão para gravação, para que os dados alterados na DataGridView sejam persistidos

Na DataGridView fizemos a exibição de instâncias da classe ItemSeguranca, são nessas instâncias que o usuário realiza suas alterações.

A alteração de dados, porém, precisa de classes FileSystemAccessRule para ser realizada. Então precisaremos de um pequeno algorítimo para transformar os dados alterados pelo usuário novamente em instâncias da classe FileSystemAccessRule.

Mas não iremos gerar uma única instância, mas sim 2. A classe FileSystemAccessRule possui um tipo de permissão específica, ou de atribuição (Allow) ou de negação (Deny). Na nossa DataGridView exibimos duas colunas, uma de negação outra de atribuição. Assim sendo o conteúdo de nossa DataGridView precisará ser transformado em 2 instâncias da classe FileSystemAccessRule.

O ponto principal é que precisamos fazer a montagem de 2 valores do tipo FileSystemRights, um de atribuição outro de negação, conforme o que o usuário houver marcado na DataGridView.

Veja como fica essa montagem :

  190     Private Sub cmdGravar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles cmdGravar.Click

  191 

  192 

  193         Dim r As FileSystemRights

  194         Dim r2 As FileSystemRights

  195 

  196         For Each IP As ItemSeguranca In ar

  197             If IP.Allow Then

  198                 If (r And IP.ValorPermissao) <> IP.ValorPermissao Then

  199 

  200 

  201                     r += IP.ValorPermissao

  202                 End If

  203 

  204             ElseIf IP.Deny Then

  205                 If (r2 And IP.ValorPermissao) <> IP.ValorPermissao Then

  206 

  207 

  208                     r2 += IP.ValorPermissao

  209                 End If

  210             End If

  211         Next

  212 

  213     End Sub

Definimos duas variáveis, r e r2, para conter nossas montagens dos valores de FileSystemRights.

Realizamos então um laço através da coleção que preencheu a DataGridView. Sempre que desejamos fazer algorítimos assim devem ser feitos sobre a coleção que serviu de origem de dados para a DataGridView. Não se preocupe com as alterações do usuário, a DataGridView tomou o cuidado de persisti-las nesta coleção automaticamente.

Para cada item, se existir permissão "Allow", somamos em r, se existir permissão "Deny" somamos em r2. Não considerei a existência das duas juntas, não faria sentido, fica faltando um tratamento na interface para isso.

Observe que as somas estão cercadas com um IF, testando se por acaso o valor que iremos somar já está contido dentro da variável. Se estivesse o resultado desta operação seria o próprio valor que estamos somando, caso contrário será algo diferente.

Esse IF poderia parecer um pouco redundante, afinal que sentido tem testar se o que ainda não somamos já está incluido na soma ? Mas para compreender este IF é necessário lembrar que estamos trabalhando com Enums, flags que podem ser combinados.

A questão é que a combinação de várias permissões mais simples podem resultar em uma permissão maior. Por exemplo, Read é uma permissão resultante da combinação de várias permissões menores. Se somassemos os valores das várias permissões menores e depois somassemos novamente o valor da permissão maior obteríamos um resultado totalmente diferente. Desta forma os IFs estrategicamente colocados são essenciais para a geração do resultado.

Observe também que poderiamos melhorar a interface, criando marcações em conjunto. Por exemplo, quando a permissão maior for marcada as menores também são, e vice-versa.

O próximo passo é a partir dos valores gerados criar duas instâncias da classe FileSystemAccessRule para realizarmos a atualização na pasta. Veja como fica :

  213         Dim novaregra As FileSystemAccessRule = Nothing

  214         Dim novaregra2 As FileSystemAccessRule = Nothing

  215 

  216         If r <> 0 Then

  217             novaregra = New FileSystemAccessRule(far.IdentityReference, r, InheritanceFlags.ContainerInherit Or InheritanceFlags.ObjectInherit, PropagationFlags.None, AccessControlType.Allow)

  218 

  219 

  220         End If

  221         If r2 <> 0 Then

  222             novaregra2 = New FileSystemAccessRule(far.IdentityReference, r2, InheritanceFlags.ContainerInherit Or InheritanceFlags.ObjectInherit, PropagationFlags.None, AccessControlType.Deny)

  223 

  224 

  225         End If

Observe que a criação das instâncias está cercada por IFs,

Veja o significado dos parâmetros :

1- A identidade do usuário

2- As permissões atribuidas ao usuário

3- Os objetos que as permissões afetarão, pastas arquivos que estiverem dentro da pasta sendo permissionada.

4- A forma de propagação para outros objetos na árvore de objetos.

5- O tipo de controle de acesso, Allow ou Deny.

Com isso encerra-se a responsabilidade do form 2, quem vai realmente realizar a alteração dos parâmetros é o form 1. O que o form2 precisa fazer é disparar o delegate para que a alteração seja realizada no form1. Veja como fica a rotina completa do botão de gravação :

  190     Private Sub cmdGravar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles cmdGravar.Click

  191 

  192 

  193         Dim r As FileSystemRights

  194         Dim r2 As FileSystemRights

  195 

  196         For Each IP As ItemSeguranca In ar

  197             If IP.Allow Then

  198                 If (r And IP.ValorPermissao) <> IP.ValorPermissao Then

  199 

  200 

  201                     r += IP.ValorPermissao

  202                 End If

  203 

  204             ElseIf IP.Deny Then

  205                 If (r2 And IP.ValorPermissao) <> IP.ValorPermissao Then

  206 

  207 

  208                     r2 += IP.ValorPermissao

  209                 End If

  210             End If

  211         Next

  212 

  213         Dim novaregra As FileSystemAccessRule = Nothing

  214         Dim novaregra2 As FileSystemAccessRule = Nothing

  215 

  216         If r <> 0 Then

  217             novaregra = New FileSystemAccessRule(far.IdentityReference, r, InheritanceFlags.ContainerInherit Or InheritanceFlags.ObjectInherit, PropagationFlags.None, AccessControlType.Allow)

  218 

  219 

  220         End If

  221         If r2 <> 0 Then

  222             novaregra2 = New FileSystemAccessRule(far.IdentityReference, r2, InheritanceFlags.ContainerInherit Or InheritanceFlags.ObjectInherit, PropagationFlags.None, AccessControlType.Deny)

  223 

  224 

  225         End If

  226 

  227         Alterar(novaregra, novaregra2)

  228 

  229     End Sub

Agora fica mais claro o conjunto de parâmetros que inserimos no Delegate, dois parâmetros do tipo FileSystemAccessRule, um de aceitação e outro de negação, mas na verdade a ordem dois dois não importará absolutamente nada para o processamento.

Para completar, vejamos como fica a sub GravarAlteracoes no form 1 :

  231     Public Sub GravarAtualizacao(ByVal Permissao As FileSystemAccessRule, ByVal Negacao As FileSystemAccessRule)

  232 

  233 

  234         If Not Permissao Is Nothing Then

  235             acl.SetAccessRule(Permissao)

  236         End If

  237         If Not Negacao Is Nothing Then

  238             acl.SetAccessRule(Negacao)

  239         End If

  240 

  241         di.SetAccessControl(acl)

  242 

  243         exibirACLs()

  244     End Sub

Observe os IFs cercando as instruções SetAccessRule. Qualquer dos dois parâmetros poderia estar em branco, Nothing. Os IFs são uma segurança contra isso. Observe que o SetAccessRule é aplicado sobre a classe DirectorySecurity, enquanto que o SetAccessControl é aplicado sobre a classe DirectoryInfo.

Com esta aplicação temos então um exemplo de manipulação da ACL com o sistema de arquivos. Observe os seguintes pontos :

1) Fizemos uma exibição detalhada das permissões, mas poderiamos ter feito diferente. Observe o sistema operacional, temos nele 2 exibições, básica e avançada. O que construimos se assemelha a opção avançada, na opção básica as permissões são agregadas em itens mais simples, mais compreensíveis ao usuário, é necessário um algorítimo para essa agregação.

2) Não lidei com a parte de propagação das permissões, utilizei valores fixos. É possível também manipular a auditoria.

3) Não inseri na aplicação a possibilidade de adicionar permissões a outros usuários que ainda não tivessem permissão alguma na pasta. Isso pode ser feito com uso das classes em System.DirectoryServices



Envie seus comentários sobre este artigo

Nome :

E-mail :

Comentários :


Avise-me quando houverem novos comentários nesta página

Veja abaixo os comentários já enviados :

Nome : -1' E-Mail : 1
1
Nome : Art E-Mail : sherwebcs@gmail.com
Test from website by Art - SherWeb
Nome : Art E-Mail : sherwebcs@gmail.com
Test 2
Nome : Art E-Mail : sherwebcs@gmail.com
Test Art
Nome : a E-Mail :
Nome : Art E-Mail : sherwebcs@gmail.com
Test
Nome : Art E-Mail : sherwebcs@gmail.com
Test again
Nome : Art E-Mail : bobkwikwi@hotmail.com
test
Nome : Art E-Mail : sherwebcs@gmail.com
test
Nome : Art E-Mail : sherwebcs@gmail.com
test
Nome : dennes E-Mail : dennes@bufaloinfo.com.br
teste
Nome : Dennes E-Mail : dennes@bufaloinfo.com.br
test
Nome : Dennes E-Mail : dennestorres@gmail.com
teste