# Створюємо файл — автоматично стаємо його власником
touch report.txt

# Дивимося поточні дозволи
ls -l report.txt
# -rw-r--r--  1 ivan  staff  0 Sep  7 14:30 report.txt
# ^^^ ^^^ ^^^
#  |   |   └─ Others: read
#  |   └───── Group: read
#  └───────── User: read + write

# Надаємо групі право на запис, забираємо доступ у інших
chmod 660 report.txt

# Результат
ls -l report.txt
# -rw-rw----  1 ivan  staff  0 Sep  7 14:30 report.txt

// domain/document.entity.ts
export class Document {
  id: string;
  title: string;
  content: string;
  ownerId: string; // UUID власника документа
  createdAt: Date;
  
  // Список дозволів: які користувачі мають які права
  permissions: DocumentPermission[];
}

export class DocumentPermission {
  id: string;
  documentId: string;
  userId: string; // UUID користувача, якому надано доступ
  canRead: boolean;
  canWrite: boolean;
  canDelete: boolean;
  canGrantAccess: boolean; // Чи може цей користувач надавати доступ іншим
  grantedAt: Date;
}

// guards/dac-authorization.guard.ts
import { Injectable, CanActivate, ExecutionContext, ForbiddenException } from '@nestjs/common';
import { Reflector } from '@nestjs/core';
import { DocumentService } from '../services/document.service';

@Injectable()
export class DacAuthorizationGuard implements CanActivate {
  constructor(
    private reflector: Reflector,
    private documentService: DocumentService
  ) {}

  async canActivate(context: ExecutionContext): Promise<boolean> {
    // Витягуємо необхідну операцію з метаданих декоратора
    const requiredOperation = this.reflector.get<'read' | 'write' | 'delete' | 'grant'>(
      'operation',
      context.getHandler()
    );

    if (!requiredOperation) {
      return true; // Якщо операція не вказана, дозволяємо доступ
    }

    const request = context.switchToHttp().getRequest();
    const currentUser = request.user; // Встановлений AuthGuard
    const documentId = request.params.id;

    if (!currentUser || !documentId) {
      throw new ForbiddenException('Missing authentication or document ID');
    }

    const document = await this.documentService.findById(documentId);

    if (!document) {
      return false; // Документ не існує — Guard не несе відповідальності за 404
    }

    // Перевірка 1: Власник має всі права
    if (document.ownerId === currentUser.sub) {
      return true;
    }

    // Перевірка 2: Шукаємо явний дозвіл для поточного користувача
    const permission = document.permissions.find(p => p.userId === currentUser.sub);

    if (!permission) {
      throw new ForbiddenException('You do not have access to this document');
    }

    // Перевірка 3: Чи має користувач необхідну операцію
    const hasPermission = this.checkPermission(permission, requiredOperation);

    if (!hasPermission) {
      throw new ForbiddenException(
        `You do not have permission to ${requiredOperation} this document`
      );
    }

    return true;
  }

  private checkPermission(
    permission: DocumentPermission,
    operation: 'read' | 'write' | 'delete' | 'grant'
  ): boolean {
    switch (operation) {
      case 'read':
        return permission.canRead;
      case 'write':
        return permission.canWrite;
      case 'delete':
        return permission.canDelete;
      case 'grant':
        return permission.canGrantAccess;
      default:
        return false;
    }
  }
}

// decorators/require-operation.decorator.ts
import { SetMetadata } from '@nestjs/common';

export const RequireOperation = (operation: 'read' | 'write' | 'delete' | 'grant') =>
  SetMetadata('operation', operation);

// controllers/documents.controller.ts
import { Controller, Get, Put, Delete, Post, Param, Body, UseGuards } from '@nestjs/common';
import { AuthGuard } from '../guards/auth.guard';
import { DacAuthorizationGuard } from '../guards/dac-authorization.guard';
import { RequireOperation } from '../decorators/require-operation.decorator';
import { CurrentUser } from '../decorators/current-user.decorator';

@Controller('documents')
@UseGuards(AuthGuard, DacAuthorizationGuard)
export class DocumentsController {
  constructor(private documentService: DocumentService) {}

  // Читання документа — потребує canRead
  @Get(':id')
  @RequireOperation('read')
  async getDocument(@Param('id') id: string) {
    return this.documentService.findById(id);
  }

  // Редагування документа — потребує canWrite
  @Put(':id')
  @RequireOperation('write')
  async updateDocument(
    @Param('id') id: string,
    @Body() updateDto: UpdateDocumentDto
  ) {
    return this.documentService.update(id, updateDto);
  }

