Microsegment.ru
  • Главная страница
  • О проекте
  • Портфолио
  • Блог
Системы

Анализ правил доступа в Tessa

Анализ правил доступа в Tessa
Системы

Если в Tessa объект «роль — условия — разрешения — объект» является квантом модели предоставления прав, то правило доступа должно быть логичным кластером подобных квантовых объектов. Далее предпринята попытка анализа подобных кластеров.

Загрузка библиотек¶

In [4]:
import pandas as pd
import numpy as np

Выгрузка данных из БД Tessa¶

-- Все правила доступа с русским переводом параметров
SELECT  kp.ID AS [ID npasmna AocTyna],
        kp.Caption AS [Ha3BaHne npaBuna AocTyna],
        CASE WHEN kp.IsDisabled ='1' THEN 'True' ELSE 'False' END AS [Правило отключено],
        CASE WHEN kp.IsRequired ='1' THEN 'True' ELSE 'False' END AS [Всегда проверять правило],
        CASE WHEN kp.IsExtended ='1' THEN 'True'ELSE 'False' END AS [РПД],
        CASE WHEN kp.Conditions LIKE '%ConditionTypeID%' THEN 'True' ELSE 'False' END AS [Типы условий],
        -- Разрешения из правил доступа
        CASE WHEN kp.CanCreateCard ='1' THEN 'True' ELSE 'False' END AS [Создание карточки],
        CASE WHEN kp.CanReadCard ='1' THEN 'True' ELSE 'False' END AS [Чтение карточки],
        CASE WHEN kp.CanEditCard ='1' THEN 'True' ELSE 'False' END AS [Редактирование карточки]]
        CASE WHEN kp.CanEditFiles ='1' THEN 'True' ELSE 'False' END AS [Редактирование файлов],
        CASE WHEN kp.CanAddFiles ='1' THEN 'True' ELSE 'False' END AS [Добавление файлов],
        CASE WHEN kp.CanEditRoute ='1' THEN 'True' ELSE 'False' END AS [Редактирование маршрута],
        CASE WHEN kp.CanDeleteCard ='1' THEN 'True' ELSE 'False' END AS [Удаление карточки],
        CASE WHEN kp.CanStartProcess ='1' THEN 'True' ELSE 'False' END AS [Инициация типового процесса отправки задач],
        CASE WHEN kp.CanEditNumber ='1' THEN 'True' ELSE 'False' END AS [Ручное редактирование номера],
        CASE WHEN kp.CanCreateResolutions ='1' THEN 'True' ELSE 'False' END AS [Создание резолюций],
        CASE WHEN kp.CanDeleteFiles ='1' THEN 'True' ELSE 'False' END AS [Удаление всех файлов],
        CASE WHEN kp.CanEditOwnFiles ='1' THEN 'True' ELSE 'False' END AS [Редактирование собственных файлов].
        CASE WHEN kp.CanDeleteownFiles ='1' THEN 'True'ELSE 'False' END AS [Удаление собственных файлов],
        CASE WHEN kp.CansignFiles ='1' THEN 'True' ELSE 'False' END AS [Подписание файлов],
        CASE WHEN kp.CanAddTopics ='1' THEN 'True'ELSE 'False'END AS [Создание обсуждений].
        CASE WHEN kp.CanSuperModeratorMode ='1' THEN 'True'ELSE 'False' END AS [Права супермодератора],
        CASE WHEN kp.CanSubscribeForNotifications = '1' THEN 'True' ELSE 'False' END AS [Подписка на уведомления],
        CASE WHEN kp.CanCreateTemplateAndCopy ='1' THEN 'True' ELSE 'False' END AS [Создание шаблона и копирование],
        CASE WHEN kp.CanSkipStages ='1' THEN 'True' ELSE 'False' END AS [Пропуск этапов],
        CASE WHEN kp.CanFullRecalcRoute ='1' THEN 'True' ELSE 'False' END AS [Полный пересчет маршрута].
        CASE WHEN kp.CanEditMyMessages ='1' THEN 'True' ELSE 'False' END AS [Редактирование своих сообщений],
        CASE WHEN kp.CanEditAllMessages ='1' THEN 'True' ELSE 'False' END AS [Редактирование всех сообщений],
        CASE WHEN kp.CanReadAllTopics ='1' THEN 'True' ELSE 'False' END AS [Чтение обсуждений],
        CASE WHEN kp.CanReadAndSendMessageInAllTopics ='1' THEN 'True' ELSE 'False' END AS [Чтение и отправка сообщений]
