Skip to content

Latest commit

 

History

History
347 lines (284 loc) · 18.6 KB

sec-design.md

File metadata and controls

347 lines (284 loc) · 18.6 KB

BUSINESS POSTURE

The primary business priority for the Insomnia project is to provide a user-friendly and efficient API client and design platform for developers. The goal is to streamline API development, testing, and debugging workflows, ultimately increasing developer productivity and reducing API integration time. This project aims to be a leading open-source API platform, fostering a strong community and potentially offering premium features or services in the future.

Key business risks associated with this project include:

  • Competition from other API platforms and tools.
  • Security vulnerabilities in the application that could lead to data breaches or reputational damage.
  • Lack of adoption by the target developer community.
  • Difficulty in monetizing the open-source project to ensure long-term sustainability.
  • Dependence on community contributions and maintenance.

SECURITY POSTURE

Existing security controls:

  • security control: Code reviews are likely performed as part of the development process, especially for contributions to an open-source project. (Location: Assumed based on common open-source practices)
  • security control: Input validation is likely implemented to prevent common web vulnerabilities like cross-site scripting (XSS) and injection attacks. (Location: Within the application codebase, specific locations not detailed without code inspection)
  • security control: Secure software development lifecycle (SSDLC) practices are likely followed to some extent, although the specifics are not explicitly documented. (Location: Assumed based on project maturity and open-source nature)
  • security control: HTTPS is enforced for communication with backend services for features like cloud sync. (Location: Assumed for cloud sync functionality)

Accepted risks:

  • accepted risk: Reliance on third-party libraries and dependencies, which may introduce vulnerabilities. (Mitigation: Dependency scanning and updates)
  • accepted risk: Potential for vulnerabilities in user-contributed plugins or extensions. (Mitigation: Plugin review process, sandboxing if applicable)
  • accepted risk: Risk of supply chain attacks targeting dependencies or build processes. (Mitigation: Dependency pinning, build process security)

Recommended security controls:

  • security control: Implement automated Static Application Security Testing (SAST) in the CI/CD pipeline to identify potential vulnerabilities in the codebase.
  • security control: Implement automated Dependency Scanning to identify vulnerabilities in third-party libraries and dependencies.
  • security control: Conduct regular penetration testing and vulnerability assessments to proactively identify and address security weaknesses.
  • security control: Implement a robust incident response plan to handle security incidents effectively.
  • security control: Enhance security awareness training for developers and contributors to promote secure coding practices.

Security requirements:

  • Authentication:
    • requirement: For cloud sync features, users should be authenticated securely.
    • requirement: Support for multi-factor authentication (MFA) should be considered for enhanced security of user accounts.
    • requirement: Authentication mechanisms should protect against common attacks like brute-force and credential stuffing.
  • Authorization:
    • requirement: Access to user data and cloud sync features should be properly authorized based on user roles and permissions.
    • requirement: Ensure proper authorization checks are in place to prevent unauthorized access to sensitive functionalities.
  • Input Validation:
    • requirement: All user inputs, including API requests, configurations, and plugin inputs, must be thoroughly validated to prevent injection attacks, XSS, and other input-related vulnerabilities.
    • requirement: Input validation should be performed on both client-side and server-side (if applicable for cloud sync features).
  • Cryptography:
    • requirement: Sensitive data, such as user credentials and API keys, should be encrypted both in transit and at rest.
    • requirement: Use strong and industry-standard cryptographic algorithms and libraries.
    • requirement: Implement secure key management practices for encryption keys.

DESIGN

C4 CONTEXT

flowchart LR
    subgraph "Organization"
        U["Developer"]
    end
    SystemBoundary(S)["Insomnia API Client"]
    R["REST APIs"]
    G["GraphQL APIs"]
    GRPC["gRPC APIs"]
    subgraph "Cloud Services"
        CS["Cloud Sync Service"]
    end

    U -->> S: Uses for API Design, Testing, Debugging
    S -->> R: Sends API Requests
    S -->> G: Sends GraphQL Queries
    S -->> GRPC: Sends gRPC Requests
    S --> CS: Syncs Configuration and Data
    CS --> U: Provides Cloud Sync Features
    style SystemBoundary fill:#f9f,stroke:#333,stroke-width:2px
