Example #1
0
        public StringCollection GetPermissions(string userName, IntPtr userToken,
                                               SecurityItemType itemType, byte[] secDesc)
        {
            EventLog.WriteEntry("SSRS-AZ", "GetPermissions", EventLogEntryType.Information);

            return(m_fullPermissions);
        }
Example #2
0
 public byte[] CreateSecurityDescriptor(
     AceCollection acl,
     SecurityItemType itemType,
     out string stringSecDesc)
 {
     stringSecDesc = null;
     EventLog.WriteEntry("SSRS-AZ", "CreateSecurityDescriptor", EventLogEntryType.Information);
     return(null);
 }
Example #3
0
        public StringCollection GetPermissions(string userName, IntPtr userToken,


                                               SecurityItemType itemType, byte[] secDesc)


        {
            return(m_fullPermissions);
        }
Example #4
0
        public byte[] CreateSecurityDescriptor(AceCollection acl, SecurityItemType itemType, out string stringSecDesc)
        {
            BinaryFormatter binaryFormatter = new BinaryFormatter();
            MemoryStream    result          = new MemoryStream();

            binaryFormatter.Serialize(result, acl);
            stringSecDesc = null;
            return(result.GetBuffer());
        }
Example #5
0
 public void AddItem(UserId userId, SecurityItemType type, string displayName, string value)
 {
     Items[userId.Id] = new SecurityItem
         {
             Display = displayName,
             Type = type,
             Value = value,
             UserId = userId.Id
         };
 }
Example #6
0
 public void AddItem(UserId userId, SecurityItemType type, string displayName, string value)
 {
     Items[userId.Id] = new SecurityItem
     {
         Display = displayName,
         Type    = type,
         Value   = value,
         UserId  = userId.Id
     };
 }
        public byte[] CreateSecurityDescriptor(AceCollection acl, SecurityItemType itemType, out string stringSecDesc)
        {
            // Creates a memory stream and serializes the ACL for storage.
            BinaryFormatter bf = new BinaryFormatter();

            using (MemoryStream result = new MemoryStream()) {
                bf.Serialize(result, acl);
                stringSecDesc = null;
                return(result.GetBuffer());
            }
        }
Example #8
0
 public StringCollection GetPermissions(string userName, IntPtr userToken, SecurityItemType itemType, byte[] secDesc)
 {
     if (usernames.Split(',').ToList().Contains(userName))
     {
         return(CreateAdminPermissionSet());
     }
     else
     {
         return(CreateUserPermissionSet(userName, secDesc));
     }
 }
