Edmund AI Documentation
/DOCUMENTATION

Security threats and mitigations

Threat modeling is part of the planning phase of the Edmund secure development lifecycle (E-SDL). The threats below are those that modeling has identified for the Edmund platform, together with the controls in place against each of them. The list is reviewed with each major release.

Unauthenticated API access

  • Component: Backend

  • Risk: An unauthorized user reaches data or performs an action reserved for authenticated users.

  • Mitigation: Authentication is enforced by default on every endpoint. The few endpoints that are intentionally public are configured individually and explicitly, so an endpoint is never public by omission.

Brute-force login attempts

  • Component: REST API authentication endpoints

  • Risk: An attacker guesses credentials, for example through a dictionary attack.

  • Mitigation: The number of failed login attempts per minute is limited for each e-mail address. In the Shared Cloud Deployment (SaaS), login and password reset requests are also rate-limited per source IP address at the network edge, before they reach the platform.

SQL injection through user input

  • Component: Backend

  • Risk: An attacker manipulates a database query to read or modify data they are not entitled to.

  • Mitigation: All user input is validated and sanitized. Database access goes through an object-relational mapper using parameterized queries; queries are never assembled from raw input. In the Shared Cloud Deployment (SaaS), a web application firewall with managed rule sets also blocks known injection patterns at the network edge.

Insecure or excessive file upload

  • Component: Backend

  • Risk: An uploaded file is executable, leading to remote code execution, or a volume of uploads exhausts platform resources and denies service to other users.

  • Mitigation: File extensions are validated on upload. Files are processed asynchronously, so a large number of uploads queues for processing rather than exhausting request capacity.

Denial of service through expensive queries

  • Component: Search endpoints and nested database queries

  • Risk: A high-cost query exhausts database resources.

  • Mitigation: Pagination and query limits are applied to endpoints that return collections, and database queries are profiled during development. Business-logic data and Edmund’s application data are held in separate databases, so load on one cannot exhaust the other.

Network-level denial of service

  • Component: Public endpoints of the platform

  • Risk: A flood of network or application traffic makes the platform unavailable to its users.

  • Mitigation: In the Shared Cloud Deployment (SaaS), all traffic passes through Cloudflare, which detects and mitigates distributed denial-of-service (DDoS) attacks automatically. The load balancer accepts connections only from Cloudflare’s network, so requests cannot reach the platform without passing through it.

Privilege escalation through role misconfiguration

  • Component: Administrative interface and role logic

  • Risk: A user obtains elevated or administrative access that was never granted to them.

  • Mitigation: Permissions are validated on every request and covered by unit tests. See Role Based Access Control (RBAC) for the permissions each level carries.

Data exposure between organizations, projects or teams

  • Component: User access

  • Risk: A user sees data belonging to an organization or project of which they are not a member.

  • Mitigation: Access scoping is implemented centrally in the application framework rather than separately per endpoint, so a user can only reach data within the projects they are assigned to. The behaviour is covered by unit tests and verified by manual testing before each major release. See Multitenancy.

Hardcoded secrets in the codebase

  • Component: Application and database configuration

  • Risk: Database passwords, secret keys or API tokens are exposed through version control.

  • Mitigation: Secrets are held in environment variables and in a managed secret store, never in source code. Automated scanning for secrets and other sensitive data runs as part of the development pipeline. Sensitive user data is encrypted.

Outdated dependencies with known vulnerabilities

  • Component: All third-party libraries

  • Risk: A published vulnerability in a dependency becomes exploitable in production.

  • Mitigation: Dependencies are monitored with GitHub Dependabot and container images are scanned with Trivy. Dependencies are updated and tested on a regular cycle. In the Shared Cloud Deployment (SaaS), the provider of the web application firewall updates its managed rule sets as new vulnerabilities are published, which protects the platform while a dependency update is prepared.

Weak passwords

  • Component: Registration and password change

  • Risk: A password is easy to guess, leading to account compromise.

  • Mitigation: A minimum password complexity is enforced. Edmund strongly recommends two-factor authentication (2FA) or single sign-on (SSO) in addition.

Logging of sensitive data

  • Component: All

  • Risk: Passwords, tokens or personal data are written to logs, most often through an unhandled exception.

  • Mitigation: Sensitive fields are declared and filtered in error reporting. Backend logic is written to keep sensitive values out of log output. Log retention periods are enforced; see Data classification & retention.

Indefinitely valid invitation and password reset tokens

  • Component: User invitation and password change

  • Risk: A token issued once remains usable indefinitely.

  • Mitigation: Invitation and password reset tokens carry a strict, enforced lifetime and cannot be reused once they expire.