  // Видалення документа — потребує canDelete
  @Delete(':id')
  @RequireOperation('delete')
  async deleteDocument(@Param('id') id: string) {
    return this.documentService.delete(id);
  }

  // Надання доступу іншому користувачеві — потребує canGrantAccess
  @Post(':id/permissions')
  @RequireOperation('grant')
  async grantPermission(
    @Param('id') id: string,
    @Body() grantDto: GrantPermissionDto,
    @CurrentUser() currentUser: JwtPayload
  ) {
    return this.documentService.grantPermission(id, grantDto);
  }
}

-- Власник таблиці надає право читання іншому користувачеві
GRANT SELECT ON users TO analyst_user;

-- Передача права надавати доступ іншим
GRANT SELECT ON users TO manager_user WITH GRANT OPTION;

// domain/security-level.enum.ts
export enum SecurityLevel {
  UNCLASSIFIED = 0,
  CONFIDENTIAL = 1,
  SECRET = 2,
  TOP_SECRET = 3,
}

// domain/classified-document.entity.ts
export class ClassifiedDocument {
  id: string;
  title: string;
  content: string;
  classification: SecurityLevel; // Рівень класифікації документа
  createdBy: string;
  createdAt: Date;
}

// domain/user.entity.ts (розширення базової моделі)
export class User {
  id: string;
  email: string;
  clearanceLevel: SecurityLevel; // Рівень допуску користувача
  department: string;
}

// guards/mac-authorization.guard.ts
import { Injectable, CanActivate, ExecutionContext, ForbiddenException } from '@nestjs/common';
import { Reflector } from '@nestjs/core';
import { ClassifiedDocumentService } from '../services/classified-document.service';
import { SecurityLevel } from '../domain/security-level.enum';

@Injectable()
export class MacAuthorizationGuard implements CanActivate {
  constructor(
    private reflector: Reflector,
    private documentService: ClassifiedDocumentService
  ) {}

  async canActivate(context: ExecutionContext): Promise<boolean> {
    const operation = this.reflector.get<'read' | 'write'>('operation', context.getHandler());

    if (!operation) {
      return true;
    }

    const request = context.switchToHttp().getRequest();
    const currentUser = request.user;
    const documentId = request.params.id;

    if (!currentUser || !documentId) {
      throw new ForbiddenException('Missing authentication or document ID');
    }

    const document = await this.documentService.findById(documentId);

    if (!document) {
      return false;
    }

    // Застосовуємо правила Белла-ЛаПадули
    if (operation === 'read') {
      // No Read Up: користувач може читати лише документи свого рівня або нижче
      if (currentUser.clearanceLevel < document.classification) {
        throw new ForbiddenException(
          `Access denied: your clearance level (${SecurityLevel[currentUser.clearanceLevel]}) ` +
          `is insufficient for documents classified as ${SecurityLevel[document.classification]}`
        );
      }
    }

    if (operation === 'write') {
      // No Write Down: користувач може писати лише у документи свого рівня або вище
      if (currentUser.clearanceLevel > document.classification) {
        throw new ForbiddenException(
          `Access denied: you cannot write to documents with lower classification ` +
          `(No Write Down policy)`
        );
      }
    }

    return true;
  }
}

// controllers/classified-documents.controller.ts
import { Controller, Get, Post, Param, Body, UseGuards } from '@nestjs/common';
import { AuthGuard } from '../guards/auth.guard';
import { MacAuthorizationGuard } from '../guards/mac-authorization.guard';
import { RequireOperation } from '../decorators/require-operation.decorator';
import { CurrentUser } from '../decorators/current-user.decorator';
import { SecurityLevel } from '../domain/security-level.enum';

@Controller('classified-documents')
@UseGuards(AuthGuard, MacAuthorizationGuard)
export class ClassifiedDocumentsController {
  constructor(private documentService: ClassifiedDocumentService) {}

  @Get(':id')
  @RequireOperation('read')
  async getDocument(@Param('id') id: string) {
    return this.documentService.findById(id);
  }

