Nils-Johan Gynther
729 lines
21 KiB
Markdown
729 lines
21 KiB
Markdown
# 🔒 Säkerhetshärdningsplan för Recipe-App (Flutter + NestJS + MariaDB)
|
||
|
||
**Mål:** Täppa till IDOR, Full Table Dump, och andra kritiska säkerhetshål i **backend (NestJS/Prisma/MariaDB)**, **Flutter-frontend**, och **infrastruktur (Docker/Gitea/Ubuntu)**.
|
||
|
||
**Prioritet:** CRITICAL → HIGH → MEDIUM
|
||
**Tidsuppskattning:** 1–3 dagar
|
||
|
||
---
|
||
|
||
---
|
||
|
||
## 📌 **0. Förberedelser**
|
||
|
||
### 0.1. Miljö och verktyg
|
||
|
||
- **Installera säkerhetsverktyg:**
|
||
```bash
|
||
# Scanna efter läckta hemligheter i Git
|
||
npm install -g gitleaks
|
||
gitleaks detect --source . --report-path gitleaks-report.json
|
||
|
||
# Scanna Docker-containers
|
||
docker scan --file Dockerfile
|
||
```
|
||
- **Skapa en `security-audit`-gren:**
|
||
```bash
|
||
git checkout -b security-audit-$(date +%Y%m%d)
|
||
```
|
||
- **Dokumentera nuvarande säkerhetsstatus:**
|
||
- Lista alla **API-endpoints** (särskilt de som hanterar användardata: `recipes`, `inventory`, `users`).
|
||
- Lista alla **databastabeller** och deras innehåll.
|
||
- Lista alla **webhooks** (t.ex. Gitea).
|
||
|
||
---
|
||
|
||
---
|
||
|
||
## 🚨 **1. IDOR (Insecure Direct Object Reference) – CRITICAL**
|
||
|
||
**Mål:** Se till att användare endast kan komma åt sina egna resurser via API:er.
|
||
|
||
### 1.1. Backend (NestJS/Prisma)
|
||
|
||
#### **Steg 1: Lägg till ägarskapskontroll i alla endpoints**
|
||
|
||
**Uppgift för Copilot:**
|
||
|
||
> "Skapa en **NestJS-guard** som automatiskt kontrollerar att den inloggade användaren äger resursen (t.ex. `Recipe`, `Inventory`). Använd `req.user.id` för att jämföra med `resource.userId`. Exempel:
|
||
>
|
||
> ```typescript
|
||
> // src/guards/ownership.guard.ts
|
||
> import { Injectable, CanActivate, ExecutionContext, ForbiddenException } from '@nestjs/common';
|
||
> import { Reflector } from '@nestjs/core';
|
||
>
|
||
> @Injectable()
|
||
> export class OwnershipGuard implements CanActivate {
|
||
> constructor(private reflector: Reflector) {}
|
||
>
|
||
> canActivate(context: ExecutionContext): boolean {
|
||
> const requiredResource = this.reflector.get<string>('resource', context.getHandler());
|
||
> if (!requiredResource) return true; // Ingen resurs specificerad = ingen kontroll
|
||
>
|
||
> const request = context.switchToHttp().getRequest();
|
||
> const resourceId = request.params.id;
|
||
> const userId = request.user.id;
|
||
>
|
||
> // Hämta resursen och kontrollera ägarskap
|
||
> // (Anta att vi har en service för detta)
|
||
> const resource = await request[requiredResource + 'Service'].findOne(resourceId);
|
||
> if (!resource || resource.userId !== userId) {
|
||
> throw new ForbiddenException('Du har inte tillgång till denna resurs.');
|
||
> }
|
||
> return true;
|
||
> }
|
||
> }
|
||
> ```
|
||
>
|
||
> Registrera guarden globalt i `app.module.ts` eller använd den på specifika routes med `@UseGuards(OwnershipGuard)`."
|
||
|
||
**Uppgift för Copilot:**
|
||
|
||
> "Uppdatera alla **controller-metoder** som hanterar `Recipe`, `Inventory`, eller `User` för att använda `@UseGuards(OwnershipGuard)` och `@SetMetadata('resource', 'recipe')` (eller motsvarande). Exempel:
|
||
>
|
||
> ```typescript
|
||
> // src/recipes/recipes.controller.ts
|
||
> import { Controller, Get, Param, UseGuards, SetMetadata } from '@nestjs/common';
|
||
> import { OwnershipGuard } from '../guards/ownership.guard';
|
||
>
|
||
> @Controller('recipes')
|
||
> @UseGuards(OwnershipGuard)
|
||
> export class RecipesController {
|
||
> @Get(':id')
|
||
> @SetMetadata('resource', 'recipe')
|
||
> async getRecipe(@Param('id') id: number) {
|
||
> return this.recipesService.findOne(id);
|
||
> }
|
||
> }
|
||
> ```"
|
||
> ```
|
||
|
||
#### **Steg 2: Prisma-middleware för automatisk filtrering**
|
||
|
||
**Uppgift för Copilot:**
|
||
|
||
> "Skapa en **Prisma-middleware** som automatiskt lägger till `userId: req.user.id` till alla `findMany`, `findFirst`, `update`, och `delete`-förfrågningar för tabellerna `Recipe` och `Inventory`. Exempel:
|
||
>
|
||
> ```typescript
|
||
> // src/prisma/prisma.service.ts
|
||
> import { Injectable, OnModuleInit } from '@nestjs/common';
|
||
> import { PrismaClient } from '@prisma/client';
|
||
>
|
||
> @Injectable()
|
||
> export class PrismaService extends PrismaClient implements OnModuleInit {
|
||
> private userId: number;
|
||
>
|
||
> setUserId(userId: number) {
|
||
> this.userId = userId;
|
||
> }
|
||
>
|
||
> async onModuleInit() {
|
||
> await this.$connect();
|
||
> this.$use(async (params, next) => {
|
||
> if (this.userId && ['Recipe', 'Inventory'].includes(params.model)) {
|
||
> params.where = { ...params.where, userId: this.userId };
|
||
> }
|
||
> return next(params);
|
||
> });
|
||
> }
|
||
> }
|
||
> ```
|
||
>
|
||
> Uppdatera sedan `OwnershipGuard` för att sätta `prismaService.setUserId(req.user.id)`."
|
||
|
||
#### **Steg 3: Testa för IDOR**
|
||
|
||
**Uppgift för Copilot:**
|
||
|
||
> "Skapa **Jest-tester** för att verifiera att IDOR-skyddet fungerar. Testa:
|
||
>
|
||
> 1. En användare kan hämta sina egna recept/inventory.
|
||
> 2. En användare **kan inte** hämta andras recept/inventory.
|
||
>
|
||
> Exempel:
|
||
>
|
||
> ```typescript
|
||
> // test/idor.test.ts
|
||
> describe('IDOR Protection', () => {
|
||
> let app;
|
||
> let user1, user2, recipe1;
|
||
>
|
||
> beforeAll(async () => {
|
||
> app = await createTestApp();
|
||
> user1 = await createTestUser();
|
||
> user2 = await createTestUser();
|
||
> recipe1 = await createTestRecipe(user1.id);
|
||
> });
|
||
>
|
||
> it('should allow user to access their own recipe', async () => {
|
||
> const response = await request(app.getHttpServer())
|
||
> .get(`/recipes/${recipe1.id}`)
|
||
> .set('Authorization', `Bearer ${user1.token}`);
|
||
> expect(response.status).toBe(200);
|
||
> });
|
||
>
|
||
> it('should block user from accessing another user\'s recipe', async () => {
|
||
> const response = await request(app.getHttpServer())
|
||
> .get(`/recipes/${recipe1.id}`)
|
||
> .set('Authorization', `Bearer ${user2.token}`);
|
||
> expect(response.status).toBe(403);
|
||
> });
|
||
> });
|
||
> ```"
|
||
> ```
|
||
|
||
---
|
||
|
||
---
|
||
|
||
## 🗃️ **2. Full Table Dump – CRITICAL**
|
||
|
||
**Mål:** Förhindra att användare kan hämta alla rader från en tabell.
|
||
|
||
### 2.1. Backend (Prisma/NestJS)
|
||
|
||
**Uppgift för Copilot:**
|
||
|
||
> "Uppdatera alla **Prisma-förfrågningar** som använder `findMany` för `Recipe`, `Inventory`, eller `User` för att **alltid** inkludera `where: { userId: req.user.id }`. Exempel:
|
||
>
|
||
> ```typescript
|
||
> // src/recipes/recipes.service.ts
|
||
> async findAll(userId: number) {
|
||
> return this.prisma.recipe.findMany({
|
||
> where: { userId } // Tvinga filtrering
|
||
> });
|
||
> }
|
||
> ```"
|
||
> ```
|
||
|
||
### 2.2. MariaDB (RLS-liknande kontroll)
|
||
|
||
**Uppgift för Copilot:**
|
||
|
||
> "Skapa **MariaDB-vyer** för `recipes` och `inventory` som automatiskt filtrerar på `userId`. Exempel:
|
||
>
|
||
> ```sql
|
||
> -- Skapa en vy för användarens recept
|
||
> CREATE VIEW user_recipes AS
|
||
> SELECT * FROM recipes WHERE userId = @current_user_id;
|
||
>
|
||
> -- Skapa en stored procedure för att sätta @current_user_id
|
||
> DELIMITER //
|
||
> CREATE PROCEDURE SetCurrentUserId(IN p_userId INT)
|
||
> BEGIN
|
||
> SET @current_user_id = p_userId;
|
||
> END //
|
||
> DELIMITER ;
|
||
> ```
|
||
>
|
||
> **Obs:** MariaDB saknar inbyggt RLS, så vyer + stored procedures är det bästa alternativet. Dokumentera att alla förfrågningar ska gå via vyer."
|
||
|
||
**Uppgift för Copilot:**
|
||
|
||
> "Skapa en **stored procedure** för att hämta användarens inventory, med `userId` som parameter. Exempel:
|
||
>
|
||
> ```sql
|
||
> DELIMITER //
|
||
> CREATE PROCEDURE GetUserInventory(IN p_userId INT)
|
||
> BEGIN
|
||
> SELECT * FROM inventory WHERE userId = p_userId;
|
||
> END //
|
||
> DELIMITER ;
|
||
> ```"
|
||
> ```
|
||
|
||
### 2.3. Testa för Full Table Dump
|
||
|
||
**Uppgift för Copilot:**
|
||
|
||
> "Skapa **Jest-tester** för att verifiera att användare inte kan hämta alla rader. Exempel:
|
||
>
|
||
> ```typescript
|
||
> it('should block full table dump for recipes', async () => {
|
||
> const user = await createTestUser();
|
||
> const response = await request(app.getHttpServer())
|
||
> .get('/recipes')
|
||
> .set('Authorization', `Bearer ${user.token}`);
|
||
> expect(response.body.length).toBeLessThanOrEqual(10); // Anta att användaren har <10 recept
|
||
> });
|
||
> ```"
|
||
> ```
|
||
|
||
---
|
||
|
||
---
|
||
|
||
## 📱 **3. Flutter-Säkerhet – HIGH**
|
||
|
||
**Mål:** Säkra kommunikation mellan Flutter och backend, samt hantering av känsliga data.
|
||
|
||
### 3.1. API-Anrop
|
||
|
||
**Uppgift för Copilot:**
|
||
|
||
> "Skapa en **Dart-klass** för säkra API-anrop till backend, med:
|
||
>
|
||
> - **JWT-autentisering** (skicka `Authorization: Bearer <token>`).
|
||
> - **Validering av svar** (kontrollera att `userId` i svaret matchar den inloggade användaren).
|
||
> - **Felhantering** för 403 (Forbidden) och 401 (Unauthorized).
|
||
> Exempel:
|
||
>
|
||
> ```dart
|
||
> // lib/services/api_service.dart
|
||
> import 'package:http/http.dart' as http;
|
||
> import 'dart:convert';
|
||
>
|
||
> class ApiService {
|
||
> final String baseUrl;
|
||
> final String token;
|
||
>
|
||
> ApiService({required this.baseUrl, required this.token});
|
||
>
|
||
> Future<Map<String, dynamic>> getRecipe(int recipeId) async {
|
||
> final response = await http.get(
|
||
> Uri.parse('$baseUrl/recipes/$recipeId'),
|
||
> headers: {'Authorization': 'Bearer $token'},
|
||
> );
|
||
>
|
||
> if (response.statusCode == 403) {
|
||
> throw Exception('Du har inte tillgång till detta recept.');
|
||
> } else if (response.statusCode != 200) {
|
||
> throw Exception('Fel vid hämtning av recept.');
|
||
> }
|
||
>
|
||
> final data = json.decode(response.body);
|
||
> // Kontrollera att användar-ID matchar (om backend skickar med det)
|
||
> if (data['userId'] != await _getCurrentUserId()) {
|
||
> throw Exception('Ogiltig användare för detta recept.');
|
||
> }
|
||
> return data;
|
||
> }
|
||
>
|
||
> Future<int> _getCurrentUserId() async {
|
||
> // Hämta den inloggade användarens ID från lokal lagring
|
||
> final user = await _getStoredUser();
|
||
> return user['id'];
|
||
> }
|
||
> }
|
||
> ```"
|
||
> ```
|
||
|
||
### 3.2. Lagring av känsliga data
|
||
|
||
**Uppgift för Copilot:**
|
||
|
||
> "Skapa en **säker lagringslösning** för JWT-tokens och användardata i Flutter med `flutter_secure_storage`. Exempel:
|
||
>
|
||
> ```dart
|
||
> // lib/services/secure_storage.dart
|
||
> import 'package:flutter_secure_storage/flutter_secure_storage.dart';
|
||
>
|
||
> class SecureStorage {
|
||
> final FlutterSecureStorage _storage = const FlutterSecureStorage();
|
||
>
|
||
> Future<void> saveToken(String token) async {
|
||
> await _storage.write(key: 'auth_token', value: token);
|
||
> }
|
||
>
|
||
> Future<String?> getToken() async {
|
||
> return await _storage.read(key: 'auth_token');
|
||
> }
|
||
>
|
||
> Future<void> deleteToken() async {
|
||
> await _storage.delete(key: 'auth_token');
|
||
> }
|
||
> }
|
||
> ```"
|
||
> ```
|
||
|
||
### 3.3. Inputvalidering
|
||
|
||
**Uppgift för Copilot:**
|
||
|
||
> "Skapa en **valideringsklass** för all input i Flutter (t.ex. för recept-ID, användar-ID). Exempel:
|
||
>
|
||
> ```dart
|
||
> // lib/utils/validators.dart
|
||
> class Validators {
|
||
> static bool isValidId(String id) {
|
||
> return RegExp(r'^[0-9]+$').hasMatch(id);
|
||
> }
|
||
>
|
||
> static bool isValidUuid(String uuid) {
|
||
> return RegExp(r'^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$').hasMatch(uuid);
|
||
> }
|
||
> }
|
||
> ```"
|
||
> ```
|
||
|
||
---
|
||
|
||
---
|
||
|
||
## 🔌 **4. Webhook-Säkerhet – HIGH**
|
||
|
||
**Mål:** Validera signaturer för alla inkommande webhooks (t.ex. Gitea).
|
||
|
||
### 4.1. Gitea-Webhooks
|
||
|
||
**Uppgift för Copilot:**
|
||
|
||
> "Skapa en **NestJS-controller** för Gitea-webhooks som validerar `X-Gitea-Signature`-headern. Använd `crypto` för att verifiera HMAC-SHA256-signaturen. Exempel:
|
||
>
|
||
> ```typescript
|
||
> // src/webhooks/gitea.controller.ts
|
||
> import { Controller, Post, Headers, Body, UnauthorizedException } from '@nestjs/common';
|
||
> import * as crypto from 'crypto';
|
||
>
|
||
> @Controller('webhooks/gitea')
|
||
> export class GiteaController {
|
||
> @Post()
|
||
> async handleWebhook(
|
||
> @Headers('X-Gitea-Signature') signature: string,
|
||
> @Body() body: any,
|
||
> ) {
|
||
> const secret = process.env.GITEA_WEBHOOK_SECRET;
|
||
> const hmac = crypto.createHmac('sha256', secret);
|
||
> hmac.update(JSON.stringify(body));
|
||
> const expectedSignature = `sha256=${hmac.digest('hex')}`;
|
||
>
|
||
> if (!crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expectedSignature))) {
|
||
> throw new UnauthorizedException('Ogiltig signatur');
|
||
> }
|
||
>
|
||
> // Hantera webhook-händelsen (t.ex. triggera backup)
|
||
> return { status: 'success' };
|
||
> }
|
||
> }
|
||
> ```"
|
||
> ```
|
||
|
||
### 4.2. Miljövariabler
|
||
|
||
**Uppgift för Copilot:**
|
||
|
||
> "Lägg till `GITEA_WEBHOOK_SECRET` i `.env.example` och dokumentera att den **måste** sättas i produktion. Exempel:
|
||
>
|
||
> ```env
|
||
> # .env.example
|
||
> GITEA_WEBHOOK_SECRET=your_gitea_webhook_secret_here
|
||
> ```"
|
||
> ```
|
||
|
||
---
|
||
|
||
---
|
||
|
||
## 🔑 **5. Hemligheter och Kryptering – HIGH**
|
||
|
||
**Mål:** Skydda API-nycklar, databaslösenord, och krypteringsnycklar.
|
||
|
||
### 5.1. `.env`-filer
|
||
|
||
**Uppgift för Copilot:**
|
||
|
||
> "Skapa en `**.gitignore`-fil** som utesluter alla `.env`-filer och känsliga konfigurationsfiler. Exempel:
|
||
>
|
||
> ```gitignore
|
||
> # .gitignore
|
||
> .env
|
||
> .env.*
|
||
> !.env.example
|
||
> *.pem
|
||
> *.key
|
||
> ```"
|
||
> ```
|
||
|
||
**Uppgift för Copilot:**
|
||
|
||
> "Skapa en `**.env.example`-fil** med alla nödvändiga miljövariabler (utan värden). Exempel:
|
||
>
|
||
> ```env
|
||
> # .env.example
|
||
> DATABASE_URL=mysql://user:password@localhost:3306/recipe_app
|
||
> JWT_SECRET=your_jwt_secret_here
|
||
> GITEA_WEBHOOK_SECRET=your_gitea_webhook_secret_here
|
||
> PGP_PRIVATE_KEY_ENCRYPTION_PASSWORD=your_password_here
|
||
> ```"
|
||
> ```
|
||
|
||
### 5.2. Docker
|
||
|
||
**Uppgift för Copilot:**
|
||
|
||
> "Uppdatera `Dockerfile` och `docker-compose.yml` för att:
|
||
>
|
||
> 1. **Ta bort alla `ENV`-instruktioner** som exponerar känsliga data.
|
||
> 2. Använd `docker run --env-file` eller Docker Secrets för känsliga variabler.
|
||
>
|
||
> Exempel:
|
||
>
|
||
> ```yaml
|
||
> # docker-compose.yml
|
||
> services:
|
||
> app:
|
||
> build: .
|
||
> env_file:
|
||
> - .env
|
||
> ```"
|
||
> ```
|
||
|
||
**Uppgift för Copilot:**
|
||
|
||
> "Skapa en `**docker-compose.override.yml**` för lokal utveckling, som aldrig pushas till Git. Exempel:
|
||
>
|
||
> ```yaml
|
||
> # docker-compose.override.yml
|
||
> services:
|
||
> app:
|
||
> environment:
|
||
> - NODE_ENV=development
|
||
> - DATABASE_URL=mysql://dev_user:dev_password@db:3306/recipe_app
|
||
> ```"
|
||
> ```
|
||
|
||
### 5.3. PGP/AES-Kryptering
|
||
|
||
**Uppgift för Copilot:**
|
||
|
||
> "Skapa en **tjänst för kryptering/avkryptering** av PGP-nycklar med `openpgp`. Exempel:
|
||
>
|
||
> ```typescript
|
||
> // src/crypto/crypto.service.ts
|
||
> import { Injectable } from '@nestjs/common';
|
||
> import * as openpgp from 'openpgp';
|
||
>
|
||
> @Injectable()
|
||
> export class CryptoService {
|
||
> async encryptPrivateKey(privateKey: string, password: string): Promise<string> {
|
||
> const encrypted = await openpgp.encrypt({
|
||
> message: openpgp.Message.fromText(privateKey),
|
||
> passwords: [password],
|
||
> });
|
||
> return encrypted.toString();
|
||
> }
|
||
>
|
||
> async decryptPrivateKey(encryptedPrivateKey: string, password: string): Promise<string> {
|
||
> const message = await openpgp.readMessage({ armoredMessage: encryptedPrivateKey });
|
||
> const { data: decrypted } = await openpgp.decrypt({
|
||
> message,
|
||
> passwords: [password],
|
||
> });
|
||
> return decrypted.toString();
|
||
> }
|
||
> }
|
||
> ```"
|
||
> ```
|
||
|
||
**Uppgift för Copilot:**
|
||
|
||
> "Uppdatera **Prisma-schemat** för att lagra `encryptedPrivateKey` istället för `privateKey` i klart text. Exempel:
|
||
>
|
||
> ```prisma
|
||
> model User {
|
||
> id Int @id @default(autoincrement())
|
||
> encryptedPrivateKey String // Krypterad PGP-privat nyckel
|
||
> // ...
|
||
> }
|
||
> ```"
|
||
> ```
|
||
|
||
---
|
||
|
||
---
|
||
|
||
## 🛡️ **6. Säkerhetsheaders och CSP – MEDIUM**
|
||
|
||
**Mål:** Skydda backend med säkerhetsheaders.
|
||
|
||
### 6.1. NestJS (Backend)
|
||
|
||
**Uppgift för Copilot:**
|
||
|
||
> "Konfigurera **Helmet** i `main.ts` för att lägga till säkerhetsheaders. Exempel:
|
||
>
|
||
> ```typescript
|
||
> // src/main.ts
|
||
> import { NestFactory } from '@nestjs/core';
|
||
> import { AppModule } from './app.module';
|
||
> import * as helmet from 'helmet';
|
||
>
|
||
> async function bootstrap() {
|
||
> const app = await NestFactory.create(AppModule);
|
||
> app.use(helmet());
|
||
> await app.listen(3000);
|
||
> }
|
||
> bootstrap();
|
||
> ```"
|
||
> ```
|
||
|
||
---
|
||
|
||
---
|
||
|
||
## 🧪 **7. Automatiserade Säkerhetstester – MEDIUM**
|
||
|
||
**Mål:** Integrera säkerhetstester i CI/CD.
|
||
|
||
### 7.1. GitHub Actions
|
||
|
||
**Uppgift för Copilot:**
|
||
|
||
> "Skapa en **GitHub Actions-workflow** för säkerhetskontroller. Exempel:
|
||
>
|
||
> ```yaml
|
||
> # .github/workflows/security-audit.yml
|
||
> name: Security Audit
|
||
> on: [push, pull_request]
|
||
>
|
||
> jobs:
|
||
> gitleaks:
|
||
> runs-on: ubuntu-latest
|
||
> steps:
|
||
> - uses: actions/checkout@v4
|
||
> - uses: gitleaks/gitleaks-action@v2
|
||
> env:
|
||
> GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||
>
|
||
> docker-scan:
|
||
> runs-on: ubuntu-latest
|
||
> steps:
|
||
> - uses: actions/checkout@v4
|
||
> - name: Build Docker image
|
||
> run: docker build -t recipe-app .
|
||
> - name: Scan for vulnerabilities
|
||
> run: docker scan recipe-app
|
||
> ```"
|
||
> ```
|
||
|
||
### 7.2. OWASP ZAP
|
||
|
||
**Uppgift för Copilot:**
|
||
|
||
> "Skapa en **GitHub Actions-workflow** för OWASP ZAP-scanning. Exempel:
|
||
>
|
||
> ```yaml
|
||
> # .github/workflows/zap-scan.yml
|
||
> name: OWASP ZAP Scan
|
||
> on: [push]
|
||
>
|
||
> jobs:
|
||
> zap_scan:
|
||
> runs-on: ubuntu-latest
|
||
> steps:
|
||
> - uses: actions/checkout@v4
|
||
> - name: Start app
|
||
> run: |
|
||
> docker-compose up -d
|
||
> sleep 30 # Vänta på att appen ska starta
|
||
> - name: Run OWASP ZAP
|
||
> uses: zaproxy/action-full-scan@v0.4.0
|
||
> with:
|
||
> target: 'http://localhost:3000'
|
||
> ```"
|
||
> ```
|
||
|
||
---
|
||
|
||
---
|
||
|
||
## 📝 **8. Dokumentation**
|
||
|
||
**Uppgift för Copilot:**
|
||
|
||
> "Skapa en `**SECURITY.md**`-fil i rotkatalogen med:
|
||
>
|
||
> 1. En lista över alla säkerhetsåtgärder som vidtagits.
|
||
> 2. Instruktioner för hur man rapporterar säkerhetshål.
|
||
> 3. En checklist för säkerhetsgranskning före deployment.
|
||
>
|
||
> Exempel:
|
||
>
|
||
> ```markdown
|
||
> # 🔒 Säkerhetsdokumentation
|
||
>
|
||
> ## Vidtagna åtgärder
|
||
> - [x] IDOR-skydd för alla API-endpoints
|
||
> - [x] Full Table Dump-skydd via Prisma-middleware
|
||
> - [x] Webhook-signaturvalidering för Gitea
|
||
> - [x] `.env`-filer uteslutna från Git
|
||
> - [x] Flutter: Säker lagring av JWT-tokens
|
||
>
|
||
> ## Rapportera säkerhetshål
|
||
> Skicka ett e-post till security@recipe-app.com.
|
||
>
|
||
> ## Checklist före deployment
|
||
> - [ ] Alla `.env`-filer är uteslutna från Git.
|
||
> - [ ] Alla API-endpoints har ägarskapskontroll.
|
||
> - [ ] Webhook-signaturer valideras.
|
||
> - [ ] Docker-containers är scannade för sårbarheter.
|
||
> - [ ] Flutter-app använder `flutter_secure_storage` för tokens.
|
||
> ```"
|
||
> ```
|
||
|
||
---
|
||
|
||
---
|
||
|
||
## ✅ **9. Avslutande Checklista**
|
||
|
||
|
||
| **Åtgärd** | **Status** | **Ansvarsområde** |
|
||
| -------------------------------- | ---------- | ----------------------- |
|
||
| IDOR-skydd i alla endpoints | ⬜ | Backend (NestJS/Prisma) |
|
||
| Full Table Dump-skydd | ⬜ | Backend (Prisma) |
|
||
| Flutter: Säkra API-anrop | ⬜ | Flutter |
|
||
| Flutter: Säker lagring av tokens | ⬜ | Flutter |
|
||
| Webhook-signaturvalidering | ⬜ | Backend (NestJS) |
|
||
| `.env`-filer skyddade | ⬜ | Git/Docker |
|
||
| Docker-säkerhet | ⬜ | Docker |
|
||
| PGP-nycklar krypterade | ⬜ | Backend (CryptoService) |
|
||
| Säkerhetsheaders (Helmet) | ⬜ | Backend (NestJS) |
|
||
| Automatiserade säkerhetstester | ⬜ | CI/CD (GitHub Actions) |
|
||
| Säkerhetsdokumentation | ⬜ | Dokumentation |
|
||
|
||
|
||
---
|
||
|
||
---
|
||
|
||
## 🎯 **10. Prioriterad Ordning för Implementering**
|
||
|
||
1. **IDOR-skydd** (CRITICAL)
|
||
2. **Full Table Dump-skydd** (CRITICAL)
|
||
3. **Flutter-säkerhet** (HIGH)
|
||
4. **Webhook-säkerhet** (HIGH)
|
||
5. **Hemligheter och kryptering** (HIGH)
|
||
6. **Säkerhetsheaders** (MEDIUM)
|
||
7. **Automatiserade tester** (MEDIUM)
|
||
|
||
---
|
||
|
||
---
|
||
|
||
## 💡 **11. Tips för GitHub Copilot**
|
||
|
||
- **Var specifik:** Beskriv exakt vad du vill uppnå (t.ex. "Skapa en NestJS-guard för ägarskapskontroll").
|
||
- **Ge exempel:** Inkludera kodsnuttar för att visa vad du menar.
|
||
- **Be om tester:** Fråga Copilot att skapa **Jest-tester** för varje säkerhetsåtgärd.
|
||
- **Iterera:** Om svaret inte är perfekt, be Copilot att **förbättra** eller **förtydliga** koden.
|
||
|
||
---
|
||
|
||
---
|
||
|
||
## 🚀 **12. Nästa Steg**
|
||
|
||
1. **Börja med IDOR-skyddet** (steg 1.1–1.3).
|
||
2. **Gå vidare till Full Table Dump-skydd** (steg 2.1–2.3).
|
||
3. **Implementera Flutter-säkerhet** (steg 3.1–3.3).
|
||
4. **Säkra webhooks** (steg 4.1–4.2).
|
||
5. **Säkra hemligheter** (steg 5.1–5.3).
|
||
6. **Lägg till säkerhetsheaders** (steg 6.1).
|
||
7. **Automatisera tester** (steg 7.1–7.2).
|
||
8. **Dokumentera** (steg 8).
|
||
|
||
---
|
||
|
||
**Fråga till dig:**
|
||
Vill du att jag **anpassar planen ytterligare** för ett specifikt område (t.ex. endast backend eller endast Flutter)? Eller ska vi börja med **IDOR-skyddet** först? |