FROM KrPermissions (NOLOCK) kp;

-- Обогащение правил доступа дополнительными данными о ролях
SELECT DISTINCT
    -- Правила доступа
    kpr.ID AS [ID правила доступа],
    -- Роли
    kpr.RoleID AS [ID роли],
    kpr.RoleName AS [Название роли]
FROM krPermissionRoles (NOLOCK) kpr;

-- Обогащение правил доступа дополнительными данными о типах документов
SELECT DISTINCT
    -- Правила доступа
    kpt.ID AS [ID правила доступа],
    -- Тип карточки
    kpt.TypeCaption AS [ID ЛФО типа карточки]
    dbo.Localize(kpt.TypeCaption, 25) AS [Тип карточки]
FROM KrPermissionTypes (NOLOCK) kpt;

-- Обогащение правил доступа дополнительными данными о состояниях документов
SELECT DISTINCT
    -- Правила доступа
    kpt.ID AS [ID правила доступа],
    -- Состояние карточки
    kps.StateName AS [ID ЛФО состояния карточки]
    dbo.Localize(kps.StateName, 25) AS [Состояние карточки]
FROM KrPermissionstates (NOLOCK) kps

-- Расширенные правила доступа (РПД)
SELECT
DISTINCT
    -- Правила доступа
    kp.ID AS [ID правила доступа],
    -- Параметры РПД
    kpecr.SectionName AS [РПД. Секция карточки].
    kpecrf.FieldName AS [РПД. Поле карточки],
    kpecr. AccessSettingName AS [РПД. Разрешение],
    dbo.Localize(kpecr.AccesssettingName, 25) AS [РПД. Разрешение (рус)]
FROM KrPermissions AS kp
LEFT JOIN KrPermissionExtendedcardRules (NOLOCK) kpecr ON kpecr.ID = kp. ID
LEFT JOIN KrPermissionExtendedcardRulefields (NOLOCK) kpecrf ON kpecrf. ID = kp.ID;

-- Вхождение PersonalRoles в любые Roles, кроме ContextRoles
SELECT  pr.ID AS [ID пользователя]，
        pr.Name AS [Имя пользователя]，
        pr.Position AS [Должность пользователя], 
        pr.AccessLevelID AS [Уровень доступа пользователя], 
        pr.LoginTypeID AS [Тип учетной записи пользователя], 
        pr.Login AS [Логин пользователя]，
        CASE WHEN pr.Blocked ='1' THEN 'True' END AS [Блокировка учетной записи пользователя], 
        r.ID AS [ID роли], 
        r.Name AS [Название роли], 
        r.TypeID AS [Тип роли]
FROM Roles (NOLOCK)r
LEFT JOIN RoleUsers (NOLOCK) ru ON ru.ID = r.ID
LEFT JOIN PersonalRoles (NOLOCK) pr ON pr.ID - ru.UserID
WHERE (ru. IsDeputy = O OR ru.IsDeputy IS NULL)
ORDER BY pr.Name, r.Name;

-- ContextRoles
SELECT cr.ID AS [ID роли],
        cr.SqlText AS [Код SQL]
FROM ContextRoles (NOLOCK) cr;
-- Для выявления вхождения идентификаторов ролей в коды контекстных ролей
-- (очень долгая операция, лучше реализовать локально на Python)
--LEFT JOIN Roles (NOLOCK) r ON cr.SqlText LIKE '%'+CONVERT(VARCHAR(50), .ID)+'%'

Загрузка данных¶

In [ ]:
# Данные из таблицы KrPermissions, предварительно выгруженные из БД Tessa
KrPermissions = pd.read.csv('KrPermissions.csv', sep=';')#, encoding='utf-8-sig')

print(KrPermissions.info())
KrPermissions.head(5)
In [ ]:
# Данные из таблицы KrPermissionRoles, предварительно выгруженные из БД Tessa
KrPermissionRoles = pd.read.csv('KrPermissionRoles.csv', sep=';')#, encoding='utf-8-sig')