  @Post()
  async createDocument(
    @Body() createDto: CreateClassifiedDocumentDto,
    @CurrentUser() currentUser: User
  ) {
    // Користувач може створити документ лише зі своїм рівнем класифікації або вище
    // (No Write Down: не можна писати у менш секретні документи)
    if (createDto.classification < currentUser.clearanceLevel) {
      throw new ForbiddenException(
        'You cannot create documents with classification lower than your clearance level'
      );
    }

    // Користувач не може створити документ з класифікацією вище за свій допуск
    if (createDto.classification > currentUser.clearanceLevel) {
      throw new ForbiddenException(
        'You cannot create documents with classification higher than your clearance level'
      );
    }

    return this.documentService.create({
      ...createDto,
      createdBy: currentUser.sub,
      classification: createDto.classification,
    });
  }
}

// domain/role.entity.ts
export class Role {
  id: string;
  name: string; // 'admin', 'editor', 'viewer'
  description: string;
  permissions: Permission[];
  createdAt: Date;
}

// domain/permission.entity.ts
export class Permission {
  id: string;
  resource: string; // 'posts', 'users', 'comments'
  action: string;   // 'create', 'read', 'update', 'delete'
  
  // Зручний геттер для формування рядка дозволу
  get fullPermission(): string {
    return `${this.action}:${this.resource}`;
  }
}

// domain/user.entity.ts
export class User {
  id: string;
  email: string;
  roles: Role[]; // Користувач може мати кілька ролей
  createdAt: Date;
}

// services/authorization.service.ts
import { Injectable } from '@nestjs/common';
import { UserService } from './user.service';

@Injectable()
export class AuthorizationService {
  constructor(private userService: UserService) {}

  /**
   * Перевіряє, чи має користувач необхідний дозвіл через свої ролі
   */
  async userHasPermission(userId: string, requiredPermission: string): Promise<boolean> {
    const user = await this.userService.findByIdWithRoles(userId);

    if (!user || !user.roles) {
      return false;
    }

    // Збираємо всі дозволи з усіх ролей користувача
    const allPermissions = user.roles.flatMap(role => 
      role.permissions.map(p => p.fullPermission)
    );

    return allPermissions.includes(requiredPermission);
  }

  /**
   * Перевіряє, чи має користувач хоча б один із вказаних дозволів
   */
  async userHasAnyPermission(userId: string, permissions: string[]): Promise<boolean> {
    const checks = await Promise.all(
      permissions.map(p => this.userHasPermission(userId, p))
    );

    return checks.some(result => result === true);
  }

  /**
   * Перевіряє, чи має користувач всі вказані дозволи
   */
  async userHasAllPermissions(userId: string, permissions: string[]): Promise<boolean> {
    const checks = await Promise.all(
      permissions.map(p => this.userHasPermission(userId, p))
    );

    return checks.every(result => result === true);
  }
}

// guards/rbac-authorization.guard.ts
import { Injectable, CanActivate, ExecutionContext, ForbiddenException } from '@nestjs/common';
import { Reflector } from '@nestjs/core';
import { AuthorizationService } from '../services/authorization.service';

@Injectable()
export class RbacAuthorizationGuard implements CanActivate {
  constructor(
    private reflector: Reflector,
    private authorizationService: AuthorizationService
  ) {}

  async canActivate(context: ExecutionContext): Promise<boolean> {
    // Витягуємо необхідні дозволи з метаданих декоратора
    const requiredPermissions = this.reflector.get<string[]>(
      'permissions',
      context.getHandler()
    );

    if (!requiredPermissions || requiredPermissions.length === 0) {
      return true; // Якщо дозволи не вказані, пропускаємо перевірку
    }

    const request = context.switchToHttp().getRequest();
    const currentUser = request.user;

    if (!currentUser) {
      throw new ForbiddenException('User not authenticated');
    }

    // Перевіряємо, чи має користувач хоча б один із необхідних дозволів
    const hasPermission = await this.authorizationService.userHasAnyPermission(
      currentUser.sub,
      requiredPermissions
    );

    if (!hasPermission) {
      throw new ForbiddenException(
        `Access denied: required permissions are [${requiredPermissions.join(', ')}]`
      );
    }

    return true;
  }
}

// decorators/require-permissions.decorator.ts
import { SetMetadata } from '@nestjs/common';

/**
 * Декоратор для вказівки необхідних дозволів у форматі "action:resource"
 * Приклад: @RequirePermissions('create:posts', 'edit:posts')
 */
export const RequirePermissions = (...permissions: string[]) =>
  SetMetadata('permissions', permissions);

// controllers/posts.controller.ts
import { Controller, Get, Post, Put, Delete, Param, Body, UseGuards } from '@nestjs/common';
import { AuthGuard } from '../guards/auth.guard';
import { RbacAuthorizationGuard } from '../guards/rbac-authorization.guard';
import { RequirePermissions } from '../decorators/require-permissions.decorator';