Loading

Context Diagram Elements:

  • Name: Developer

    • Type: Person
    • Description: Software developers who use Insomnia to design, test, and debug APIs.
    • Responsibilities: Uses Insomnia to create, manage, and test APIs.
    • Security controls: User authentication for cloud sync features. Local account management for application settings.

  • Name: Insomnia API Client

    • Type: Software System
    • Description: Desktop application for API design, testing, and debugging of REST, GraphQL, and gRPC APIs.
    • Responsibilities: Provides a user interface for creating API requests, sending requests to API endpoints, and viewing responses. Manages API collections and environments. Offers cloud sync functionality.
    • Security controls: Input validation, secure storage of API keys and credentials (if applicable), secure communication with backend services (HTTPS), protection against common desktop application vulnerabilities.

  • Name: REST APIs

    • Type: External System
    • Description: Represent external RESTful APIs that developers interact with using Insomnia.
    • Responsibilities: Provides data and functionality to applications through RESTful interfaces.
    • Security controls: API security controls implemented by the API providers (e.g., authentication, authorization, rate limiting).

  • Name: GraphQL APIs

    • Type: External System
    • Description: Represent external GraphQL APIs that developers interact with using Insomnia.
    • Responsibilities: Provides data and functionality to applications through GraphQL interfaces.
    • Security controls: API security controls implemented by the API providers (e.g., authentication, authorization, rate limiting).

  • Name: gRPC APIs

    • Type: External System
    • Description: Represent external gRPC APIs that developers interact with using Insomnia.
    • Responsibilities: Provides data and functionality to applications through gRPC interfaces.
    • Security controls: API security controls implemented by the API providers (e.g., authentication, authorization, rate limiting).

  • Name: Cloud Sync Service

    • Type: External System
    • Description: Cloud-based service provided by Insomnia for syncing user configurations, API collections, and other data across multiple devices.
    • Responsibilities: Stores and synchronizes user data securely. Manages user accounts and authentication for cloud sync features.
    • Security controls: User authentication, authorization, data encryption in transit and at rest, access control, regular security audits.

C4 CONTAINER

flowchart LR
    subgraph "Developer Desktop"
        subgraph "Insomnia API Client"
            direction TB
            UI["User Interface (Electron)"]
            Core["Core Application Logic (JavaScript)"]
            Storage["Local Data Storage (Local Database)"]
            Plugins["Plugins (JavaScript/Node.js)"]
        end
    end
    subgraph "Cloud Services"
        Sync["Cloud Sync Service (Backend API)"]
        Auth["Authentication Service"]
    end

    UI -->> Core: Uses
    Core -->> Storage: Reads/Writes Data
    Core -->> Plugins: Loads and Executes
    Core -->> Sync: Syncs Data via HTTPS
    Core -->> Auth: Authenticates User via HTTPS
    style "Insomnia API Client" fill:#ccf,stroke:#333,stroke-width:2px
    style "Cloud Services" fill:#eef,stroke:#333,stroke-width:2px
Loading