print(KrPermissionRoles.info())
KrPermissionRoles.head(5)
In [ ]:
# Данные из таблицы KrPermissionTypes, предварительно выгруженные из БД Tessa
KrPermissionTypes = pd.read.csv('KrPermissionTypes.csv', sep=';')#, encoding='utf-8-sig')

print(KrPermissionTypes.info())
KrPermissionTypes.head(5)
In [ ]:
# Данные из таблицы KrPermissionStates, предварительно выгруженные из БД Tessa
KrPermissionStates = pd.read.csv('KrPermissionStates.csv', sep=';')#, encoding='utf-8-sig')

print(KrPermissionStates.info())
KrPermissionStates.head(5)
In [ ]:
# Данные из таблицы KrPermissionCardRules, предварительно выгруженные из БД Tessa
KrPermissionCardRules = pd.read.csv('KrPermissionCardRules.csv', sep=';')#, encoding='utf-8-sig')

print(KrPermissionCardRules.info())
KrPermissionCardRules.head(5)
In [ ]:
# Данные из таблицы RoleUsers, предварительно выгруженные из БД Tessa
RoleUsers = pd.read.csv('RoleUsers.csv', sep=';')#, encoding='utf-8-sig')

print(RoleUsers.info())
RoleUsers.head(5)
In [ ]:
# Данные из таблицы ContextRoles, предварительно выгруженные из БД Tessa
ContextRoles = pd.read.csv('ContextRoles.csv', sep=';')#, encoding='utf-8-sig')

print(ContextRoles.info())
ContextRoles.head(5)

Предобработка данных¶

Перемещение дополнительной информации из датафреймов с правилами в отдельные датафреймы¶

In [ ]:
# Перемещение данных о правилах доступа в отдельный датафрейм 
rules_data = KrPermissions[['ID правила доступа', 'Название правила доступа', 
                            'Правило отключено', 'Всегда проверять правило', 
                            'РПД', 'Типы условий']]\
.groupby(['ID правила доступа', 'Название правила доступа', 
          'Правило отключено', 'Всегда проверять правило', 
          'РПД', 'Типы условий']).count().reset_index()
KrPermissions = KrPermissions.drop(['Название правила доступа', 
                                    'Правило отключено', 'Всегда проверять правило', 
                                    'РПД', 'Типы условий'], axis=1)

print(rules_data.info())
rules_data.head(5)
In [ ]:
# Перемещение названий ролей из правил доступа в отдельный датафрейм 
roles_name = KrPermissionRoles[['ID роли', 'Название роли']]\
.groupby(['ID роли', 'Название роли']).count().reset_index()
KrPermissionRoles = KrPermissionRoles.drop(['Название роли'], axis=1)

print(rules_data.info())
rules_data.head(5)

Перемещение дополнительной информации из датафреймов с ролями в отдельные датафреймы¶

In [ ]:
# Перемещение данных о правилах доступа в отдельный датафрейм 
user_data = RoleUsers[['ID пользователя', 
                       'Имя пользователя', 
                       'Логин пользователя', 
                       'Должность пользователя', 
                       'Уровень доступа пользователя', 
                       'Тип учетной записи пользователя', 
                       'Блокировка учетной записи пользователя']]\
.groupby(['ID пользователя', 
          'Имя пользователя', 
          'Логин пользователя', 
          'Должность пользователя', 
          'Уровень доступа пользователя', 
          'Тип учетной записи пользователя', 
          'Блокировка учетной записи пользователя'], 
         # Не удалять строки с пропусками
         dropna=False)\
.count().reset_index()
user_data = user_data[~user_data['ID пользователя'].isnull()]
RoleUsers = RoleUsers.drop(['Имя пользователя', 
                            'Логин пользователя', 
                            'Должность пользователя', 
                            'Уровень доступа пользователя', 
                            'Тип учетной записи пользователя', 
                            'Блокировка учетной записи пользователя'], axis=1)

print(user_data.info())
user_data.head(5)
In [ ]:
# Перемещение данных о правилах доступа в отдельный датафрейм 
role_name = RoleUsers[['ID роли', 'Название роли']]\
.groupby(['ID роли', 'Название роли']).count().reset_index()
RoleUsers = RoleUsers.drop(['Название роли'], axis=1)