Example #9
0
        public byte[] CreateSecurityDescriptor(


            AceCollection acl,


            SecurityItemType itemType,


            out string stringSecDesc)


        {
            stringSecDesc = null;


            return(null);
        }
        public StringCollection GetPermissions(string userName, IntPtr userToken,
         SecurityItemType itemType, byte[] secDesc)
        {
            StringCollection permissions = new StringCollection();
             if (0 == String.Compare(userName, m_adminUserName, true,
               CultureInfo.CurrentCulture))
             {
             foreach (CatalogOperation oper in m_CatOperNames.Keys)
             {
                 if (!permissions.Contains((string)m_CatOperNames[oper]))
                     permissions.Add((string)m_CatOperNames[oper]);
             }
            foreach(ModelItemOperation oper in m_ModelItemOperNames.Keys)
            {
              if (!permissions.Contains((string)m_ModelItemOperNames[oper]))
                permissions.Add((string)m_ModelItemOperNames[oper]);
            }
            foreach(ModelOperation oper in m_ModelOperNames.Keys)
            {
              if (!permissions.Contains((string)m_ModelOperNames[oper]))
                permissions.Add((string)m_ModelOperNames[oper]);
            }
            foreach(CatalogOperation oper in m_CatOperNames.Keys)
            {
               if (!permissions.Contains((string)m_CatOperNames[oper]))
                  permissions.Add((string)m_CatOperNames[oper]);
            }
            foreach(ReportOperation oper in m_RptOperNames.Keys)
            {
               if (!permissions.Contains((string)m_RptOperNames[oper]))
                  permissions.Add((string)m_RptOperNames[oper]);
            }
            foreach(FolderOperation oper in m_FldOperNames.Keys)
            {
               if (!permissions.Contains((string)m_FldOperNames[oper]))
                  permissions.Add((string)m_FldOperNames[oper]);
            }
            foreach(ResourceOperation oper in m_ResOperNames.Keys)
            {
               if (!permissions.Contains((string)m_ResOperNames[oper]))
                  permissions.Add((string)m_ResOperNames[oper]);
            }
            foreach(DatasourceOperation oper in m_DSOperNames.Keys)
            {
               if (!permissions.Contains((string)m_DSOperNames[oper]))
                  permissions.Add((string)m_DSOperNames[oper]);
            }
             }
             else
             {
            AceCollection acl = DeserializeAcl(secDesc);
            foreach(AceStruct ace in acl)
            {
               if (0 == String.Compare(userName, ace.PrincipalName, true,
                     CultureInfo.CurrentCulture))
               {
                  foreach(ModelItemOperation aclOperation in ace.ModelItemOperations)
                  {
                     if (!permissions.Contains((string)m_ModelItemOperNames[aclOperation]))
                       permissions.Add((string)m_ModelItemOperNames[aclOperation]);
                  }
                  foreach(ModelOperation aclOperation in ace.ModelOperations)
                  {
                     if (!permissions.Contains((string)m_ModelOperNames[aclOperation]))
                       permissions.Add((string)m_ModelOperNames[aclOperation]);
                  }
                  foreach(CatalogOperation aclOperation in
                     ace.CatalogOperations)
                  {
                     if (!permissions.Contains((string)m_CatOperNames[aclOperation]))
                        permissions.Add((string)m_CatOperNames[aclOperation]);
                  }
                  foreach(ReportOperation aclOperation in ace.ReportOperations)
                  {
                     if (!permissions.Contains((string)m_RptOperNames[aclOperation]))
                        permissions.Add((string)m_RptOperNames[aclOperation]);
                  }
                  foreach(FolderOperation aclOperation in ace.FolderOperations)
                  {
                     if (!permissions.Contains((string)m_FldOperNames[aclOperation]))
                        permissions.Add((string)m_FldOperNames[aclOperation]);
                  }
                  foreach(ResourceOperation aclOperation in ace.ResourceOperations)
                  {
                     if (!permissions.Contains((string)m_ResOperNames[aclOperation]))
                        permissions.Add((string)m_ResOperNames[aclOperation]);
                  }
                  foreach(DatasourceOperation aclOperation in ace.DatasourceOperations)
                  {
                     if (!permissions.Contains((string)m_DSOperNames[aclOperation]))
                        permissions.Add((string)m_DSOperNames[aclOperation]);
                  }
               }
            }
             }

             return permissions;
        }
 public byte[] CreateSecurityDescriptor(
     AceCollection acl,
     SecurityItemType itemType,
     out string stringSecDesc)
 {
     stringSecDesc = null;
     return null;
 }
        public StringCollection GetPermissions(string userName, IntPtr userToken, SecurityItemType itemType, byte[] secDesc)
        {
            StringCollection permissions = new StringCollection();

            if (0 == String.Compare(userName, m_adminUserName, true,
                                    CultureInfo.CurrentCulture))
            {
                foreach (CatalogOperation oper in m_CatOperNames.Keys)
                {
                    if (!permissions.Contains((string)m_CatOperNames[oper]))
                    {
                        permissions.Add((string)m_CatOperNames[oper]);
                    }
                }
                foreach (ModelItemOperation oper in m_ModelItemOperNames.Keys)
                {
                    if (!permissions.Contains((string)m_ModelItemOperNames[oper]))
                    {
                        permissions.Add((string)m_ModelItemOperNames[oper]);
                    }
                }
                foreach (ModelOperation oper in m_ModelOperNames.Keys)
                {
                    if (!permissions.Contains((string)m_ModelOperNames[oper]))
                    {
                        permissions.Add((string)m_ModelOperNames[oper]);
                    }
                }
                foreach (CatalogOperation oper in m_CatOperNames.Keys)
                {
                    if (!permissions.Contains((string)m_CatOperNames[oper]))
                    {
                        permissions.Add((string)m_CatOperNames[oper]);
                    }
                }
                foreach (ReportOperation oper in m_RptOperNames.Keys)
                {
                    if (!permissions.Contains((string)m_RptOperNames[oper]))
                    {
                        permissions.Add((string)m_RptOperNames[oper]);
                    }
                }
                foreach (FolderOperation oper in m_FldOperNames.Keys)
                {
                    if (!permissions.Contains((string)m_FldOperNames[oper]))
                    {
                        permissions.Add((string)m_FldOperNames[oper]);
                    }
                }
                foreach (ResourceOperation oper in m_ResOperNames.Keys)
                {
                    if (!permissions.Contains((string)m_ResOperNames[oper]))
                    {
                        permissions.Add((string)m_ResOperNames[oper]);
                    }
                }
                foreach (DatasourceOperation oper in m_DSOperNames.Keys)
                {
                    if (!permissions.Contains((string)m_DSOperNames[oper]))
                    {
                        permissions.Add((string)m_DSOperNames[oper]);
                    }
                }
            }
            else
            {
                AceCollection acl = DeserializeAcl(secDesc);
                foreach (AceStruct ace in acl)
                {
                    if (0 == String.Compare(userName, ace.PrincipalName, true,
                                            CultureInfo.CurrentCulture))
                    {
                        foreach (ModelItemOperation aclOperation in ace.ModelItemOperations)
                        {
                            if (!permissions.Contains((string)m_ModelItemOperNames[aclOperation]))
                            {
                                permissions.Add((string)m_ModelItemOperNames[aclOperation]);
                            }
                        }
                        foreach (ModelOperation aclOperation in ace.ModelOperations)
                        {
                            if (!permissions.Contains((string)m_ModelOperNames[aclOperation]))
                            {
                                permissions.Add((string)m_ModelOperNames[aclOperation]);
                            }
                        }
                        foreach (CatalogOperation aclOperation in
                                 ace.CatalogOperations)
                        {
                            if (!permissions.Contains((string)m_CatOperNames[aclOperation]))
                            {
                                permissions.Add((string)m_CatOperNames[aclOperation]);
                            }
                        }
                        foreach (ReportOperation aclOperation in ace.ReportOperations)
                        {
                            if (!permissions.Contains((string)m_RptOperNames[aclOperation]))
                            {
                                permissions.Add((string)m_RptOperNames[aclOperation]);
                            }
                        }
                        foreach (FolderOperation aclOperation in ace.FolderOperations)
                        {
                            if (!permissions.Contains((string)m_FldOperNames[aclOperation]))
                            {
                                permissions.Add((string)m_FldOperNames[aclOperation]);
                            }
                        }
                        foreach (ResourceOperation aclOperation in ace.ResourceOperations)
                        {
                            if (!permissions.Contains((string)m_ResOperNames[aclOperation]))
                            {
                                permissions.Add((string)m_ResOperNames[aclOperation]);
                            }
                        }
                        foreach (DatasourceOperation aclOperation in ace.DatasourceOperations)
                        {
                            if (!permissions.Contains((string)m_DSOperNames[aclOperation]))
                            {
                                permissions.Add((string)m_DSOperNames[aclOperation]);
                            }
                        }
                    }
                }
            }

            return(permissions);
        }