Container Diagram Elements:

  • Name: User Interface

    • Type: Container
    • Description: Electron-based desktop application providing the user interface for Insomnia.
    • Responsibilities: Presents the user interface, handles user interactions, and displays API request and response data.
    • Security controls: Input validation on UI elements, protection against UI-based vulnerabilities (e.g., XSS in rendered content), secure handling of user credentials in the UI.

  • Name: Core Application Logic

    • Type: Container
    • Description: JavaScript code containing the core application logic for API request processing, data management, and plugin management.
    • Responsibilities: Handles API request construction, execution, and response processing. Manages local data storage and synchronization with the cloud service. Loads and executes plugins.
    • Security controls: Input validation, secure API request construction, secure handling of API keys and credentials, plugin sandboxing (if applicable), secure communication with backend services (HTTPS).

  • Name: Local Data Storage

    • Type: Container
    • Description: Local database (e.g., SQLite or similar embedded database) used to store user configurations, API collections, and other application data locally on the user's machine.
    • Responsibilities: Persistently stores application data. Provides data access to the Core Application Logic.
    • Security controls: Data encryption at rest (if sensitive data is stored locally), access control to the local database file, protection against local file system vulnerabilities.

  • Name: Plugins

    • Type: Container
    • Description: Extensible plugin system allowing users to extend Insomnia's functionality with custom JavaScript/Node.js plugins.
    • Responsibilities: Provides extensibility and customization. Executes user-provided code within the Insomnia application.
    • Security controls: Plugin review process (if applicable), plugin sandboxing or isolation to limit potential damage from malicious plugins, clear documentation and warnings about plugin security risks.

  • Name: Cloud Sync Service

    • Type: Container
    • Description: Backend API service responsible for synchronizing user data across multiple Insomnia instances.
    • Responsibilities: Stores and manages user data in the cloud. Provides API endpoints for data synchronization.
    • Security controls: User authentication and authorization, data encryption in transit and at rest, access control, API security controls (rate limiting, input validation), regular security audits.

  • Name: Authentication Service

    • Type: Container
    • Description: Service responsible for user authentication for cloud sync features.
    • Responsibilities: Manages user accounts, handles user login and registration, issues authentication tokens.
    • Security controls: Secure authentication protocols (e.g., OAuth 2.0, OpenID Connect), secure password storage (hashing and salting), protection against brute-force and credential stuffing attacks, multi-factor authentication (MFA).

DEPLOYMENT

Deployment Architecture Option: Desktop Application with Cloud Sync

flowchart LR
    subgraph "Developer's Machine"
        Desktop["Insomnia Desktop Application"]
    end
    subgraph "Cloud Infrastructure"
        LoadBalancer["Load Balancer"]
        subgraph "Application Servers"
            AppServer1["Application Server 1"]
            AppServer2["Application Server 2"]
            AppServerN["Application Server N"]
        end
        Database["Database Server"]
    end

    Desktop -->> LoadBalancer: HTTPS (Cloud Sync API)
    LoadBalancer -->> AppServer1
    LoadBalancer -->> AppServer2
    LoadBalancer -->> AppServerN
    AppServer1 -->> Database: Database Queries
    AppServer2 -->> Database: Database Queries
    AppServerN -->> Database: Database Queries
    style "Developer's Machine" fill:#eee,stroke:#333,stroke-width:2px
    style "Cloud Infrastructure" fill:#eee,stroke:#333,stroke-width:2px
    style "Application Servers" fill:#ccf,stroke:#333,stroke-width:2px
Loading

Deployment Diagram Elements:

  • Name: Insomnia Desktop Application

    • Type: Software
    • Description: Instance of the Insomnia desktop application running on a developer's machine.
    • Responsibilities: Provides API client functionality to the developer. Communicates with the Cloud Sync Service for data synchronization.
    • Security controls: Application-level security controls as described in the Container Diagram. Operating system and endpoint security controls on the developer's machine.

  • Name: Load Balancer

    • Type: Infrastructure
    • Description: Distributes incoming cloud sync API requests across multiple application servers.
    • Responsibilities: Load balancing, traffic routing, potentially SSL termination.
    • Security controls: DDoS protection, SSL/TLS configuration, access control lists (ACLs), web application firewall (WAF) if applicable.

  • Name: Application Server 1, 2, N

    • Type: Software
    • Description: Instances of the Cloud Sync Service backend application running on servers.
    • Responsibilities: Handles cloud sync API requests, processes data synchronization logic, interacts with the database.
    • Security controls: Application-level security controls for the Cloud Sync Service, operating system security hardening, network security controls (firewalls, intrusion detection/prevention systems).

  • Name: Database Server

    • Type: Infrastructure
    • Description: Database server storing user data for the Cloud Sync Service.
    • Responsibilities: Persistent storage of user data, data integrity, data availability.
    • Security controls: Database access control, data encryption at rest, database security hardening, regular backups, monitoring and auditing.

BUILD