print(role_name.info())
role_name.head(5)
In [ ]:
# Перемещение данных од известных роляъ в отдельный датафрейм
roles = RoleUsers[RoleUsers['ID роли'] != 'Unknown'].drop_duplicates()

print(roles.info())
roles.head(5)

Кластеризация правил и ролей¶

Правила и роли не дающие прав пользователям¶

In [ ]:
# Связка полной информации о ролях с идентификаторами правил,
# в которых роли используются
rules_roles = pd.merge(KrPermissionRoles, 
                       roles, 
                       on='ID роли', how-'left')

rules_roles = pd.merge(rules_roles, 
                       rules_data[['ID правила доступа', 'Правило отключено']], 
                       on='ID правила доступа', how-'left')

print(rules_roles.info())
rules_roles.head(5)
In [ ]:
# Правила с групповыми ролями, о не контекстными, по которым практически
# не возможно отследить, кому они предоставляют права
rules_not_contextuel_roles = rules_roles[rules_roles['Тип роли'] != 4]

print('-'*5, 'Правила без контекстных ролей', '-'*5)
print(rules_roles.info())
rules_roles.head(5)
In [ ]:
# Предварительный список правил с ролями без пользователей
_rules_without_users = rules_not_contextuel_roles[rules_not_contextuel_roles['ID пользователя'].isnull()]\
sort_values(['ID правила доступа', 'ID роли'])\
.drop(['ID пользователя', 'Должность пользователя', 
       'Уровень доступа пользователя', 'Тип учетной записи пользователя', 
       'Блокировка учетной записи пользователя'], axis=1).drop_duplicates()

# Правила с ролями без пользователей
rules_without_users = pd.merge(_rules_without_users['ID правила доступа']).drop_duplicates(), 
                               rules_data[['ID правила доступа', 'Название правила доступа', 'Правило отключено']], 
                               on='ID правила доступа', how='inner')
rules_without_users.to_csv('clusters/rules_without_users.csv')

print('-'*5, 'Правила с ролями без пользователей', '-'*5)
print(rules_without_users.info())
rules_without_users.head(5)
In [ ]:
# Роли без пользователей в правилах
roles_without_users = pd.merge(_rules_without_users[['ID роли', 'Тип роли']]).drop_duplicates(), 
                               rules_data[['ID роли', 'Название роли']], 
                               on='ID роли', how='left')[['ID роли', 'Название роли', 'Тип роли']]
roles_without_users.to_csv('clusters/rules_without_users.csv')

print('-'*5, 'Роли без пользователей (в правилах)', '-'*5)
print(roles_without_users.info())
roles_without_users.head(5)
In [ ]:
# Предварительный список правил с ролями с пользователями
_rules_with_users = rules_not_contextuel_roles[~rules_not_contextuel_roles['ID пользователя'].isnull()]\
sort_values(['ID правила доступа', 'ID роли'])\
.drop(['ID пользователя', 'Должность пользователя', 
       'Уровень доступа пользователя', 'Тип учетной записи пользователя', 
       'Блокировка учетной записи пользователя'], axis=1).drop_duplicates()

# Правила с ролями с пользователями
rules_with_users = pd.merge(_rules_with_users['ID правила доступа']).drop_duplicates(), 
                               rules_data[['ID правила доступа', 'Название правила доступа', 'Правило отключено']], 
                               on='ID правила доступа', how='inner')
rules_with_users.to_csv('clusters/rules_with_users.csv')

print('-'*5, 'Правила с ролями с пользователями', '-'*5)
print(rules_with_users.info())
rules_with_users.head(5)
In [ ]:
# Роли с пользователями в правилах
roles_with_users = pd.merge(_rules_with_users[['ID роли', 'Тип роли']]).drop_duplicates(), 
                            rules_data[['ID роли', 'Название роли']], 
                            on='ID роли', how='left')[['ID роли', 'Название роли', 'Тип роли']]
roles_with_users.to_csv('clusters/roles_with_users.csv')

print('-'*5, 'Роли с пользователями (в правилах)', '-'*5)
print(roles_with_users.info())
roles_with_users.head(5)

Правила с заблокированными пользователями¶

In [ ]:
# Карточки заблокирванных пользователей
blocked_users = user_data[
    (user_data['Логин пользователя'].isna()) 
    | (user_data['Блокировка учетной записи пользователя'] == 1)
    & ~(user_data['ID пользователя'] == '11111111-1111-1111-1111-111111111111')
][['ID пользователя', 'Имя пользователя']]