@Controller('posts')
@UseGuards(AuthGuard, RbacAuthorizationGuard)
export class PostsController {
  constructor(private postsService: PostsService) {}

  // Публічний ендпоінт — дозволи не вимагаються
  @Get()
  async getAllPosts() {
    return this.postsService.findAll();
  }

  // Вимагає дозвіл на читання постів
  @Get(':id')
  @RequirePermissions('read:posts')
  async getPost(@Param('id') id: string) {
    return this.postsService.findById(id);
  }

  // Вимагає дозвіл на створення постів
  @Post()
  @RequirePermissions('create:posts')
  async createPost(@Body() createDto: CreatePostDto) {
    return this.postsService.create(createDto);
  }

  // Вимагає дозвіл на редагування постів
  @Put(':id')
  @RequirePermissions('edit:posts')
  async updatePost(@Param('id') id: string, @Body() updateDto: UpdatePostDto) {
    return this.postsService.update(id, updateDto);
  }

  // Вимагає дозвіл на видалення постів (зазвичай лише admin або moderator)
  @Delete(':id')
  @RequirePermissions('delete:posts')
  async deletePost(@Param('id') id: string) {
    return this.postsService.delete(id);
  }

  // Ендпоінт адміністрування — вимагає кілька дозволів одночасно
  @Post(':id/publish')
  @RequirePermissions('edit:posts', 'publish:posts')
  async publishPost(@Param('id') id: string) {
    return this.postsService.publish(id);
  }
}

ПРАВИЛО: Дозволити читання медичного запису
ЯКЩО:
  - subject.role == "doctor"
  - subject.department == resource.departmentAssigned
  - subject.licenseStatus == "active"
  - context.time BETWEEN 08:00 AND 20:00
  - context.location == "clinic_network"
  - resource.patientId IN subject.assignedPatients

ПРАВИЛО: Дозволити експорт знеособлених даних
ЯКЩО:
  - subject.role == "researcher"
  - subject.hasEthicsApproval == true
  - resource.type == "anonymized_dataset"
  - action == "export"
  - context.approvalExpiryDate > context.currentDate

// domain/policy.interface.ts
export interface AbacPolicy {
  name: string;
  description: string;
  
  /**
   * Оцінює, чи дозволяє політика виконання дії
   * @returns true якщо дозволено, false якщо заборонено
   */
  evaluate(context: AbacContext): Promise<boolean>;
}

export interface AbacContext {
  subject: {
    userId: string;
    email: string;
    roles: string[];
    department: string;
    emailVerified: boolean;
  };
  resource: {
    id: string;
    type: string;
    ownerId: string;
    confidentialityLevel: number;
  };
  action: string; // 'read', 'write', 'delete', 'export'
  environment: {
    time: Date;
    ipAddress: string;
    userAgent: string;
  };
}

// policies/document-access.policy.ts
import { Injectable } from '@nestjs/common';
import { AbacPolicy, AbacContext } from '../domain/policy.interface';

@Injectable()
export class DocumentAccessPolicy implements AbacPolicy {
  name = 'DocumentAccessPolicy';
  description = 'Користувач може редагувати документи свого відділу у робочі години';

  async evaluate(context: AbacContext): Promise<boolean> {
    const { subject, resource, action, environment } = context;

    // Правило 1: Власник має всі права
    if (resource.ownerId === subject.userId) {
      return true;
    }

    // Правило 2: Документи можна редагувати лише у робочі години (8:00 - 18:00)
    if (action === 'write' || action === 'delete') {
      const hour = environment.time.getHours();
      if (hour < 8 || hour >= 18) {
        return false; // Поза робочими годинами — заборонено
      }
    }

    // Правило 3: Користувачі можуть читати документи з рівнем конфіденційності <= 2
    if (action === 'read' && resource.confidentialityLevel <= 2) {
      return true;
    }

    // Правило 4: Адміністратори мають повні права
    if (subject.roles.includes('admin')) {
      return true;
    }

    // Правило 5: Експорт дозволений лише з підтвердженим email
    if (action === 'export' && !subject.emailVerified) {
      return false;
    }

    // За замовчуванням — відхилити
    return false;
  }
}

// guards/abac-authorization.guard.ts
import { Injectable, CanActivate, ExecutionContext, ForbiddenException } from '@nestjs/common';
import { Reflector } from '@nestjs/core';
import { AbacPolicy, AbacContext } from '../domain/policy.interface';
import { DocumentService } from '../services/document.service';