flowchart LR
    subgraph "Developer Workstation"
        Developer["Developer"]
        CodeRepo["Code Repository (GitHub)"]
    end
    subgraph "CI/CD Pipeline (GitHub Actions)"
        BuildServer["Build Server (GitHub Actions Runner)"]
        SAST["SAST Scanner"]
        DependencyCheck["Dependency Check"]
        Linter["Linter"]
        ArtifactStorage["Artifact Storage"]
    end

    Developer -->> CodeRepo: Code Commit
    CodeRepo -->> BuildServer: Trigger Build
    BuildServer -->> SAST: Run SAST Scan
    BuildServer -->> DependencyCheck: Run Dependency Check
    BuildServer -->> Linter: Run Linter
    BuildServer -->> ArtifactStorage: Publish Artifacts
    style "Developer Workstation" fill:#eee,stroke:#333,stroke-width:2px
    style "CI/CD Pipeline (GitHub Actions)" fill:#eee,stroke:#333,stroke-width:2px
Loading

Build Process Diagram Elements:

  • Name: Developer

    • Type: Person
    • Description: Software developer writing and committing code changes.
    • Responsibilities: Writes code, performs local testing, commits code to the code repository.
    • Security controls: Secure coding practices, code review participation, workstation security.

  • Name: Code Repository

    • Type: Software
    • Description: GitHub repository hosting the Insomnia project source code.
    • Responsibilities: Version control, code storage, collaboration platform.
    • Security controls: Access control (branch permissions, repository permissions), audit logging, vulnerability scanning (GitHub Dependabot).

  • Name: Build Server

    • Type: Software
    • Description: GitHub Actions runner executing the CI/CD pipeline.
    • Responsibilities: Automates the build process, runs security checks, publishes build artifacts.
    • Security controls: Secure build environment, access control to CI/CD configuration, secrets management for build credentials.

  • Name: SAST Scanner

    • Type: Software
    • Description: Static Application Security Testing tool integrated into the CI/CD pipeline.
    • Responsibilities: Analyzes source code for potential security vulnerabilities.
    • Security controls: Configuration of SAST rules and policies, vulnerability reporting.

  • Name: Dependency Check

    • Type: Software
    • Description: Dependency scanning tool integrated into the CI/CD pipeline.
    • Responsibilities: Checks project dependencies for known vulnerabilities.
    • Security controls: Configuration of dependency vulnerability databases, vulnerability reporting.

  • Name: Linter

    • Type: Software
    • Description: Code linting tool integrated into the CI/CD pipeline.
    • Responsibilities: Enforces code style and quality standards, identifies potential code defects.
    • Security controls: Configuration of linting rules, code quality enforcement.

  • Name: Artifact Storage

    • Type: Software
    • Description: Storage location for build artifacts (e.g., compiled application binaries, installers).
    • Responsibilities: Stores and distributes build artifacts.
    • Security controls: Access control to artifact storage, integrity checks for build artifacts, secure artifact distribution channels.

RISK ASSESSMENT

Critical business processes to protect:

  • API design, testing, and debugging workflows for developers using Insomnia.
  • Cloud sync functionality for users who rely on it for data synchronization across devices.
  • The integrity and availability of the Insomnia application itself.
  • The reputation and trust associated with the Insomnia project.

Data to protect and sensitivity:

  • User credentials for cloud sync accounts (high sensitivity).
  • API keys and credentials stored within Insomnia configurations (high sensitivity).
  • User API collections, environments, and settings (medium sensitivity - potential business impact if lost or compromised).
  • Application source code and build artifacts (medium sensitivity - intellectual property, supply chain security).
  • User activity logs (low to medium sensitivity - audit trails, usage patterns).

QUESTIONS & ASSUMPTIONS

Questions:

  • What specific authentication mechanism is used for cloud sync? (e.g., OAuth 2.0, JWT)
  • Is multi-factor authentication (MFA) supported for cloud sync accounts?
  • What type of encryption is used for data at rest in local storage and in the cloud?
  • Are plugins sandboxed or isolated in any way to limit security risks?
  • Is there a formal plugin review process?
  • What specific SAST and dependency scanning tools are used in the CI/CD pipeline?
  • Is penetration testing or vulnerability assessment performed regularly?
  • Is there a documented incident response plan?

Assumptions:

  • Code reviews are performed for contributions.
  • Input validation is implemented in the application.
  • HTTPS is used for communication with cloud services.
  • Standard secure coding practices are generally followed.
  • The project aims to be secure and protect user data.
  • The deployment model described is a common scenario for desktop applications with cloud sync features.
  • GitHub Actions is used for CI/CD, which is common for GitHub-hosted projects.