Example #13
0
 public User(string lookup, SecurityItemType kind)
 {
     Lookup = lookup;
     Kind = kind;
 }
Example #14
0
 public User(string lookup, SecurityItemType kind)
 {
     Lookup = lookup;
     Kind   = kind;
 }
Example #15
0
        public StringCollection GetPermissions(string userName, IntPtr userToken,
                                               SecurityItemType itemType, byte[] secDesc)
        {
            StringCollection permissions = new StringCollection();

            if (IsAdmin(userName))
            {
                permissions.AddRange(_fullPermissions.ToArray());
            }
            else if (IsReportViewer(userName))
            {
                //permissions.AddRange(_fullPermissions.ToArray());
            }
            else
            {
                AceCollection acl = DeserializeAcl(secDesc);
                foreach (AceStruct ace in acl)
                {
                    if (0 == String.Compare(userName, ace.PrincipalName, true,
                                            CultureInfo.CurrentCulture))
                    {
                        foreach (ModelItemOperation aclOperation in ace.ModelItemOperations)
                        {
                            if (!permissions.Contains(_modelItemOperNames[aclOperation]))
                            {
                                permissions.Add(_modelItemOperNames[aclOperation]);
                            }
                        }
                        foreach (ModelOperation aclOperation in ace.ModelOperations)
                        {
                            if (!permissions.Contains(_modelOperNames[aclOperation]))
                            {
                                permissions.Add(_modelOperNames[aclOperation]);
                            }
                        }
                        foreach (CatalogOperation aclOperation in ace.CatalogOperations)
                        {
                            if (!permissions.Contains(_catalogOperationNames[aclOperation]))
                            {
                                permissions.Add(_catalogOperationNames[aclOperation]);
                            }
                        }
                        foreach (ReportOperation aclOperation in ace.ReportOperations)
                        {
                            if (!permissions.Contains(_reportOperationNames[aclOperation]))
                            {
                                permissions.Add(_reportOperationNames[aclOperation]);
                            }
                        }
                        foreach (FolderOperation aclOperation in ace.FolderOperations)
                        {
                            if (!permissions.Contains(_folderOperationNames[aclOperation]))
                            {
                                permissions.Add(_folderOperationNames[aclOperation]);
                            }
                        }
                        foreach (ResourceOperation aclOperation in ace.ResourceOperations)
                        {
                            if (!permissions.Contains(_resourceOperationNames[aclOperation]))
                            {
                                permissions.Add(_resourceOperationNames[aclOperation]);
                            }
                        }
                        foreach (DatasourceOperation aclOperation in ace.DatasourceOperations)
                        {
                            if (!permissions.Contains(_dataSourceOperationNames[aclOperation]))
                            {
                                permissions.Add(_dataSourceOperationNames[aclOperation]);
                            }
                        }
                    }
                }
            }

            return(permissions);
        }
