Edmund AI Documentation
/DOCUMENTATION

Compliance

ISO27001

Edmund is ISO27001 ISMS compliant. See our ISO27001 certificate CZ and ENG in attachment “Edmund ISO27001 certificate.pdf”.

ISO42001

Edmund is also ISO42001 ISMS compliant. See our ISO42001 certificate CZ and ENG in attachment “Edmund ISO42001 certificate.pdf”.

AWS CIS Report

See AWS CIS Report in attachment with name “Edmund AWS CIS Report.pdf”. This vulnerability report showcases 100% health for our Cloud based infrastructure of Edmund.

Penetration testing

We are frequently going through penetration testing in our development cycle. See our latest report of penetration testing in attachment file with name “Edmund OWASP Penetration Testing Report.pdf”.

For the automated penetration testing we are using the globally recognized tool “OWASP ZAP”.

Our penetration testing methods go through the most common vulnerabilities that we can also find in the OWASP TOP 10:

1. Threat: Unauthenticated API Access ✓

  • Component: Backend

  • Risk: Unauthorized users may access data or perform actions.

  • Mitigation:

    • We enforce authentication by default for all endpoints.

    • We manually configure public endpoints.

2. Threat: Brute-force password login attempts ✓

  • Component: Django REST Framework (DRF) endpoints

  • Risk: Unauthorized users may attempt brute-force login attacks, e.g., with dictionary attacks.

  • Mitigation:

    • We limit the number of failed login attempts per minute for every email.

    • In the Shared Cloud Deployment (SaaS), we also rate-limit login and password reset requests per source IP address at the network edge (Cloudflare).

3. Threat: SQL injection in user Input ✓

  • Component: Backend

  • Risk: Attackers can manipulate queries to access or modify sensitive data.

  • Mitigation:

    • We sanitize and validate all user input.

    • We use ORM (Object-Relational Mapping) and parameterized queries.

    • In the Shared Cloud Deployment (SaaS), a web application firewall (Cloudflare) blocks known injection patterns at the network edge.

4. Threat: Insecure file upload or Denial of Service via Many File Uploads ✓

  • Component: Backend

  • Risk: Uploaded files could be executable or oversized, leading to Remote Code Execution (RCE) or Denial of Service (DoS).

  • Mitigation:

    • We validate file extensions.

    • We process files asynchronously to minimize the possible effect of Denial of Service.

5. Threat: Denial of Service (DoS) via heavy queries ✓

  • Component: Search endpoints or nested ORM queries

  • Risk: High-cost queries could exhaust database resources.

  • Mitigation:

    • We use pagination and query limits.

    • We profile database queries.

    • We maintain separate databases for business logic and document indexing.

6. Threat: Privilege escalation via role misconfiguration ✓

  • Component: Admin interface or custom role logic

  • Risk: Regular users may gain sales or admin access.

  • Mitigation:

    • We validate permissions and have unit tests in place.

7. Threat: Private data exposure between organizations/projects/teams ✓

  • Component: User access

  • Risk: A user might see data from another organization or project where they are not a member.

  • Mitigation:

    • We have built a framework solution to ensure that users can only see data within their authorized projects.

    • We have unit testing in place.

    • We conduct manual testing with each major release.

8. Threat: Hardcoded secrets in codebase ✓

  • Component: Django and user database configuration, etc.

  • Risk: Exposure of database passwords, secret keys, or API tokens in version control.

  • Mitigation:

    • We store secrets in environment variables or secret management tools (e.g., AWS Secrets Manager).

    • We encrypt user-sensitive data.

9. Threat: Outdated dependencies with known vulnerabilities ✓

  • Component: All installed libraries

  • Risk: Vulnerabilities in libraries like Django, DRF, or Pillow.

  • Mitigation:

    • We use GitHub Dependabot and Trivy.

    • We regularly update and test dependencies.

10. Threat: Weak password policies ✓

  • Component: User registration and change-password processes

  • Risk: Easy-to-guess passwords leading to account compromise.

  • Mitigation:

    • We enforce minimum password complexity.

    • We highly recommend using two-factor authentication (2FA) or Single Sign-On (SSO).

11. Threat: Logging sensitive data ✓

  • Component: All

  • Risk: Passwords, tokens, or Personally Identifiable Information (PII) accidentally logged, especially in exceptions.

  • Mitigation:

    • We use sensitive fields and filters in Sentry.

    • We use backend logic to not log sensitive data.

    • We implement log retention policies.

12. Threat: Invite token and password reset token validity ✓

  • Component: User invitation and change-password processes

  • Risk: Tokens are valid forever.

  • Mitigation:

    • We enforce strict token lifetime.

Vulnerability report

We are frequently going through vulnerability scans during our development life-cycle. See in attachment our vulnerability reports “Edmund Vulnerability Django Report.pdf”, “Edmund Vulnerability Celery Report.pdf” and “Edmund Vulnerability Frontend Report.pdf” from DockerScout software.