# Карточки не заблокированных пользователей
non_blocked_users = user_data[
    ~(user_data['Логин пользователя'].isna()) 
    | ~(user_data['Блокировка учетной записи пользователя'] == 1)
][['ID пользователя', 'Имя пользователя']]

print('-'*5, 'Заблокированные пользователи', '-'*5)
print(blocked_users.info())
display(blocked_users.head(5))

print('-'*5, 'Не заблокированные пользователи', '-'*5)
print(non_blocked_users.info())
display(non_blocked_users.head(5))
In [ ]:
# Правила с заблокированными пользователями
_rules_with_blocked_users = rules_not_contextuel_roles[
    rules_not_contextuel_roles['ID пользователя'].isin(blocked_users['ID пользователя'])
]['ID правила доступа'].drop_duplicates()
rules_with_blocked_users = rules_with_users[rules_with_users['ID правила доступа'].isin(_rules_with_blocked_users)].drop_duplicates()
rules_with_blocked_users.to_csv('clusters/rules_with_blocked_users.csv')

# Правила с не заблокированными пользователями
_rules_with_non_blocked_users = rules_not_contextuel_roles[
    rules_not_contextuel_roles['ID пользователя'].isin(non_blocked_users['ID пользователя'])
]['ID правила доступа'].drop_duplicates()
rules_with_non_blocked_users = rules_with_users[rules_with_users['ID правила доступа'].isin(_rules_with_non_blocked_users)].drop_duplicates()
rules_with_non_blocked_users.to_csv('clusters/rules_with_non_blocked_users.csv')

print('-'*5, 'Правила с заблокированными пользователями', '-'*5)
print(rules_with_blocked_users.info())
display(rules_with_blocked_users.head(5))
print()

print('-'*5, 'Правила с не заблокированными пользователями', '-'*5)
print(rules_with_non_blocked_users.info())
display(rules_with_non_blocked_users.head(5))

Правила с сотрудниками без групповых ролей¶

In [ ]:
# Предварительный список правил с сотрудниками без групповых ролей
_rules_with_users_without_roles = rules_not_contextuel_roles[
    rules_not_contextuel_roles['Тип роли'] == 1 # Тип роли Сотрудник
].sort_values(['ID правила доступа', 'ID роли']).drop(['ID пользователя', 'Должность пользователя', 
       'Уровень доступа пользователя', 'Тип учетной записи пользователя', 
       'Блокировка учетной записи пользователя'], axis=1).drop_duplicates()

# Правила с сотрудниками без групповых ролей
rules_with_users_without_roles = pd.merge(_rules_with_users_without_roles['ID правила доступа'].drop_duplicates(), 
                                          ules_data[['ID правила доступа', 'Название правила доступа', 'Правило отключено']], 
                                          on='ID правила доступа', how='inner')
rules_with_users_without_roles.to_csv('clusters/rules_with_users_without_roles.csv')

# Пользователи без групповых ролей в правилах
roles_with_users_without_roles = pd.merge(_rules_with_users_without_roles[['ID роли', 'Тип роли']].drop_duplicates(), 
                                          roles_name[['ID роли', 'Название роли']], 
                                          on='ID роли', how='left')[['ID роли', 'Название роли', 'Тип роли']]
roles_with_users_without_roles.to_csv('clusters/roles_with_users_without_roles.csv')

print('-'*5, 'Правила с сотрудниками без групповых ролей', '-'*5)
print(rules_with_users_without_roles.info())
display(rules_with_users_without_roles.head(5))
print()

print('-'*5, 'Пользователи без групповых ролей в правилах', '-'*5)
print(roles_with_users_without_roles.info())
display(roles_with_users_without_roles.head(5))

Правила с пользователем System¶

In [ ]:
# Предварительный список правил с пользователем System
_rules_with_system = rules_not_contextuel_roles[
    rules_not_contextuel_roles['ID пользователя'] == '11111111-1111-1111-1111-111111111111' # Пользователь System
].sort_values(['ID правила доступа', 'ID роли']).drop(['ID пользователя', 'Должность пользователя', 
       'Уровень доступа пользователя', 'Тип учетной записи пользователя', 
       'Блокировка учетной записи пользователя'], axis=1).drop_duplicates()