Example #16
0
        public StringCollection GetPermissions(string userName, IntPtr userToken, SecurityItemType itemType, byte[] secDesc)
        {
            StringCollection permissions = new StringCollection();

            //Check Overrides
            if (IsSecurityOverride(userName))
            {
                permissions.AddRange(_catalogOperationNames.Select(t => t.Value).Distinct().ToArray());
                permissions.AddRange(_reportOperationNames.Select(t => t.Value).Distinct().ToArray());
                permissions.AddRange(_folderOperationNames.Select(t => t.Value).Distinct().ToArray());
                permissions.AddRange(_resourceOperationNames.Select(t => t.Value).Distinct().ToArray());
                permissions.AddRange(_datasetOperationNames.Select(t => t.Value).Distinct().ToArray());
                permissions.AddRange(_modelOperationNames.Select(t => t.Value).Distinct().ToArray());
                permissions.AddRange(_modelItemOperationNames.Select(t => t.Value).Distinct().ToArray());
            }
            else
            {
                AceCollection acl = DeserializeAcl(secDesc);
                foreach (AceStruct ace in acl)
                {
                    if (ValidateACLPrincipal(ace.PrincipalName, userName))
                    {
                        foreach (CatalogOperation aclOperation in ace.CatalogOperations)
                        {
                            if (!permissions.Contains((string)_catalogOperationNames[aclOperation]))
                            {
                                permissions.Add((string)_catalogOperationNames[aclOperation]);
                            }
                        }
                        foreach (ReportOperation aclOperation in ace.ReportOperations)
                        {
                            if (!permissions.Contains((string)_reportOperationNames[aclOperation]))
                            {
                                permissions.Add((string)_reportOperationNames[aclOperation]);
                            }
                        }
                        foreach (FolderOperation aclOperation in ace.FolderOperations)
                        {
                            if (!permissions.Contains((string)_folderOperationNames[aclOperation]))
                            {
                                permissions.Add((string)_folderOperationNames[aclOperation]);
                            }
                        }
                        foreach (ResourceOperation aclOperation in ace.ResourceOperations)
                        {
                            if (!permissions.Contains((string)_resourceOperationNames[aclOperation]))
                            {
                                permissions.Add((string)_resourceOperationNames[aclOperation]);
                            }
                        }
                        foreach (DatasourceOperation aclOperation in ace.DatasourceOperations)
                        {
                            if (!permissions.Contains((string)_datasetOperationNames[aclOperation]))
                            {
                                permissions.Add((string)_datasetOperationNames[aclOperation]);
                            }
                        }
                        foreach (ModelOperation aclOperation in ace.ModelOperations)
                        {
                            if (!permissions.Contains((string)_modelOperationNames[aclOperation]))
                            {
                                permissions.Add((string)_modelOperationNames[aclOperation]);
                            }
                        }
                        foreach (ModelItemOperation aclOperation in ace.ModelItemOperations)
                        {
                            if (!permissions.Contains((string)_modelItemOperationNames[aclOperation]))
                            {
                                permissions.Add((string)_modelItemOperationNames[aclOperation]);
                            }
                        }
                    }
                }
            }
            return(permissions);
        }
 public byte[] CreateSecurityDescriptor(
  AceCollection acl, 
  SecurityItemType itemType, 
  out string stringSecDesc)
 {
     // Creates a memory stream and serializes the ACL for storage.
      BinaryFormatter bf = new BinaryFormatter();
      using (MemoryStream result = new MemoryStream())
      {
      bf.Serialize(result, acl);
      stringSecDesc = null;
      return result.GetBuffer();
      }
 }