@Injectable()
export class AbacAuthorizationGuard implements CanActivate {
  constructor(
    private reflector: Reflector,
    private documentService: DocumentService,
    private policies: AbacPolicy[] // Список зареєстрованих політик
  ) {}

  async canActivate(context: ExecutionContext): Promise<boolean> {
    const action = this.reflector.get<string>('action', context.getHandler());

    if (!action) {
      return true;
    }

    const request = context.switchToHttp().getRequest();
    const currentUser = request.user;
    const resourceId = request.params.id;

    if (!currentUser || !resourceId) {
      throw new ForbiddenException('Missing authentication or resource ID');
    }

    // Завантажуємо ресурс для отримання його атрибутів
    const resource = await this.documentService.findById(resourceId);

    if (!resource) {
      return false;
    }

    // Формуємо контекст для оцінки політик
    const abacContext: AbacContext = {
      subject: {
        userId: currentUser.sub,
        email: currentUser.email,
        roles: currentUser.roles || [],
        department: currentUser.department,
        emailVerified: currentUser.email_verified,
      },
      resource: {
        id: resource.id,
        type: resource.type,
        ownerId: resource.ownerId,
        confidentialityLevel: resource.confidentialityLevel,
      },
      action: action,
      environment: {
        time: new Date(),
        ipAddress: request.ip,
        userAgent: request.headers['user-agent'],
      },
    };

    // Оцінюємо всі політики — доступ дозволяється, якщо хоча б одна політика повертає true
    const evaluations = await Promise.all(
      this.policies.map(policy => policy.evaluate(abacContext))
    );

    const isAllowed = evaluations.some(result => result === true);

    if (!isAllowed) {
      throw new ForbiddenException(
        `Access denied: no policy permits ${action} operation on this resource`
      );
    }

    return true;
  }
}

// decorators/require-action.decorator.ts
import { SetMetadata } from '@nestjs/common';

export const RequireAction = (action: string) => SetMetadata('action', action);

// controllers/documents.controller.ts
import { Controller, Get, Put, Delete, Post, Param, Body, UseGuards } from '@nestjs/common';
import { AuthGuard } from '../guards/auth.guard';
import { AbacAuthorizationGuard } from '../guards/abac-authorization.guard';
import { RequireAction } from '../decorators/require-action.decorator';

@Controller('documents')
@UseGuards(AuthGuard, AbacAuthorizationGuard)
export class DocumentsController {
  constructor(private documentService: DocumentService) {}

  @Get(':id')
  @RequireAction('read')
  async getDocument(@Param('id') id: string) {
    return this.documentService.findById(id);
  }

  @Put(':id')
  @RequireAction('write')
  async updateDocument(@Param('id') id: string, @Body() updateDto: UpdateDocumentDto) {
    return this.documentService.update(id, updateDto);
  }

  @Delete(':id')
  @RequireAction('delete')
  async deleteDocument(@Param('id') id: string) {
    return this.documentService.delete(id);
  }

  @Post(':id/export')
  @RequireAction('export')
  async exportDocument(@Param('id') id: string) {
    return this.documentService.exportToPdf(id);
  }
}

// services/posts.service.ts
async updatePost(postId: string, updateDto: UpdatePostDto, currentUser: User): Promise<Post> {
  const post = await this.postsRepository.findById(postId);

  if (!post) {
    throw new NotFoundException('Post not found');
  }

  // Перевірка 1: Адміністратори можуть редагувати будь-які пости
  if (currentUser.roles.includes('admin')) {
    return this.postsRepository.update(postId, updateDto);
  }

  // Перевірка 2: Звичайні користувачі можуть редагувати лише свої пости
  if (post.authorId !== currentUser.id) {
    throw new ForbiddenException('You can only edit your own posts');
  }

  return this.postsRepository.update(postId, updateDto);
}

// Звичайні операції — через RBAC Guard
@Get(':id')
@RequirePermissions('read:documents')
async getDocument(@Param('id') id: string) {
  return this.documentService.findById(id);
}

// Експорт конфіденційних даних — через ABAC Guard з перевіркою контексту
@Post(':id/export-financial-data')
@UseGuards(AuthGuard, AbacAuthorizationGuard)
@RequireAction('export_financial')
async exportFinancialData(@Param('id') id: string) {
  return this.documentService.exportFinancialData(id);
}