# Правила с пользователем System
rules_with_system = pd.merge(_rules_with_system['ID правила доступа'].drop_duplicates(), 
                             rules_data[['ID правила доступа', 'Название правила доступа', 'Правило отключено']], 
                             on='ID правила доступа', how='inner')
rules_with_system.to_csv('clusters/rules_with_system.csv')

# Роли с пользователем System
roles_with_system = pd.merge(_rules_with_system[['ID роли', 'Тип роли']].drop_duplicates(), 
                             roles_name[['ID роли', 'Название роли']], 
                             on='ID роли', how='left')[['ID роли', 'Название роли', 'Тип роли']]
roles_with_system.to_csv('clusters/roles_with_users_without_roles.csv')

print('-'*5, 'Правила с пользователем System', '-'*5)
print(rules_with_system.info())
display(rules_with_system.head(5))
print()

print('-'*5, 'Роли с пользователем System', '-'*5)
print(roles_with_system.info())
display(roles_with_system.head(5))

Правила с системными ролями¶

In [ ]:
# Предварительный список правил с системными пользователями
_rules_with_systems_roles = rules_not_contextual_roles[rules_not_contextual_roles['ID пользователя'].isin([
    #'11111111-1111-1111-1111-111111111111', #'System'
    '00000000-0000-0000-0000-000000000002', # 'Бухгалтерские сервисы'
    '00000000-0000-0000-0000-000000000003', # 'ИТ-сервисы'
    '00000000-0000-0000-0000-000000000004', # 'Сайт компании'
    '00000000-0000-0000-0000-000000000005', # 'Робот службы безопасности'
    '00000000-0000-0000-0000-000000000006', # 'Робот финансовой службы'
    '00000000-0000-0000-0000-000000000007'  # 'Юридические сервисы'
])].sort_values([
    'ID правила доступа',
    'ID роли'
]).drop(['ID пользователя', 
         'Должность пользователя', 
         'Уровень доступа пользователя', 
         'Тип учетной записи  пользователя', 
         'Блокировка учетной записи пользователя'
], axis=1).drop_duplicates()

# Правила с системными пользователями
rules_with_systems_roles = pd.merge(
    _rules_with_systems_roles['ID правила доступа'].drop_duplicates(), 
    rules_data[['ID правила доступа','Название правила доступа','Правило отключено']],
    on='ID правила доступа', how='inner')
rules_with_systems_roles.to_csv('clusters/rules_with_system.csv')

# Роли с системными пользователями в правилах
roles_with_systems_roles = pd.merge(
    _rules_with_systems_roles[['ID роли','Тип роли']].drop_duplicates(), 
    role_name[['ID роли','Название роли']], 
    on='ID роли', how='left'
)[['ID роли','Название роли','Тип роли']]
roles_with_systems_roles.to_csv('clusters/roles_with_system.csv')

print('-'*5,'Правила с системными пользователями',‘-**5)
print(rules_with_systems_roles.info())
display(rules_with_systems_roles.head(5))
print()