Example #18
0
        public StringCollection GetPermissions(string userName, IntPtr userToken, SecurityItemType itemType, byte[] secDesc)
        {
            StringCollection permissions = new StringCollection();

            if (HasUnRestrictedAccess(userName))
            {
                foreach (CatalogOperation oper in m_CatOperNames.Keys)
                {
                    if (!permissions.Contains((string)m_CatOperNames[oper]))
                    {
                        permissions.Add((string)m_CatOperNames[oper]);
                    }
                }
                foreach (ModelItemOperation oper in m_ModelItemOperNames.Keys)
                {
                    if (!permissions.Contains((string)m_ModelItemOperNames[oper]))
                    {
                        permissions.Add((string)m_ModelItemOperNames[oper]);
                    }
                }
                foreach (ModelOperation oper in m_ModelOperNames.Keys)
                {
                    if (!permissions.Contains((string)m_ModelOperNames[oper]))
                    {
                        permissions.Add((string)m_ModelOperNames[oper]);
                    }
                }
                foreach (CatalogOperation oper in m_CatOperNames.Keys)
                {
                    if (!permissions.Contains((string)m_CatOperNames[oper]))
                    {
                        permissions.Add((string)m_CatOperNames[oper]);
                    }
                }
                foreach (ReportOperation oper in m_RptOperNames.Keys)
                {
                    if (!permissions.Contains((string)m_RptOperNames[oper]))
                    {
                        permissions.Add((string)m_RptOperNames[oper]);
                    }
                }
                foreach (FolderOperation oper in m_FldOperNames.Keys)
                {
                    if (!permissions.Contains((string)m_FldOperNames[oper]))
                    {
                        permissions.Add((string)m_FldOperNames[oper]);
                    }
                }
                foreach (ResourceOperation oper in m_ResOperNames.Keys)
                {
                    if (!permissions.Contains((string)m_ResOperNames[oper]))
                    {
                        permissions.Add((string)m_ResOperNames[oper]);
                    }
                }
                foreach (DatasourceOperation oper in m_DSOperNames.Keys)
                {
                    if (!permissions.Contains((string)m_DSOperNames[oper]))
                    {
                        permissions.Add((string)m_DSOperNames[oper]);
                    }
                }
            }
            else
            {
                AceCollection acl = DeserializeAcl(secDesc);
                foreach (AceStruct ace in acl)
                {
                    if (UserMatchesPrincipal(ace.PrincipalName, userToken))
                    {
                        foreach (ModelItemOperation aclOperation in ace.ModelItemOperations)
                        {
                            if (!permissions.Contains((string)m_ModelItemOperNames[aclOperation]))
                            {
                                permissions.Add((string)m_ModelItemOperNames[aclOperation]);
                            }
                        }
                        foreach (ModelOperation aclOperation in ace.ModelOperations)
                        {
                            if (!permissions.Contains((string)m_ModelOperNames[aclOperation]))
                            {
                                permissions.Add((string)m_ModelOperNames[aclOperation]);
                            }
                        }
                        foreach (CatalogOperation aclOperation in
                                 ace.CatalogOperations)
                        {
                            if (!permissions.Contains((string)m_CatOperNames[aclOperation]))
                            {
                                permissions.Add((string)m_CatOperNames[aclOperation]);
                            }
                        }
                        foreach (ReportOperation aclOperation in ace.ReportOperations)
                        {
                            if (!permissions.Contains((string)m_RptOperNames[aclOperation]))
                            {
                                permissions.Add((string)m_RptOperNames[aclOperation]);
                            }
                        }
                        foreach (FolderOperation aclOperation in ace.FolderOperations)
                        {
                            if (!permissions.Contains((string)m_FldOperNames[aclOperation]))
                            {
                                permissions.Add((string)m_FldOperNames[aclOperation]);
                            }
                        }
                        foreach (ResourceOperation aclOperation in ace.ResourceOperations)
                        {
                            if (!permissions.Contains((string)m_ResOperNames[aclOperation]))
                            {
                                permissions.Add((string)m_ResOperNames[aclOperation]);
                            }
                        }
                        foreach (DatasourceOperation aclOperation in ace.DatasourceOperations)
                        {
                            if (!permissions.Contains((string)m_DSOperNames[aclOperation]))
                            {
                                permissions.Add((string)m_DSOperNames[aclOperation]);
                            }
                        }
                    }
                }
            }

            return(permissions);
        }
 public StringCollection GetPermissions(string userName, IntPtr userToken,
  SecurityItemType itemType, byte[] secDesc)
 {
     return m_fullPermissions;
 }