print('-'*5,'Роли с системными пользователями в правилах'，·_'*5)
print(roles_with_systems_roles.info())
display(roles_with_systems_roles.head(5))

Правила с администраторами¶

In [ ]:
# Предварительный список правил с администраторами
_rules_with_admins = rules_not_contextual_roles[
    (rules_not_contextual_roles['ID пользователя'].isin(['00000000-0000-0000-0000-000000000008'])) # Статическая роль 'Сотрудники с правами Администратора
    | (rules_not_contextual_roles['Уровень доступа пользователя']== 1) # Административный уровень доступа
].sort_values(['ID правила доступа','ID роли']).drop([
    'ID пользователя', 'Доложность пользователя', 
    'Уровень доступа пользователя', 'Тип учетной записи пользователя', 
    'Блокировка учетной записи пользователя'
], axis=1).drop_duplicates()

# Правила с администраторами
rules_with_admins = pd.merge(_rules_with_admins['ID npaBwna AocTyna'].drop_duplicates(), 
                             rules_data[['ID правила доступа', 
                                         'Название правила доступа', 
                                         'Правило отключено']], on='ID правила доступа', how='inner')
rules_with_admins.to_csv('clusters/rules_with_admins.csv')

# Роли с администраторами
roles_with_admins = pd.merge(_rules_with_admins[['ID роли','Tun роли']].drop_duplicates(), 
                             role_name[['ID роли','Название роли']], 
                             on='ID роли', how='left')[['ID роли','Название роли','Тип роли']]
roles_with_admins.to_csv('clusters/roles_with_admins.csv')

print('-'*5,'Правила с администраторами','-'*5)
print(rules_with_admins.info())
display(rules_with_admins.head(5))
print()

print('-'*5,'Роли с администраторами в правилах'，'-'*5)
print(roles_with_admins.info())
display(roles_with_admins.head(5))

Объединение данных о результатах анализа правил¶

In [ ]:
# Данные о правилах
result_rules = rules_data[['ID правила доступа','Название правила доступа','Правило отключено']].drop_duplicates()
result_rules['РПД'] = np.where(result_rules['ID правила доступа'].isin(rules_data[rules_data['РПД'] == True]['ID правила доступа']), True, False)
result_rules['Типы условий'] = np.where(result_rules['ID правила доступа'].isin(rules_data[rules_data['Типы условий'] == True]['ID правила доступа']), True, False)
# Данные о ролях в правилах
result_rules['Контекстные роли'] = np.where(result_rules['ID правила доступа'].isin(rules_roles[rules_roles['Тип роли'] == 4]['ID правила доступа']), True, False)
result_rules['Роли с пользователями'] = np.where(result_rules['ID правила доступа'].isin(rules_with_users['ID правила доступа']), True, False)
result_rules['Роли без пользователей'] = np.where(result_rules['ID правила доступа'].isin(rules_without_users['ID правила доступа']), True, False)
result_rules['Роли с не заблокированными пользователями'] = np.where(result_rules['ID правила доступа'].isin(rules_with_non_blocked_users['ID правила доступа']), True, False)
result_rules['Роли с заблокированными пользователями'] = np.where(result_rules['ID правила доступа'].isin(rules_with_blocked_users['ID правила доступа']), True, False)
result_rules['Пользователи без групповых ролей'] = np.where(result_rules['ID правила доступа'].isin(rules_with_users_without_group_roles['ID правила доступа']), True, False)
result_rules['Роли с System'] = np.where(result_rules['ID правила доступа'].isin(rules_with_system['ID правила доступа']), True, False)
result_rules['Роли с системными пользователям'] = np.where(result_rules['ID правила доступа'].isin(rules_with_systems_roles['ID правила доступа']), True, False)
result_rules['Роли с администраторами'] = np.where(result_rules['ID правила доступа'].isin(rules_with_admins['ID правила доступа']), True, False)
# Данные о разрешениях
result_rules['Чтение карточки'] = np.where(result_rules['ID правила доступа'].isin(KrPermissions[KrPermissions['Чтение карточки'] == True]['ID правила доступа']), True, False)
result_rules['Создание карточки'] = np.where(result_rules['ID правила доступа'].isin(KrPermissions[KrPermissions['Создание карточки'] == True]['ID правила доступа']), True, False)
result_rules['Редактирование карточки'] = np.where(result_rules['ID правила доступа'].isin(KrPermissions[KrPermissions['Редактирование карточки'] == True]['ID правила доступа']), True, False)
result_rules['Удаление карточки'] = np.where(result_rules['ID правила доступа'].isin(KrPermissions[KrPermissions['Удаление карточки'] == True]['ID правила доступа']), True, False)
result_rules['Добавление файлов'] = np.where(result_rules['ID правила доступа'].isin(KrPermissions[KrPermissions['Добавление файлов'] == True]['ID правила доступа']), True, False)
result_rules['Редактирование файлов'] = np.where(result_rules['ID правила доступа'].isin(KrPermissions[KrPermissions['Редактирование файлов'] == True]['ID правила доступа']), True, False)
result_rules['Удаление всех файлов'] = np.where(result_rules['ID правила доступа'].isin(KrPermissions[KrPermissions['Удаление всех файлов'] == True]['ID правила доступа']), True, False)

print('-'*5,'Результаты анализа правил'，'-'*5)
print(result_rules.info())
display(result_rules.head(5))

Кластеризация правил¶

In [ ]:
# Кластеры правил и рекомендации
result_rules['Кластеры'] = ''
result_rules['Рекомендации'] = ''

# Все роли пустые
mask = ((result_rules['Роли с пользователями'] == False)
    & (result_rules['Роли без пользователей'] == True)
    | ( (result_rules['Роли с не заблокированными пользователями'] == False)
    & (result_rules['Роли с заблокированными пользователями'] == True))
    & (result_rules['Кластеры'] = ''))
result_rules.loc[mask, 'Кластеры'] = 'Все роли пустые. '
result_rules.loc[mask, 'Рекомендации'] = 'Удалить правила и роли внутри них. '

# Есть пустые роли
mask = ((result_rules['Роли с пользователями'] == True)
    & (result_rules['Роли без пользователей'] == True)
    | ( (result_rules['Роли с не заблокированными пользователями'] == True)
    & (result_rules['Роли с заблокированными пользователями'] == True)))
result_rules.loc[mask, 'Кластеры'] = 'Пустые роли. '
result_rules.loc[mask, 'Рекомендации'] = 'Проверить правила и роли внутри них. '

# Иднивидуальные роли
mask = (result_rules['Пользователи без групповых ролей'] == True)
result_rules.loc[mask, 'Кластеры'] += 'Индивидуальные роли. '
result_rules.loc[mask, 'Рекомендации'] += 'Использовать групповые роли вместо иднивидуальных'

# Контекстные роли
mask = (result_rules['Контекстные роли'] == True)
result_rules.loc[mask, 'Кластеры'] += 'Контекстные роли. '
result_rules.loc[mask, 'Рекомендации'] += 'Контекстные роли заменить на групповые роли и типы условий. '

# Системные роли
mask = ((result_rules['Роли с системными пользователям'] == True))
result_rules.loc[mask, 'Кластеры'] += 'Системные роли. '
result_rules.loc[mask, 'Рекомендации'] += 'Сверить права системных ролей с их ТЗ. '

# Административные права
mask = ((result_rules['Роли с System'] == True)
    | (result_rules['Роли с администраторами'] == True))
result_rules.loc[mask, 'Кластеры'] += 'Административные права. '
result_rules.loc[mask, 'Рекомендации'] += 'Особое внимание на список администраторов. '

# Полные права на модификацию документов
mask = ((result_rules['Редактирование карточки'] == True)
    & (result_rules['Удаление карточки'] == True)
    & (result_rules['Добавление файлов'] == True)
    & (result_rules['Редактирование файлов'] == True)
    & (result_rules['Удаление всех файлов'] == True))
result_rules.loc[mask, 'Кластеры'] += 'Полные права на модификацию документов. '
result_rules.loc[mask, 'Рекомендации'] += 'Проверить риск возможности подлога документов. '

# Права на чтение
mask = ((result_rules['Чтение карточки'] == True))
result_rules.loc[mask, 'Кластеры'] += 'Права на чтение. '
result_rules.loc[mask, 'Рекомендации'] += 'Сверить права с бизнес-требованиями на доступ к документам. '

# Права на создание
mask = ((result_rules['Создание карточки'] == True))
result_rules.loc[mask, 'Кластеры'] += 'Права на создание. '
result_rules.loc[mask, 'Рекомендации'] += ''

result_rules.to_csv('clusters/result_rules.csv', sep=';', encoding='utf-8-sig')
result_rules.head()

Python sql анализ информационная система информация корпоративная информационная система модель предоставления прав практика

Предыдущая статьяИнтерпретация кластерного анализа модели предоставления разрешений в TessaСледующая статья Анализ модели предоставления прав в информационной системе

Рубрики

Метки

abc abcd Apache Airflow CI/CD Data Warehouse Docker excel Git Grafana Great Expectations ms sql pandas PostgreSQL Python sql tessa VBA xyz Zabbix анализ виртуальный помощник данные знания информационная система информация искусственный интеллект кластерный анализ компетенции корпоративная информационная система математика модель предоставления прав мудрость о проекте оптимизация ошибка практика программное обеспечение ролевая модель теория теория вероятностей тесса тест хранилище данных юмор языки программирования

Политика конфиденциальности

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




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


Все права защищены. При копировании материалов сайта обязательно указывать ссылку на © Microsegment.ru (2020-2026)