(WIP)

.github/workflows/c4po-ci.yml

@@ -1,106 +0,0 @@
-# This workflow uses actions that are not certified by GitHub.
-# They are provided by a third-party and are governed by
-# separate terms of service, privacy policy, and support
-# documentation.
-
-# GitHub recommends pinning actions to a commit SHA.
-# To get a newer version, you will need to update the SHA.
-# You can also reference a tag or branch, but the action may change without warning.
-
-name: "CI: Clean Build C4PO"
-
-on:
-  pull_request:
-    branches: [ "main" ]
-
-
-env:
-  ANGULAR_PATH: security-c4po-angular
-  API_PATH: security-c4po-api
-  REPORTING_PATH: security-c4po-reporting
-  CFG_PATH: security-c4po-cfg
-
-  ANGULAR_CLI_VERSION: 15
-
-
-jobs:
-
-  angular_job:
-    name: "Angular Job"
-
-    runs-on: ubuntu-latest
-    
-    steps:
-      - name: "Check out code"
-        uses: actions/checkout@v3
-
-      - name: "Use Node.js 16.x"
-        uses: actions/setup-node@v1
-        with:
-          node-version: '16.x'
-          cache: 'npm'
-          
-      - name: "Install NPM dependencies"
-        run: |
-          cd $ANGULAR_PATH
-          npm ci
-
-      - name: "Build assets"
-        run: |
-          cd $ANGULAR_PATH
-          npm run build --if-present
-
-      - name: "Run tests"
-        run: |
-          cd $ANGULAR_PATH
-          npm test
-  
-  api_job:
-    name: "API Job"
-
-    runs-on: ubuntu-latest
-    
-    steps:
-      - name: "Check out code"
-        uses: actions/checkout@v3
-
-      - name: "Set up JDK 11"
-        uses: actions/setup-java@v3
-        with:
-          java-version: '11'
-          distribution: 'temurin'
-
-      - name: "Setup Gradle"
-        uses: gradle/gradle-build-action@v2
-        with:
-          gradle-version: 6.5
-
-      - name: "Execute Gradle build"
-        run: |
-          cd $API_PATH
-          ./gradlew clean build -x dependencyCheckAnalyze
-
-  reporting_job:
-    name: "Reporting Job"
-
-    runs-on: ubuntu-latest
-    
-    steps:
-      - name: "Check out code"
-        uses: actions/checkout@v3
-
-      - name: "Set up JDK 11"
-        uses: actions/setup-java@v3
-        with:
-          java-version: '11'
-          distribution: 'temurin'
-
-      - name: "Setup Gradle"
-        uses: gradle/gradle-build-action@v2
-        with:
-          gradle-version: 6.5
-
-      - name: "Execute Gradle build"
-        run: |
-          cd $REPORTING_PATH
-          ./gradlew clean build

.github/workflows/c4po-release.yml

@@ -1,173 +0,0 @@
-# This workflow uses actions that are not certified by GitHub.
-# They are provided by a third-party and are governed by
-# separate terms of service, privacy policy, and support
-# documentation.
-
-# GitHub recommends pinning actions to a commit SHA.
-# To get a newer version, you will need to update the SHA.
-# You can also reference a tag or branch, but the action may change without warning.
-
-name: "CD: Publish C4PO to Docker Hub"
-
-on:
-  push:
-    branches: [ "main" ]
-
-env:
-  ANGULAR_PATH: security-c4po-angular
-  API_PATH: security-c4po-api
-  REPORTING_PATH: security-c4po-reporting
-  CFG_PATH: security-c4po-cfg
-
-jobs:
-
-  angular_job:
-    name: "Angular Job"
-
-    runs-on: ubuntu-latest
-    
-    steps:
-      - name: "Check out code"
-        uses: actions/checkout@v3
-
-      - name: "Use Node.js 16.x"
-        uses: actions/setup-node@v1
-        with:
-          node-version: '16.x'
-          cache: 'npm'
-          
-      - name: "Install NPM dependencies"
-        run: |
-          cd $ANGULAR_PATH
-          npm ci
-
-      - name: "Build assets"
-        run: |
-          cd $ANGULAR_PATH
-          npm run build --if-present
-
-      - name: "Run tests"
-        run: |
-          cd $ANGULAR_PATH
-          npm test
-  
-  api_job:
-    name: "API Job"
-
-    runs-on: ubuntu-latest
-    
-    steps:
-      - name: "Check out code"
-        uses: actions/checkout@v3
-
-      - name: "Set up JDK 11"
-        uses: actions/setup-java@v3
-        with:
-          java-version: '11'
-          distribution: 'temurin'
-
-      - name: "Setup Gradle"
-        uses: gradle/gradle-build-action@v2
-        with:
-          gradle-version: 6.5
-
-      - name: "Execute Gradle build"
-        run: |
-          cd $API_PATH
-          ./gradlew clean bootJar -x dependencyCheckAnalyze
-
-      - uses: actions/upload-artifact@v3
-        with:
-          name: API-jar
-          path: security-c4po-api/build/libs/
-
-  reporting_job:
-    name: "Reporting Job"
-
-    runs-on: ubuntu-latest
-    
-    steps:
-      - name: "Check out code"
-        uses: actions/checkout@v3
-
-      - name: "Set up JDK 11"
-        uses: actions/setup-java@v3
-        with:
-          java-version: '11'
-          distribution: 'temurin'
-
-      - name: "Setup Gradle"
-        uses: gradle/gradle-build-action@v2
-        with:
-          gradle-version: 6.5
-
-      - name: "Execute Gradle build"
-        run: |
-          cd $REPORTING_PATH
-          ./gradlew clean bootJar
-
-      - uses: actions/upload-artifact@v3
-        with:
-          name: REPORTING-jar
-          path: security-c4po-reporting/build/libs/
-
-  push_c4po_to_docker_hub:
-    name: "Push images to Docker Hub"
-
-    runs-on: ubuntu-latest
-
-    needs: [angular_job, api_job, reporting_job]
-
-    steps:
-      - name: "Check out the repo"
-        uses: actions/checkout@v3
-
-      - name: "Log in to Docker Hub"
-        uses: docker/login-action@f4ef78c080cd8ba55a85445d5b36e214a81df20a
-        with:
-          username: ${{ secrets.DOCKER_HUB_USERNAME }}
-          password: ${{ secrets.DOCKER_HUB_TOKEN }}
-
-      - name: "Extract metadata (tags, labels) for Docker"
-        id: meta
-        uses: docker/metadata-action@9ec57ed1fcdbf14dcef7dfbe97b2010124a938b7
-        with:
-          images: cellecram/security-c4po  # my-docker-hub-namespace/my-docker-hub-repository
-
-      - name: Download jar api artifact
-        uses: actions/download-artifact@v3
-        with:
-          name: API-jar
-          path: security-c4po-api/build/libs/
-
-      - name: Download jar reporting artifact
-        uses: actions/download-artifact@v3
-        with:
-          name: REPORTING-jar
-          path: security-c4po-reporting/build/libs/
-
-      - name: "Set up Docker Buildx"
-        uses: docker/setup-buildx-action@94ab11c41e45d028884a99163086648e898eed25 #v1
-
-      - name: "Buildx & Push Docker images for AMD64 & ARM64"
-        run: |
-          cd $CFG_PATH
-          docker buildx build --push \
-          --platform linux/amd64,linux/arm64 \
-          --tag cellecram/security-c4po:mongo ./c4po-db
-          docker buildx build --push \
-          --platform linux/amd64,linux/arm64 \
-          --tag cellecram/security-c4po:keycloak ./c4po-keycloak
-          docker buildx build --push \
-          --build-arg JAR_FILE_REPORT=./build/libs/security-c4po-reporting-0.0.1-SNAPSHOT.jar \
-          --build-arg SPRING_PROFILES_ACTIVE=COMPOSE \
-          --platform linux/amd64,linux/arm64 \
-          --tag cellecram/security-c4po:reporting ../security-c4po-reporting
-          docker buildx build --push \
-          --build-arg JAR_FILE_API=./build/libs/security-c4po-api-0.0.1-SNAPSHOT.jar \
-          --build-arg SPRING_PROFILES_ACTIVE=COMPOSE \
-          --platform linux/amd64,linux/arm64 \
-          --tag cellecram/security-c4po:api ../security-c4po-api
-          docker buildx build --push \
-          --platform linux/amd64,linux/arm64 \
-          --tag cellecram/security-c4po:angular ../security-c4po-angular

CONTRIBUTING.md

@@ -1,56 +0,0 @@
-# Contributing to Security-C4PO
-
-First off, thanks for taking the time to contribute! 👍
-
-The following is a set of guidelines for contributing to this project and its packages, which are hosted on GitHub. 
-These are mostly guidelines, not rules. Use your best judgment, and feel free to propose changes to this document in a pull request.
-
-## How Can I Contribute?
-
-### Reporting Bugs
-This section guides you through submitting a bug report. Following these guidelines helps maintainers and the community understand your report.
-
-Explain the problem and include additional details to help maintainers reproduce the problem:
-
-* **Use a clear and descriptive title** for the issue to identify the problem.
-* **Describe the exact steps which reproduce the problem** in as many details as possible. For example, start by explaining how you started the application, e.g. which command exactly you used in the terminal, or how you started the application otherwise. When listing steps, **don't just say what you did, but explain how you did it**. 
-* **Describe the behavior you observed after following the steps** and point out what exactly is the problem with that behavior.
-* **Explain which behavior you expected to see instead and why.**
-* **Include screenshots and animated GIFs** which show you following the described steps and clearly demonstrate the problem.
-* **If the problem wasn't triggered by a specific action**, describe what you were doing before the problem happened.
-
-### Suggesting Enhancements
-
-This section guides you through submitting an enhancement suggestion, including completely new features and minor improvements to existing functionality. 
-Following these guidelines helps maintainers and the community understand your suggestion :pencil: and find related suggestions :mag_right:.
-* **Use a clear and descriptive title** for the issue to identify the suggestion.
-* **Provide a step-by-step description of the suggested enhancement** in as many details as possible.
-* **Include screenshots, mock-ups or animated GIFs** which help you demonstrate the steps or point out the part which the suggestion is related to.
-* **Explain why this enhancement would be useful**
-
-## Code of Conduct
-
-Use the following conventions:
-* Branch: `<initial>_c4po_<issuenumber>`
-* Commit: `feat: <What was implemented?>` or `fix: <What got fixed?>`
-By participating, you are expected to uphold this code.
-
-## Local development
-Security-C4PO and all it's included micorservices can be developed locally. 
-Execute `c4po-dev.sh` and all services will run on a dev server.
-
-#### Testuser Credentials:
-* Username: c4po
-* Password: Test1234!
-
-#### Technical Environment Requirements
-* Docker / Docker-compose
-* OpenJDK 11
-* Node 14.15.1 / npm 6.14.8
-
-#### Helpfull Tools
-* mongoDB Compass
-* Postman
-
-## Issue Board
-[C4PO Board](https://github.com/Marcel-Haag/security-c4po/projects/1)

LICENSE.md

@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [2020] [Marcel Haag]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

README.md

@@ -1,94 +1,43 @@
-![workflow_badge](https://github.com/Marcel-Haag/security-c4po/actions/workflows/c4po-ci.yml/badge.svg?branch=main)
-![workflow_badge](https://github.com/Marcel-Haag/security-c4po/actions/workflows/c4po-release.yml/badge.svg?branch=main)
-[![OWASP Incubator](https://img.shields.io/badge/owasp-incubator%20project-3267fe.svg)](https://owasp.org/other_projects/)<!-- @IGNORE PREVIOUS: link -->
+# security-c4po
 
+### Chief Innovator
+> Daniel Mader
 
-![alt architecture](./wiki/repository-owasp-guide-c4po.png)
+### Project Leads
+* Andreas Falk
+* Christina Paule
 
-Welcome to the frontend repository of Security C4PO, an open-source pentest reporting tool.
-Security C4PO is a powerful, user-friendly tool designed to simplify the process of generating professional pentest reports.
-It aims to streamline and automate the often time-consuming task of creating comprehensive reports by providing an intuitive web-based interface that facilitates the content of the [OWASP TESTING GUIDE](https://owasp.org/www-project-web-security-testing-guide/v42/).
+### Developers
+* Marcel Haag
+* Norman Schmidt
+* Stipe Knez
 
-This repository contains the codebase of Security C4PO, built with an Angular Frontend and two Spring Boot Backend Microservices.
+### Technical Requirements
+* Docker / Docker-compose
+* OpenJDK 11
+* Node 14.15.1 / npm 6.14.8
+* MongoDB 4.4.6
 
-[![YouTube](https://img.shields.io/badge/YouTube-%23FF0000.svg?style=for-the-badge&logo=YouTube&logoColor=white)](https://www.youtube.com/channel/UCDwRRDVepRUowI0NmBy_9lQ)
+### Tools
+* mongoDB Compass
+* Postman
 
-
-## Table of Contents
-* [Docker Hub Setup](#docker-hub-setup)
-* [Application Architecture](#application-architecture)
-* [Data Structure](#data-structure)
-* [C4PO Roadmap](#c4po-roadmap)
-* [Project](#project)
-  * [Technical Requirements](#technical-requirements)
-  * [Tools](#tools)
-  * [Conventions](#conventions)
-  * [Development server](#development-server)
-  * [Testuser Credentials](#testuser-credentials)
-* [Contributing](#contributing)
-* [License](#license)
-
-## Docker Hub Setup
-[![Docker](https://img.shields.io/badge/docker-%230db7ed.svg?style=for-the-badge&logo=docker&logoColor=white)](https://hub.docker.com/repository/docker/cellecram/security-c4po/general)
-* Pull all images:
-  * `docker image pull --all-tags cellecram/security-c4po`
-* Create network: 
-  * `docker network create -d bridge c4po`
-* Start images:
-  * `docker run --network=c4po --name c4po-keycloak -d -p 8080:8080 cellecram/security-c4po:keycloak`
-  * `docker run --network=c4po --name c4po-db -d -p 27017:27017 cellecram/security-c4po:mongo`
-  * `docker run --network=c4po --name c4po-angular -d -p 4200:4200 cellecram/security-c4po:angular`
-  * `docker run --network=c4po -e "SPRING_PROFILES_ACTIVE=COMPOSE" --name c4po-api -d -p 8443:8443 cellecram/security-c4po:api`
-  * `docker run --network=c4po -e "SPRING_PROFILES_ACTIVE=COMPOSE" --name c4po-reporting -d -p 8444:8444 cellecram/security-c4po:reporting`
-
-### OR: Run Script (Docker Hub)
-Execute `c4po-prod.sh` and all services will be pulled from Docker Hub and started.
-You can reach the application by entering http://localhost:4200 in you browser.
-  
 ## Application Architecture
 ![alt architecture](./wiki/C4PO-Architecture.png)
 
 ## Data Structure
 ![alt datastructure](./wiki/C4PO-Datastructure.png)
 
-## C4PO Roadmap
-![alt roadmap](./wiki/C4PO-Roadmap.png)
-
-## Project
-
-![Angular](https://img.shields.io/badge/angular-%23DD0031.svg?style=for-the-badge&logo=angular&logoColor=white)
-![RxJS](https://img.shields.io/badge/rxjs-%23B7178C.svg?style=for-the-badge&logo=reactivex&logoColor=white)
-![Spring](https://img.shields.io/badge/spring-%236DB33F.svg?style=for-the-badge&logo=spring&logoColor=white)
-![Gradle](https://img.shields.io/badge/Gradle-02303A.svg?style=for-the-badge&logo=Gradle&logoColor=white)
-![MongoDB](https://img.shields.io/badge/MongoDB-%234ea94b.svg?style=for-the-badge&logo=mongodb&logoColor=white)
-
-### Technical Requirements
-* Docker / Docker-compose
-* OpenJDK 11
-* Node 16.20.2 / npm 8.19.4
-* MongoDB 4.4.6
-
-### Tools
-* mongoDB Compass
-* Postman
-* Jaspersoft Studio
-
 ### Conventions
 * Branch: `<initial>_c4po_<issuenumber>`
 * Commit: `feat: <What was implemented?>` or `fix: <What got fixed?>`
 
 ### Development server
-Execute `c4po-dev.sh` and all services will run on a dev server.
-You can reach the application by entering http://localhost:4200 in you browser.
+Execute 'c4po.sh' and all services will run on a dev server.
 
-### Testuser Credentials
-* Username: c4po
+### Testuser Credentials:
+* Username: ttt
 * Password: Test1234!
 
-## Contributing
-Contributions to Security C4PO are welcome! If you'd like to contribute to the project, please follow the guidelines outlined in the [CONTRIBUTING.md](https://github.com/marcel-haag/security-c4po/blob/main/CONTRIBUTING.md) file.
-
-## License
-Security C4PO is licensed under the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0) License. Please see the [LICENSE](https://github.com/marcel-haag/security-c4po/blob/main/LICENSE.md) file for more information.
-
-We hope you find Security C4PO useful for managing and generating pentest reports. If you encounter any issues or have suggestions for improvement, please feel free to create an issue on the [issue tracker](https://github.com/Marcel-Haag/security-c4po/issues).
+## C4PO Roadmap
+![alt roadmap](./wiki/C4PO-Roadmap.png)

THIRD-PARTY-LICENSES.md

@@ -1,13 +0,0 @@
-## Dependency License Report for security-c4po SNAPSHOT
-
-#### Example
-
-1. Group: antlr  Name: antlr  Version: 2.7.7
-
-POM Project URL: http://www.antlr.org/
-
-POM License: BSD License - http://www.antlr.org/license.html
-
---------------------------------------------------------------------------------
-
-This report was generated at Thu Oct 01 09:28:53 CEST 2020.

c4po-prod.sh

@@ -1,35 +0,0 @@
-#!/bin/bash
-baseDir=$(pwd)
-compose=$baseDir"/security-c4po-cfg/docker-compose.yml"
-
-echo -e "
-_______ _______ _______ _     _  ______ _____ _______ __   __
-|______ |______ |       |     | |_____/   |      |      \_/
-______| |______ |_____  |_____| |    \_ __|__    |       |         _/_/_/     _/  _/       _/_/_/         _/_/
-                                                                _/           _/  _/       _/    _/     _/    _/
-                                                               _/           _/_/_/_/     _/_/_/       _/    _/
-                                                              _/               _/       _/           _/    _/
-                                                               _/_/_/         _/       _/             _/_/
-\n"
-
-echo "---------------Pull C4PO from Docker Hub----------------"
-echo -e "\n"
-docker image pull --all-tags cellecram/security-c4po
-echo -e "\n"
-
-echo "---------------Create Network----------------"
-echo -e "\n"
-docker network create -d bridge c4po
-echo -e "\n"
-
-echo "---------------Start Containers---------------"
-echo -e "\n"
-docker run --network=c4po --name c4po-keycloak -d -p 8080:8080 cellecram/security-c4po:keycloak
-echo -e "\n"
-docker run --network=c4po --name c4po-db -d -p 27017:27017 cellecram/security-c4po:mongo
-echo -e "\n"
-docker run --network=c4po --name c4po-angular -d -p 4200:4200 cellecram/security-c4po:angular
-echo -e "\n"
-docker run --network=c4po -e "SPRING_PROFILES_ACTIVE=COMPOSE" --name c4po-api -d -p 8443:8443 cellecram/security-c4po:api
-echo -e "\n"
-docker run --network=c4po -e "SPRING_PROFILES_ACTIVE=COMPOSE" --name c4po-reporting -d -p 8444:8444 cellecram/security-c4po:reporting

c4po.sh

@@ -1,6 +1,10 @@
 #!/bin/bash
 baseDir=$(pwd)
+
+composeDir=$baseDir"/security-c4po-cfg"
 compose=$baseDir"/security-c4po-cfg/docker-compose.yml"
+keycloakVolume="security-c4po-cfg/volumes/keycloak/data/*"
+mongoVolume="security-c4po-cfg/volumes/mongodb/data/*"
 
 echo -e "
 _______ _______ _______ _     _  ______ _____ _______ __   __
@@ -14,29 +18,22 @@ ______| |______ |_____  |_____| |    \_ __|__    |       |         _/_/_/     _/
 
 echo "-------------CLEAN UP Container---------------"
 echo -e "\n"
-#docker rm -f c4po-keycloak     ### toggle to clear keycloak with every start ###
-#docker rm -f c4po-db           ### toggle to clear database with every start ###
-docker rm -f c4po-reporting
+rm -r ${keycloakVolume}
+docker rm -f c4po-keycloak
+docker rm -f c4po-keycloak-postgres
+docker rm -f c4po-db
 docker rm -f c4po-api
 docker rm -f c4po-angular
 echo -e "\n"
-
 echo "-----------------Start Build------------------"
-echo " - Report Engine: "
-docker-compose -f ${compose} build c4po-db
-echo " - Report Engine: "
-docker-compose -f ${compose} build c4po-keycloak
-echo -e "\n"
-echo " - Report Engine: "
-docker-compose -f ${compose} build c4po-reporting --build-arg JAR_FILE_REPORT=./build/libs/security-c4po-reporting-0.0.1-SNAPSHOT.jar ### toggle for additional build args ###
 echo -e "\n"
 echo " - Backend: "
-docker-compose -f ${compose} build c4po-api --build-arg JAR_FILE_API=./build/libs/security-c4po-api-0.0.1-SNAPSHOT.jar ### toggle for additional build args ###
+docker-compose -f ${compose} build c4po-api
 echo -e "\n"
 echo " - Frontend: "
-docker-compose -f ${compose} build c4po-angular
+#docker-compose -f ${compose} build c4po-angular
 echo -e "\n"
 
 echo "------------Start Docker Container------------"
 echo -e "\n"
-docker-compose -f ${compose} up
+ docker-compose -f ${compose} up # --scale c4po-angular=0

security-c4po-angular/.browserslistrc

@@ -0,0 +1,18 @@
+# This file is used by the build system to adjust CSS and JS output to support the specified browsers below.
+# For additional information regarding the format and rule options, please see:
+# https://github.com/browserslist/browserslist#queries
+
+# For the full list of supported browsers by the Angular framework, please see:
+# https://angular.io/guide/browser-support
+
+# You can see what browsers were selected by your queries by running:
+#   npx browserslist
+
+last 1 Chrome version
+last 1 Firefox version
+last 2 Edge major versions
+last 2 Safari major versions
+last 2 iOS major versions
+Firefox ESR
+not IE 9-10 # Angular support for IE 9-10 has been deprecated and will be removed as of Angular v11. To opt-in, remove the 'not' prefix on this line.
+not IE 11 # Angular supports IE 11 only as an opt-in. To opt-in, remove the 'not' prefix on this line.

security-c4po-angular/.gitignore

@@ -44,6 +44,3 @@ testem.log
 # System Files
 .DS_Store
 Thumbs.db
-
-# Chache
-.angular/*

security-c4po-angular/Dockerfile

@@ -1,5 +1,5 @@
 # base image
-FROM node:14
+FROM node:14.15.3
 
 # set working directory
 WORKDIR /app
@@ -9,11 +9,13 @@ ENV PATH /app/node_modules/.bin:$PATH
 
 # install and cache app dependencies
 COPY package.json /app/package.json
-RUN NODE_ENV=development npm install
-RUN NODE_ENV=development npm install -g @angular/cli@12.2.17
+RUN npm install
+RUN npm install -g @angular/cli@12.2.17
 
 # add app
 COPY . /app
 
 # start app
-CMD ng serve --host 0.0.0.0
+CMD ng serve -c compose --host 0.0.0.0
+
+# -------------------------------------------------------------

security-c4po-angular/README.md

@@ -1,6 +1,6 @@
-# Security C4PO Angular
+# SecurityC4poAngular
 
-This Angular application serves as the frontend interface for Security C4PO, allowing users to efficiently manage and generate comprehensive reports for their penetration testing activities.
+This project was generated with [Angular CLI](https://github.com/angular/angular-cli) version 10.2.0.
 
 ## Development server
 
@@ -16,19 +16,12 @@ Run `ng build` to build the project. The build artifacts will be stored in the `
 
 ## Running unit tests
 
-Run `ng test` to execute the unit tests via [Jest](https://jestjs.io/).
+Run `ng test` to execute the unit tests via [Karma](https://karma-runner.github.io).
 
 ## Running end-to-end tests
 
-Run `ng e2e` to execute the end-to-end tests via [Cypress](https://www.cypress.io/).
+Run `ng e2e` to execute the end-to-end tests via [Protractor](http://www.protractortest.org/).
 
 ## Further help
 
 To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI Overview and Command Reference](https://angular.io/cli) page.
-
-## Contributing
-
-Pull requests are welcome. For major changes, please open an issue first
-to discuss what you would like to change.
-
-Please make sure to read our [contributing guideline](https://github.com/marcel-haag/security-c4po/blob/main/CONTRIBUTING.md).

security-c4po-angular/angular.json

@@ -28,21 +28,14 @@
               "src/assets"
             ],
             "styles": [
-              "src/assets/@theme/styles/styles.scss",
-              "node_modules/@fortawesome/fontawesome-free/css/all.css",
-              "node_modules/@glidejs/glide/src/assets/sass/glide.core.scss",
-              "node_modules/@glidejs/glide/src/assets/sass/glide.theme.scss"
-            ],
-            "scripts": [
-              "node_modules/@fortawesome/fontawesome-free/js/all.js"
+              "src/assets/@theme/styles/styles.scss"
             ],
+            "scripts": [],
             "allowedCommonJsDependencies": [
               "buffer",
               "crypto-js/hmac-sha256",
               "crypto-js/lib-typedarrays",
               "js-cookie",
-              "chartjs-plugin-annotation",
-              "chart.js",
               "deep-equal",
               "moment-timezone",
               "uuid"
@@ -72,8 +65,8 @@
               "budgets": [
                 {
                   "type": "initial",
-                  "maximumWarning": "5mb",
-                  "maximumError": "8mb"
+                  "maximumWarning": "3mb",
+                  "maximumError": "5mb"
                 },
                 {
                   "type": "anyComponentStyle",
@@ -81,16 +74,36 @@
                 }
               ]
             },
-            "development": {
-              "buildOptimizer": false,
-              "optimization": false,
-              "vendorChunk": true,
-              "extractLicenses": false,
-              "sourceMap": true,
-              "namedChunks": true
+            "compose": {
+              "fileReplacements": [
+                {
+                  "replace": "src/environments/environment.ts",
+                  "with": "src/environments/environment.compose.ts"
+                }
+              ],
+              "optimization": true,
+              "outputHashing": "all",
+              "sourceMap": false,
+              "extractCss": true,
+              "namedChunks": false,
+              "aot": true,
+              "extractLicenses": true,
+              "vendorChunk": false,
+              "buildOptimizer": true,
+              "budgets": [
+                {
+                  "type": "initial",
+                  "maximumWarning": "3mb",
+                  "maximumError": "5mb"
+                },
+                {
+                  "type": "anyComponentStyle",
+                  "maximumWarning": "6kb"
+                }
+              ]
             }
           },
-          "defaultConfiguration": "production"
+          "defaultConfiguration": ""
         },
         "serve": {
           "builder": "@angular-devkit/build-angular:dev-server",
@@ -99,7 +112,10 @@
           },
           "configurations": {
             "production": {
-              "browserTarget": "security-c4po-angular:build:development"
+              "browserTarget": "security-c4po-angular:build:production"
+            },
+            "compose": {
+              "browserTarget": "security-c4po-angular:build:compose"
             }
           }
         },
@@ -155,6 +171,7 @@
       }
     }
   },
+  "defaultProject": "security-c4po-angular",
   "cli": {
     "analytics": false
   }

security-c4po-angular/package.json

@@ -11,67 +11,62 @@
   },
   "private": true,
   "dependencies": {
-    "@angular/animations": "^15.2.10",
-    "@angular/cdk": "^15.2.9",
-    "@angular/common": "^15.2.10",
-    "@angular/compiler": "^15.2.10",
-    "@angular/core": "^15.2.10",
-    "@angular/flex-layout": "^15.0.0-beta.42",
-    "@angular/forms": "^15.2.10",
-    "@angular/localize": "^15.2.10",
-    "@angular/platform-browser": "^15.2.10",
-    "@angular/platform-browser-dynamic": "^15.2.10",
-    "@angular/router": "^15.2.10",
-    "@fortawesome/angular-fontawesome": "^0.10.0",
+    "@angular/animations": "^12.2.16",
+    "@angular/cdk": "^12.2.7",
+    "@angular/common": "^12.2.16",
+    "@angular/compiler": "~12.2.16",
+    "@angular/core": "~12.2.16",
+    "@angular/flex-layout": "^11.0.0-beta.33",
+    "@angular/forms": "~12.2.16",
+    "@angular/localize": "^12.2.16",
+    "@angular/platform-browser": "~12.2.16",
+    "@angular/platform-browser-dynamic": "~12.2.16",
+    "@angular/router": "~12.2.16",
+    "@fortawesome/angular-fontawesome": "^0.8.2",
     "@fortawesome/fontawesome-common-types": "^0.2.36",
-    "@fortawesome/fontawesome-svg-core": "^6.3.0",
-    "@fortawesome/free-regular-svg-icons": "^6.3.0",
-    "@fortawesome/free-solid-svg-icons": "^6.3.0",
-    "@glidejs/glide": "^3.6.0",
-    "@nebular/eva-icons": "^11.0.1",
-    "@nebular/theme": "^11.0.1",
-    "@ngneat/until-destroy": "^9.2.3",
-    "@ngx-translate/core": "^14.0.0",
+    "@fortawesome/fontawesome-svg-core": "^1.2.36",
+    "@fortawesome/free-regular-svg-icons": "^5.15.4",
+    "@fortawesome/free-solid-svg-icons": "^5.15.4",
+    "@nebular/eva-icons": "^8.0.0",
+    "@nebular/theme": "^8.0.0",
+    "@ngneat/until-destroy": "~8.0.4",
+    "@ngx-translate/core": "^13.0.0",
     "@ngx-translate/http-loader": "^6.0.0",
-    "@ngxs/storage-plugin": "^3.7.3",
     "@ngxs/store": "^3.7.3",
-    "chart.js": "^4.2.1",
-    "deep-equal": "^2.0.5",
     "eva-icons": "^1.1.3",
-    "font-awesome": "^4.7.0",
     "i18n-iso-countries": "^6.8.0",
     "jwt-decode": "^3.1.2",
-    "keycloak-angular": "^13.1.0",
-    "keycloak-js": "^18.0.0",
+    "keycloak-angular": "^8.4.0",
+    "keycloak-js": "^13.0.1",
     "moment": "^2.29.1",
     "moment-timezone": "latest",
-    "ng-mocks": "^14.12.2",
-    "ngx-glide": "^15.0.0",
+    "ng-mocks": "^13.4.2",
     "ngx-moment": "^5.0.0",
-    "ngx-translate-testing": "^6.0.0",
+    "ngx-take-until-destroy": "^5.4.0",
+    "ngx-translate-testing": "^5.2.0",
     "roboto-fontface": "^0.10.0",
-    "rxjs": "^7.8.0",
+    "rxjs": "^6.6.7",
     "tslib": "^2.3.1",
     "uuid": "^8.3.1",
     "zone.js": "~0.11.4"
   },
   "devDependencies": {
-    "@angular-builders/jest": "^15.0.0",
-    "@angular-devkit/build-angular": "^15.2.11",
-    "@angular/cli": "^15.2.11",
-    "@angular/compiler-cli": "^15.2.10",
+    "@angular-builders/jest": "14.0.0",
+    "@angular-devkit/build-angular": "~12.2.16",
+    "@angular/cli": "^12.2.16",
+    "@angular/compiler-cli": "~12.2.16",
     "@babel/preset-typescript": "^7.18.6",
-    "@briebug/jest-schematic": "^2.1.1",
-    "@fortawesome/fontawesome-free": "^6.4.0",
     "@schematics/angular": "^10.2.4",
     "@types/jest": "28.1.1",
     "@types/node": "^12.20.47",
+    "@briebug/jest-schematic": "^3.0.0",
     "codelyzer": "^6.0.2",
+    "font-awesome": "^4.7.0",
     "jest": "28.1.1",
-    "protractor": "^7.0.0",
+    "protractor": "~7.0.0",
     "ts-node": "~8.3.0",
     "tslint": "~6.1.0",
-    "typescript": "~4.9.5"
+    "typescript": "~4.3.5"
   },
   "resolutions": {
     "webpack": "^5.0.0"

security-c4po-angular/src/app/app-routing.module.ts

@@ -2,31 +2,20 @@ import { NgModule } from '@angular/core';
 import { Routes, RouterModule } from '@angular/router';
 import {HomeComponent} from './home/home.component';
 import {AuthGuardService} from '../shared/guards/auth-guard.service';
-import {Route} from '@shared/models/route.enum';
 
-export const START_PAGE = Route.PROJECT_OVERVIEW;
+export const START_PAGE = 'projects';
 
 const routes: Routes = [
   {
-    path: Route.HOME,
+    path: 'home',
     component: HomeComponent,
     canActivate: [AuthGuardService]
   },
   {
-    path: Route.PROJECT_OVERVIEW,
+    path: 'projects',
     loadChildren: () => import('./project-overview').then(mod => mod.ProjectOverviewModule),
     canActivate: [AuthGuardService]
   },
-  {
-    path: Route.OBJECTIVE_OVERVIEW,
-    loadChildren: () => import('./project-overview/project').then(mod => mod.ProjectModule),
-    canActivate: [AuthGuardService]
-  },
-  {
-    path: Route.PENTEST_OBJECTIVE,
-    loadChildren: () => import('./pentest').then(mod => mod.PentestModule),
-    canActivate: [AuthGuardService]
-  },
   // ToDo: Remove after default Keycloak login mask got reworked
   /*{
     path: 'login',
@@ -38,7 +27,7 @@ const routes: Routes = [
 ];
 
 @NgModule({
-  imports: [RouterModule.forRoot(routes, {})],
+  imports: [RouterModule.forRoot(routes, { relativeLinkResolution: 'legacy' })],
   exports: [RouterModule]
 })
 export class AppRoutingModule { }

security-c4po-angular/src/app/app.component.ts

@@ -9,8 +9,6 @@ import {SessionState, SessionStateModel} from '@shared/stores/session-state/sess
 import {UntilDestroy, untilDestroyed} from '@ngneat/until-destroy';
 import {isNotNullOrUndefined} from 'codelyzer/util/isNotNullOrUndefined';
 import {filter} from 'rxjs/operators';
-import {NbIconLibraries} from '@nebular/theme';
-import {FaIconLibrary} from '@fortawesome/angular-fontawesome';
 
 @UntilDestroy()
 @Component({
@@ -26,8 +24,6 @@ export class AppComponent implements OnInit, OnDestroy {
 
   constructor(private translateService: TranslateService,
               private store: Store,
-              private iconLibraries: FaIconLibrary,
-              private nebularIconLibraries: NbIconLibraries,
               @Inject(LOCALE_ID) private localeId: string) {
     this.initApp();
   }
@@ -48,14 +44,10 @@ export class AppComponent implements OnInit, OnDestroy {
   initApp(): void {
     // for global language
     this.translateService.use(this.localeId);
+
     // for number, date and time
     registerLocaleData(localeDe, 'de-DE');
-    // for font-awesome icons
-    this.nebularIconLibraries.registerFontPack('fas', { packClass: 'fas', iconClassPrefix: 'fa' });
-    this.nebularIconLibraries.registerFontPack('far', { packClass: 'far', iconClassPrefix: 'fa' });
-    this.nebularIconLibraries.registerFontPack('fab', { packClass: 'fab', iconClassPrefix: 'fa' });
-    this.nebularIconLibraries.setDefaultPack('far');
-    // for country codes
+
     this.setupCountryCode();
   }
 

security-c4po-angular/src/app/app.module.ts

@@ -6,37 +6,30 @@ import {BrowserAnimationsModule} from '@angular/platform-browser/animations';
 import {
   NbLayoutModule,
   NbToastrModule,
-  NbIconModule,
-  NbCardModule,
-  NbButtonModule,
-  NbSelectModule,
-  NbThemeModule,
-  NbOverlayContainerAdapter,
-  NbDialogModule, NbMenuModule, NbIconLibraries,
+  NbIconModule, NbCardModule, NbButtonModule, NbDialogService, NbDialogModule, NbSelectModule
 } from '@nebular/theme';
 import {TranslateLoader, TranslateModule} from '@ngx-translate/core';
 import {HttpClient, HttpClientModule} from '@angular/common/http';
 import {HttpLoaderFactory} from './common-app.module';
 import {RouterModule} from '@angular/router';
+import {FaConfig, FaIconLibrary, FontAwesomeModule} from '@fortawesome/angular-fontawesome';
+import {fas} from '@fortawesome/free-solid-svg-icons';
+import {far} from '@fortawesome/free-regular-svg-icons';
 import {NgxsModule} from '@ngxs/store';
 import {SessionState} from '@shared/stores/session-state/session-state';
 import {environment} from '../environments/environment';
-import {NotificationService} from '@shared/services/toaster-service/notification.service';
+import {NotificationService} from '@shared/services/notification.service';
 import {ThemeModule} from '@assets/@theme/theme.module';
 import {HeaderModule} from './header/header.module';
 import {HomeModule} from './home/home.module';
 import {KeycloakService} from 'keycloak-angular';
 import {httpInterceptorProviders} from '@shared/interceptors';
 import {FlexLayoutModule} from '@angular/flex-layout';
+import {DialogService} from '@shared/services/dialog-service/dialog.service';
+import {ConfirmDialogModule} from '@shared/modules/confirm-dialog/confirm-dialog.module';
+import {OverlayContainer} from '@angular/cdk/overlay';
 import {NgxsLoggerPluginModule} from '@shared/stores/plugins/store-logger-plugin';
 import {ProjectState} from '@shared/stores/project-state/project-state';
-import {CustomOverlayContainer} from '@shared/modules/custom-overlay-container.component';
-import {DialogService} from '@shared/services/dialog-service/dialog.service';
-import {FormsModule, ReactiveFormsModule} from '@angular/forms';
-import {RetryDialogModule} from '@shared/modules/retry-dialog/retry-dialog.module';
-import {FaConfig, FaIconLibrary, FontAwesomeModule} from '@fortawesome/angular-fontawesome';
-import {fas} from '@fortawesome/free-solid-svg-icons';
-import {far} from '@fortawesome/free-regular-svg-icons';
 
 @NgModule({
   declarations: [
@@ -47,20 +40,16 @@ import {far} from '@fortawesome/free-regular-svg-icons';
     AppRoutingModule,
     RouterModule,
     NbLayoutModule,
+    NbDialogModule.forRoot(),
     NbCardModule,
     NbIconModule,
     NbButtonModule,
-    NbDialogModule.forRoot(),
-    NbThemeModule.forRoot(),
     NbToastrModule.forRoot(), // used for notification service
-    FlexLayoutModule,
-    ReactiveFormsModule,
-    FormsModule,
     FontAwesomeModule,
     BrowserAnimationsModule,
     ThemeModule.forRoot(),
-    NbMenuModule.forRoot(),
     NbSelectModule,
+    ConfirmDialogModule,
     NgxsModule.forRoot([SessionState, ProjectState], {developmentMode: !environment.production}),
     NgxsLoggerPluginModule.forRoot({developmentMode: !environment.production}),
     HttpClientModule,
@@ -73,7 +62,7 @@ import {far} from '@fortawesome/free-regular-svg-icons';
     }),
     HeaderModule,
     HomeModule,
-    RetryDialogModule
+    FlexLayoutModule
   ],
   providers: [
     HttpClient,
@@ -83,22 +72,21 @@ import {far} from '@fortawesome/free-regular-svg-icons';
       multi: true,
       deps: [KeycloakService]
     },
+    OverlayContainer,
     KeycloakService,
     httpInterceptorProviders,
     NotificationService,
     DialogService,
-    {provide: NbOverlayContainerAdapter, useClass: CustomOverlayContainer}
+    NbDialogService,
   ],
   bootstrap: [
     AppComponent
   ]
 })
 export class AppModule {
-  constructor(library: FaIconLibrary, faConfig: FaConfig, libraries: NbIconLibraries) {
-    library.addIconPacks(far, fas);
-    libraries.registerFontPack('solid', {packClass: 'fas', iconClassPrefix: 'fa'});
+  constructor(library: FaIconLibrary, faConfig: FaConfig) {
+    library.addIconPacks(fas, far);
     faConfig.defaultPrefix = 'fas';
-    libraries.setDefaultPack('solid');
   }
 }
 

security-c4po-angular/src/app/common-app.module.ts

@@ -6,27 +6,22 @@ import {HttpClient, HttpClientModule} from '@angular/common/http';
 import {FontAwesomeModule} from '@fortawesome/angular-fontawesome';
 import {FlexLayoutModule, FlexModule} from '@angular/flex-layout';
 import {MomentModule} from 'ngx-moment';
-import {NotificationService} from '@shared/services/toaster-service/notification.service';
-import {NbMenuModule, NbOverlayContainerAdapter, NbSpinnerModule, NbToastrModule} from '@nebular/theme';
-import {ThemeModule} from '@assets/@theme/theme.module';
-import {LoadingSpinnerComponent} from '@shared/widgets/loading-spinner/loading-spinner.component';
+import {NotificationService} from '../shared/services/notification.service';
+import {NbToastrModule} from '@nebular/theme';
+import {ThemeModule} from '../assets/@theme/theme.module';
 
 export function HttpLoaderFactory(http: HttpClient): TranslateHttpLoader {
   return new TranslateHttpLoader(http);
 }
 
 @NgModule({
-  declarations: [
-    LoadingSpinnerComponent
-  ],
+  declarations: [],
   imports: [
     CommonModule,
     NbToastrModule, // used for notification service
-    NbSpinnerModule,
     FontAwesomeModule,
     FlexLayoutModule,
     ThemeModule.forRoot(),
-    NbMenuModule.forRoot(),
     FlexModule,
     HttpClientModule,
     TranslateModule.forChild({
@@ -39,11 +34,9 @@ export function HttpLoaderFactory(http: HttpClient): TranslateHttpLoader {
   ],
   providers: [
     HttpClient,
-    NotificationService,
-    NbOverlayContainerAdapter
+    NotificationService
   ],
   exports: [
-    LoadingSpinnerComponent,
     // modules
     MomentModule
   ]

security-c4po-angular/src/app/header/header.component.html

@@ -2,49 +2,35 @@
   <img *ngIf="currentTheme === 'corporate', else changeImage"
        src="../../assets/images/favicons/favicon.ico" alt="logo dark" class="header-icon" width="60rem" height="60rem">
   <ng-template #changeImage>
-    <img src="../../assets/images/favicons/favicon_corporate.ico" alt="logo light" class="header-icon" width="60rem"
-         height="60rem">
+    <img src="../../assets/images/favicons/corporate_favicon.ico" alt="logo light" class="header-icon" width="60rem" height="60rem">
   </ng-template>
 
   <div class="logo-container">
-    <h1>{{SECURITYC4PO_TITLE}} </h1>
+    <h1 >{{SECURITYC4PO_TITLE}} </h1>
   </div>
   <div class="filler"></div>
   <div fxLayoutGap="4rem">
     <nb-actions size="medium">
-      <!--Info Action-->
-      <nb-action>
-        <fa-icon title="Info" [icon]="fa.faCircleInfo" (click)="onClickShowTutorial()" class="action-element-icon fa-2x">
-        </fa-icon>
-      </nb-action>
-      <!--OWASP Action-->
-      <nb-action>
-        <!-- Latest: https://owasp.org/www-project-web-security-testing-guide/latest/ -->
-        <!-- Stable: https://owasp.org/www-project-web-security-testing-guide/stable/ -->
-        <fa-icon title="OWASP Testing Guide"
-                 (click)="onClickGoToLink('https://owasp.org/www-project-web-security-testing-guide/v42/')"
-                 [icon]="fa.faFileInvoice" class="action-element-icon fa-2x">
-        </fa-icon>
-      </nb-action>
-      <!--Theme Action-->
-      <nb-action>
-        <div (click)="onClickSwitchTheme()" class="action-element-icon">
-          <fa-icon *ngIf="currentTheme === 'corporate', else changeIcon"
-                   title="Darktheme" [icon]="fa.faMoon" class="fa-2x">
-          </fa-icon>
+      <nb-action class="toggle-theme">
+        <button nbButton
+                (click)="onClickSwitchTheme()">
+          <fa-icon *ngIf="currentTheme === 'corporate', else changeIcon" [icon]="fa.faMoon"
+                   class="new-element-icon"></fa-icon>
           <ng-template #changeIcon>
-            <fa-icon title="Lighttheme" [icon]="fa.faSun" class="fa-2x"></fa-icon>
+            <fa-icon [icon]="fa.faSun" class="new-element-icon"></fa-icon>
           </ng-template>
-        </div>
-      </nb-action>
-      <!--User Action-->
-      <nb-action class="user-action">
-        <nb-user [nbContextMenu]="userMenu"
-                 [picture]="FALLBACK_IMG"
-                 name="{{user?.getValue()?.username}}"
-                 title="Pentester">
-        </nb-user>
+        </button>
       </nb-action>
     </nb-actions>
   </div>
+  <div *ngIf="selectedLanguage && languages" class="languageContainer">
+    <nb-select selected="{{selectedLanguage}}" fullWidth>
+      <nb-option *ngFor="let language of languages"
+                 value="{{language}}" (click)="onClickLanguage(language)" fxLayoutAlign="start center">
+          <img src="../../assets/images/flags/{{language}}.svg" class="flag" width="25rem" height="16rem" alt="">
+          <span fxFlexOffset="0.5rem"> {{'languageKeys.' + language | translate}} </span>
+      </nb-option>
+    </nb-select>
+  </div>
 </div>
+

security-c4po-angular/src/app/header/header.component.scss

@@ -1,4 +1,4 @@
-@import '@nebular/theme/styles/global/breakpoints';
+@import '~@nebular/theme/styles/global/breakpoints';
 @import "../../assets/@theme/styles/_variables.scss";
 
 .header {
@@ -8,26 +8,13 @@
     flex-grow: 1;
   }
 
-  .action-element-icon:hover {
-    cursor: pointer;
-  }
-
-  .logo-container {
-    white-space: nowrap;
-    overflow: hidden;
-    text-overflow: ellipsis;
-  }
-
-  .owasp-redirect-button {
-    margin-left: 0.5rem;
-  }
-
-  .user-action {
-    // width: 4rem;
-    z-index: 10;
-    // height: 3rem;
-    .user-action-accordion-header {
+  .languageContainer {
+    display: flex;
+    max-width: 8rem;
+    min-width: 8rem;
 
+    .flag {
+      object-fit: contain;
     }
   }
 }
@@ -42,6 +29,11 @@
     align-items: center;
     width: auto;
 
+    .logo-container {
+      font-style: oblique;
+      color: #e74c3c;
+    }
+
     nb-action {
       height: auto;
       display: flex;

security-c4po-angular/src/app/header/header.component.spec.ts

@@ -3,32 +3,17 @@ import {ComponentFixture, TestBed} from '@angular/core/testing';
 import {HeaderComponent} from './header.component';
 import {CommonModule} from '@angular/common';
 import {FontAwesomeTestingModule} from '@fortawesome/angular-fontawesome/testing';
-import {NbActionsModule, NbMenuModule, NbMenuService, NbSelectModule} from '@nebular/theme';
+import {NbActionsModule, NbSelectModule} from '@nebular/theme';
 import {ThemeModule} from '@assets/@theme/theme.module';
 import {TranslateLoader, TranslateModule} from '@ngx-translate/core';
 import {HttpLoaderFactory} from '../common-app.module';
 import {HttpClient} from '@angular/common/http';
 import {RouterTestingModule} from '@angular/router/testing';
 import {HttpClientTestingModule} from '@angular/common/http/testing';
-import {NgxsModule, Store} from '@ngxs/store';
-import {KeycloakService} from 'keycloak-angular';
-import {SESSION_STATE_NAME, SessionState, SessionStateModel} from '@shared/stores/session-state/session-state';
-import {User} from '@shared/models/user.model';
-import {DialogService} from '@shared/services/dialog-service/dialog.service';
-import {DialogServiceMock} from '@shared/services/dialog-service/dialog.service.mock';
-
-const DESIRED_STORE_STATE_SESSION: SessionStateModel = {
-  userAccount: {
-    ...new User('ttt', 'test', 'user', 'default.user@test.de', 'en-US'),
-    id: '11c47c56-3bcd-45f1-a05b-c197dbd33110'
-  },
-  isAuthenticated: true
-};
 
 describe('HeaderComponent', () => {
   let component: HeaderComponent;
   let fixture: ComponentFixture<HeaderComponent>;
-  let store: Store;
 
   beforeEach(async () => {
     await TestBed.configureTestingModule({
@@ -41,7 +26,6 @@ describe('HeaderComponent', () => {
         NbSelectModule,
         FontAwesomeTestingModule,
         HttpClientTestingModule,
-        NbMenuModule,
         ThemeModule.forRoot(),
         TranslateModule.forRoot({
           loader: {
@@ -50,24 +34,14 @@ describe('HeaderComponent', () => {
             deps: [HttpClient]
           }
         }),
-        RouterTestingModule.withRoutes([]),
-        NgxsModule.forRoot([SessionState])
-      ],
-      providers: [
-        {provide: DialogService, useClass: DialogServiceMock},
-        NbMenuService,
-        KeycloakService
+        RouterTestingModule.withRoutes([])
       ]
-    }).compileComponents();
+    })
+      .compileComponents();
   });
 
   beforeEach(() => {
     fixture = TestBed.createComponent(HeaderComponent);
-    store = TestBed.inject(Store);
-    store.reset({
-      ...store.snapshot(),
-      [SESSION_STATE_NAME]: DESIRED_STORE_STATE_SESSION
-    });
     component = fixture.componentInstance;
     fixture.detectChanges();
   });

security-c4po-angular/src/app/header/header.component.ts

@@ -1,141 +1,36 @@
-import {Component, OnInit} from '@angular/core';
+import {Component, OnDestroy, OnInit} from '@angular/core';
 import * as FA from '@fortawesome/free-solid-svg-icons';
-import {NbMenuItem, NbMenuService, NbThemeService} from '@nebular/theme';
-import {filter, map} from 'rxjs/operators';
+import {NbThemeService} from '@nebular/theme';
+import {map} from 'rxjs/operators';
 import {GlobalTitlesVariables} from '@shared/config/global-variables';
 import {TranslateService} from '@ngx-translate/core';
 import {UntilDestroy, untilDestroyed} from '@ngneat/until-destroy';
-import {KeycloakService} from 'keycloak-angular';
-import {Store} from '@ngxs/store';
-import {ResetSession} from '@shared/stores/session-state/session-state.actions';
-import {UserService} from '@shared/services/user-service/user.service';
-import {User} from '@shared/models/user.model';
-import {BehaviorSubject} from 'rxjs';
-import {Route} from '@shared/models/route.enum';
-import {Router} from '@angular/router';
-import {DialogService} from '@shared/services/dialog-service/dialog.service';
-import {ProfileSettingsComponent} from '@shared/modules/profile-settings/profile-settings.component';
-import {TutorialDialogComponent} from '@shared/modules/tutorial-dialog/tutorial-dialog.component';
 
+@UntilDestroy()
 @Component({
   selector: 'app-header',
   templateUrl: './header.component.html',
   styleUrls: ['./header.component.scss']
 })
-@UntilDestroy()
-export class HeaderComponent implements OnInit {
+export class HeaderComponent implements OnInit{
 
-  // HTML only
   readonly fa = FA;
-  readonly SECURITYC4PO_TITLE: string = GlobalTitlesVariables.SECURITYC4PO_TITLE;
-  // Menu only
-  readonly settingsIcon = 'gear';
-  readonly logoutIcon = 'right-from-bracket';
+  readonly SECURITYC4PO_TITLE = GlobalTitlesVariables.SECURITYC4PO_TITLE;
 
   currentTheme = '';
+  languages = ['en-US', 'de-DE'];
+  selectedLanguage = '';
 
-  user: BehaviorSubject<User> = new BehaviorSubject<User>(null);
-  userMenu: NbMenuItem[] = [
-    {
-      title: 'settings',
-      icon: { icon: this.settingsIcon, pack: 'fas' }
-    },
-    {
-      title: 'logout',
-      icon: { icon: this.logoutIcon, pack: 'fas'}
-    }
-  ];
-  readonly FALLBACK_IMG = 'assets/images/demo/anon-user-icon.png';
-
-  constructor(
-    private store: Store,
-    private router: Router,
-    private themeService: NbThemeService,
-    private translateService: TranslateService,
-    private dialogService: DialogService,
-    private menuService: NbMenuService,
-    private userService: UserService,
-    protected keycloakService: KeycloakService) {
-  }
+  constructor(private themeService: NbThemeService, private translateService: TranslateService) { }
 
   ngOnInit(): void {
-    // Handle theme selection
     this.themeService.onThemeChange()
       .pipe(
-        map(({name}) => name),
+        map(({ name }) => name),
         untilDestroyed(this),
-      ).subscribe(themeName => this.currentTheme = themeName);
-
-    // Load user profile
-    this.userService.loadUserProfile().pipe(
-      untilDestroyed(this)
-    ).subscribe({
-      next: (user: User) => {
-        this.user.next(user);
-      },
-      error: err => {
-        console.error(err);
-      }
-    });
-    // Handle user profile menu selection
-    this.menuService.onItemClick()
-      .pipe(
-        untilDestroyed(this)
       )
-      .subscribe((menuBag) => {
-        // Makes sure that other menus without icon won't trigger
-        if (menuBag.item.icon) {
-          // tslint:disable-next-line:no-string-literal
-          if (menuBag.item.icon['icon'] === this.settingsIcon) {
-            this.dialogService.openCustomDialog(
-              ProfileSettingsComponent,
-              {
-                user: this.user.getValue(),
-              }
-            ).onClose.pipe(
-              filter((confirm) => !!confirm),
-              untilDestroyed(this)
-            ).subscribe({
-              next: () => {
-                console.info('New Settings confirmed');
-              }
-            });
-          }
-          // tslint:disable-next-line:no-string-literal
-          else if (menuBag.item.icon['icon'] === this.logoutIcon) {
-            this.onClickLogOut();
-          }
-        }
-      });
-    // Setup stream to translate menu item
-    this.translateService.stream('global.action.profile')
-      .pipe(
-        untilDestroyed(this)
-      ).subscribe((text: string) => {
-      this.userMenu[0].title = text;
-    });
-    // Setup stream to translate menu item
-    this.translateService.stream('global.action.logout')
-      .pipe(
-        untilDestroyed(this)
-      ).subscribe((text: string) => {
-      this.userMenu[1].title = text;
-    });
-  }
-
-  // HTML only
-  onClickGoToLink(url: string): void {
-    window.open(url, '_blank');
-  }
-
-  onClickShowTutorial(): void {
-    this.dialogService.openCustomDialog(
-      TutorialDialogComponent,
-      {}
-    ).onClose.pipe(
-      filter((confirm) => !!confirm),
-      untilDestroyed(this)
-    ).subscribe();
+      .subscribe(themeName => this.currentTheme = themeName);
+    this.selectedLanguage = this.translateService.currentLang;
   }
 
   onClickSwitchTheme(): void {
@@ -146,19 +41,7 @@ export class HeaderComponent implements OnInit {
     }
   }
 
-  onClickLogOut(): void {
-    this.userService.logout().then(() => {
-      console.warn('logout success');
-      // Route user back to default page
-      this.router.navigate([Route.HOME]).then(() => {
-        // Reset User props from store
-        this.keycloakService.clearToken();
-        this.store.dispatch(new ResetSession());
-      }, err => {
-        console.error(err);
-      });
-    }, err => {
-      console.error(err);
-    });
+  onClickLanguage(language: string): void {
+    this.translateService.use(language);
   }
 }

security-c4po-angular/src/app/header/header.module.ts

@@ -1,19 +1,10 @@
 import {NgModule} from '@angular/core';
 import {CommonModule} from '@angular/common';
 import {HeaderComponent} from './header.component';
-import {
-  NbActionsModule,
-  NbButtonModule,
-  NbCardModule,
-  NbContextMenuModule,
-  NbSelectModule,
-  NbUserModule
-} from '@nebular/theme';
+import {NbActionsModule, NbButtonModule, NbCardModule, NbSelectModule} from '@nebular/theme';
 import {FontAwesomeModule} from '@fortawesome/angular-fontawesome';
 import {FlexLayoutModule} from '@angular/flex-layout';
 import {TranslateModule} from '@ngx-translate/core';
-import {ProfileSettingsModule} from '@shared/modules/profile-settings/profile-settings.module';
-import {TutorialDialogModule} from '@shared/modules/tutorial-dialog/tutorial-dialog.module';
 
 @NgModule({
   declarations: [
@@ -22,22 +13,16 @@ import {TutorialDialogModule} from '@shared/modules/tutorial-dialog/tutorial-dia
   exports: [
     HeaderComponent
   ],
-  imports: [
-    CommonModule,
-    NbButtonModule,
-    FontAwesomeModule,
-    NbCardModule,
-    NbActionsModule,
-    FlexLayoutModule,
-    NbSelectModule,
-    TranslateModule,
-    NbUserModule,
-    NbContextMenuModule,
-    ProfileSettingsModule,
-    TutorialDialogModule
-  ],
-  providers: [
-  ]
+    imports: [
+        CommonModule,
+        NbButtonModule,
+        FontAwesomeModule,
+        NbCardModule,
+        NbActionsModule,
+        FlexLayoutModule,
+        NbSelectModule,
+        TranslateModule
+    ]
 })
 export class HeaderModule {
 }

security-c4po-angular/src/app/login/login.component.scss

@@ -1,4 +1,4 @@
-@import '@nebular/theme/styles/theming';
+@import '~@nebular/theme/styles/theming';
 
 $login-width: 24em;
 $input-width: 16rem;

security-c4po-angular/src/app/login/login.component.spec.ts

@@ -21,8 +21,8 @@ import {ReactiveFormsModule} from '@angular/forms';
 import {User} from '../../shared/models/user.model';
 import {CommonModule} from '@angular/common';
 import {BrowserAnimationsModule} from '@angular/platform-browser/animations';
-import {NotificationService} from '@shared/services/toaster-service/notification.service';
-import {NotificationServiceMock} from '@shared/services/toaster-service/notification.service.mock';
+import {NotificationService} from '../../shared/services/notification.service';
+import {NotificationServiceMock} from '../../shared/services/notification.service.mock';
 import {KeycloakService} from 'keycloak-angular';
 
 const DESIRED_STORE_STATE_SESSION: SessionStateModel = {
@@ -81,6 +81,7 @@ describe('LoginComponent', () => {
       ...store.snapshot(),
       [SESSION_STATE_NAME]: DESIRED_STORE_STATE_SESSION
     });
+
     fixture = TestBed.createComponent(LoginComponent);
     component = fixture.componentInstance;
     httpMock = TestBed.inject(HttpTestingController);

security-c4po-angular/src/app/login/login.component.ts

@@ -1,8 +1,8 @@
 import {Component, OnInit} from '@angular/core';
-import {AbstractControl, UntypedFormBuilder, UntypedFormGroup, Validators} from '@angular/forms';
+import {AbstractControl, FormBuilder, FormGroup, Validators} from '@angular/forms';
 import {Router} from '@angular/router';
 import {Store} from '@ngxs/store';
-import {NotificationService, PopupType} from '@shared/services/toaster-service/notification.service';
+import {NotificationService, PopupType} from '../../shared/services/notification.service';
 import {UntilDestroy, untilDestroyed} from '@ngneat/until-destroy';
 import {User} from '../../shared/models/user.model';
 import {throwError} from 'rxjs';
@@ -22,6 +22,7 @@ import {KeycloakService} from 'keycloak-angular';
 export class LoginComponent implements OnInit {
   readonly MIN_LENGTH: number = 2;
   readonly SECURITYC4PO_TITLE = GlobalTitlesVariables.SECURITYC4PO_TITLE;
+  readonly NOVATEC_NAME = GlobalTitlesVariables.NOVATEC_NAME;
 
   // ToDo: Remove after adding real authentication
   private readonly user = new User('ttt', 'test', 'user', 'default.user@test.de', 'en-US');
@@ -29,7 +30,7 @@ export class LoginComponent implements OnInit {
   version: string;
 
   // form control elements
-  loginFormGroup: UntypedFormGroup;
+  loginFormGroup: FormGroup;
   loginUsernameCtrl: AbstractControl;
   loginPasswordCtrl: AbstractControl;
 
@@ -39,7 +40,7 @@ export class LoginComponent implements OnInit {
 
   formCtrlStatus = FieldStatus.BASIC;
 
-  constructor(private fb: UntypedFormBuilder,
+  constructor(private fb: FormBuilder,
               private router: Router,
               private store: Store,
               private readonly httpClient: HttpClient,

security-c4po-angular/src/app/login/login.module.ts

@@ -4,7 +4,7 @@ import {LoginComponent} from './login.component';
 import {TranslateLoader, TranslateModule} from '@ngx-translate/core';
 import {HttpLoaderFactory} from '../common-app.module';
 import {HttpClient} from '@angular/common/http';
-import {NotificationService} from '@shared/services/toaster-service/notification.service';
+import {NotificationService} from '../../shared/services/notification.service';
 import {LoginRoutingModule} from './login-routing.module';
 import {NbButtonModule, NbCardModule, NbFormFieldModule, NbInputModule, NbLayoutModule} from '@nebular/theme';
 import {ReactiveFormsModule} from '@angular/forms';

security-c4po-angular/src/app/objective-overview/index.ts

@@ -1,2 +0,0 @@
-export {ObjectiveOverviewModule} from './objective-overview.module';
-export {ObjectiveOverviewRoutingModule} from './objective-overview-routing.module';

security-c4po-angular/src/app/objective-overview/objective-categories/objective-categories.component.html

@@ -1,5 +0,0 @@
-<div class="pentest-categories">
-  <nb-menu id="category-menu" class="menu-style" tag="menu" [items]="categories"></nb-menu>
-</div>
-
-

security-c4po-angular/src/app/objective-overview/objective-header/objective-header.component.html

@@ -1,49 +0,0 @@
-<div class="pentest-header" fxLayout="row" fxLayoutGap="2rem" fxLayoutAlign="space-between center">
-  <div class="back-button-container">
-    <button nbButton
-            shape="round"
-            title="{{ 'global.action.return' | translate }}"
-            (click)="onClickRouteBack()">
-      <fa-icon [icon]="fa.faLongArrowAltLeft"
-               class="back-element-icon fa-lg"></fa-icon>
-    </button>
-  </div>
-
-  <div class="header-info" fxLayout="row" fxLayoutGap="4rem" fxLayoutAlign="space-between center">
-    <app-report-state-tag class="state-tag"
-                          [currentReportState]="selectedProject$.getValue()?.state"></app-report-state-tag>
-    <h4 class="project-title">{{selectedProject$.getValue().title}}</h4>
-    <app-version-tag [version]="selectedProject$.getValue().version"></app-version-tag>
-  </div>
-
-  <div class="button-container">
-    <!--Actions for normal view-->
-    <nb-actions size="medium" fxHide.lt-lg>
-      <nb-action>
-        <button nbButton
-                status="primary"
-                shape="round"
-                (click)="onClickEditPentestProject()">
-          <fa-icon [icon]="fa.faEdit"
-                   class="element-icon fa-lg"></fa-icon>
-        </button>
-      </nb-action>
-      <nb-action>
-        <button nbButton hero
-                status="info"
-                shape="round"
-                (click)="onClickGeneratePentestReport()">
-          <fa-icon [icon]="fa.faFileAlt"
-                   class="element-icon fa-lg"></fa-icon>
-          <span class="element-text">{{ 'global.action.report' | translate }}</span>
-        </button>
-      </nb-action>
-    </nb-actions>
-    <!--Actions for mobile devices-->
-    <nb-actions size="medium" fxHide fxShow.lt-lg>
-      <nb-action>
-        <nb-user [nbContextMenu]="objectiveActionItems" shape="rectangle" [picture]="BARS_IMG" name="" [onlyPicture]></nb-user>
-      </nb-action>
-    </nb-actions>
-  </div>
-</div>

security-c4po-angular/src/app/objective-overview/objective-header/objective-header.component.scss

@@ -1,37 +0,0 @@
-@import '../../../assets/@theme/styles/_text-overflow.scss';
-
-.pentest-header {
-  width: 100vw;
-
-  .back-button-container {
-    .back-element-icon {
-    }
-  }
-
-  .header-info {
-    position: absolute;
-    margin-left: 10rem;
-    margin-right: 10rem;
-    text-align: center;
-
-    .state-tag {
-    }
-
-    .project-title {
-      @include multiLineEllipsis($font-size: 1.5rem, $font-weight: bold, $line-height: 2rem, $lines-to-show: 1, $max-width: 36rem);
-    }
-  }
-
-  .button-container {
-    position: absolute;
-    right: 2rem;
-
-    .element-icon {
-    }
-
-    .element-text {
-      padding-left: 0.5rem;
-      font-size: 0.85rem;
-    }
-  }
-}

security-c4po-angular/src/app/objective-overview/objective-header/objective-header.component.spec.ts

@@ -1,111 +0,0 @@
-import {ComponentFixture, TestBed} from '@angular/core/testing';
-
-import {ObjectiveHeaderComponent} from './objective-header.component';
-import {BrowserAnimationsModule} from '@angular/platform-browser/animations';
-import {HttpClientTestingModule} from '@angular/common/http/testing';
-import {ThemeModule} from '@assets/@theme/theme.module';
-import {TranslateLoader, TranslateModule} from '@ngx-translate/core';
-import {HttpLoaderFactory} from '../../common-app.module';
-import {HttpClient} from '@angular/common/http';
-import {RouterTestingModule} from '@angular/router/testing';
-import {NgxsModule, Store} from '@ngxs/store';
-import {PROJECT_STATE_NAME, ProjectState, ProjectStateModel} from '@shared/stores/project-state/project-state';
-import {FontAwesomeModule} from '@fortawesome/angular-fontawesome';
-import {NbActionsModule, NbIconModule, NbMenuService} from '@nebular/theme';
-import {ProjectService} from '@shared/services/api/project.service';
-import {ProjectServiceMock} from '@shared/services/api/project.service.mock';
-import {ProjectDialogService} from '@shared/modules/project-dialog/service/project-dialog.service';
-import {ProjectDialogServiceMock} from '@shared/modules/project-dialog/service/project-dialog.service.mock';
-import {DialogService} from '@shared/services/dialog-service/dialog.service';
-import {DialogServiceMock} from '@shared/services/dialog-service/dialog.service.mock';
-import {NotificationService} from '@shared/services/toaster-service/notification.service';
-import {NotificationServiceMock} from '@shared/services/toaster-service/notification.service.mock';
-import {Category} from '@shared/models/category.model';
-import {PentestStatus} from '@shared/models/pentest-status.model';
-import {ExportReportDialogService} from '@shared/modules/export-report-dialog/service/export-report-dialog.service';
-import {ExportReportDialogServiceMock} from '@shared/modules/export-report-dialog/service/export-report-dialog.service.mock';
-import {ReportState} from '@shared/models/state.enum';
-
-const DESIRED_PROJECT_STATE_SESSION: ProjectStateModel = {
-  allProjects: [],
-  selectedProject: {
-    id: '56c47c56-3bcd-45f1-a05b-c197dbd33111',
-    client: 'E Corp',
-    title: 'Some Mock API (v1.0) Scanning',
-    createdAt: new Date('2019-01-10T09:00:00'),
-    tester: 'Novatester',
-    summary: '',
-    state: ReportState.NEW,
-    version: '1.0',
-    testingProgress: 0,
-    createdBy: '11c47c56-3bcd-45f1-a05b-c197dbd33110'
-  },
-  // Manages Categories
-  disabledCategories: [],
-  selectedCategory: Category.INFORMATION_GATHERING,
-  // Manages Pentests of Category
-  disabledPentests: [],
-  selectedPentest: {
-    id: '56c47c56-3bcd-45f1-a05b-c197dbd33112',
-    category: Category.INFORMATION_GATHERING,
-    refNumber: 'OTF-001',
-    childEntries: [],
-    status: PentestStatus.NOT_STARTED,
-    enabled: true,
-    findingIds: [],
-    commentIds: ['56c47c56-3bcd-45f1-a05b-c197dbd33112']
-  },
-};
-
-describe('ObjectiveHeaderComponent', () => {
-  let component: ObjectiveHeaderComponent;
-  let fixture: ComponentFixture<ObjectiveHeaderComponent>;
-  let store: Store;
-
-  beforeEach(async () => {
-    await TestBed.configureTestingModule({
-      declarations: [ObjectiveHeaderComponent],
-      imports: [
-        BrowserAnimationsModule,
-        HttpClientTestingModule,
-        ThemeModule.forRoot(),
-        FontAwesomeModule,
-        NbIconModule,
-        NbActionsModule,
-        TranslateModule.forRoot({
-          loader: {
-            provide: TranslateLoader,
-            useFactory: HttpLoaderFactory,
-            deps: [HttpClient]
-          }
-        }),
-        RouterTestingModule.withRoutes([]),
-        NgxsModule.forRoot([ProjectState])
-      ],
-      providers: [
-        NbMenuService,
-        {provide: ProjectService, useValue: new ProjectServiceMock()},
-        {provide: ProjectDialogService, useClass: ProjectDialogServiceMock},
-        {provide: ExportReportDialogService, useClass: ExportReportDialogServiceMock},
-        {provide: DialogService, useClass: DialogServiceMock},
-        {provide: NotificationService, useValue: new NotificationServiceMock()}
-      ]
-    })
-      .compileComponents();
-  });
-
-  beforeEach(() => {
-    fixture = TestBed.createComponent(ObjectiveHeaderComponent);
-    store = TestBed.inject(Store);
-    store.reset({
-      ...store.snapshot(),
-      [PROJECT_STATE_NAME]: DESIRED_PROJECT_STATE_SESSION
-    });
-    component = fixture.componentInstance;
-    fixture.detectChanges();
-  });
-
-  it('should create', () => {
-    expect(component).toBeTruthy();
-  });
-});

security-c4po-angular/src/app/objective-overview/objective-header/objective-header.component.ts

@@ -1,176 +0,0 @@
-import {Component, OnInit} from '@angular/core';
-import * as FA from '@fortawesome/free-solid-svg-icons';
-import {Route} from '@shared/models/route.enum';
-import {Store} from '@ngxs/store';
-import {Router} from '@angular/router';
-import {PROJECT_STATE_NAME, ProjectState} from '@shared/stores/project-state/project-state';
-import {UntilDestroy, untilDestroyed} from '@ngneat/until-destroy';
-import {BehaviorSubject} from 'rxjs';
-import {Project, ProjectDialogBody} from '@shared/models/project.model';
-import {ProjectDialogComponent} from '@shared/modules/project-dialog/project-dialog.component';
-import {filter, mergeMap} from 'rxjs/operators';
-import {NotificationService, PopupType} from '@shared/services/toaster-service/notification.service';
-import {ProjectService} from '@shared/services/api/project.service';
-import {DialogService} from '@shared/services/dialog-service/dialog.service';
-import {ProjectDialogService} from '@shared/modules/project-dialog/service/project-dialog.service';
-import {InitProjectState} from '@shared/stores/project-state/project-state.actions';
-import {ExportReportDialogService} from '@shared/modules/export-report-dialog/service/export-report-dialog.service';
-import {ExportReportDialogComponent} from '@shared/modules/export-report-dialog/export-report-dialog.component';
-import {NbMenuItem} from '@nebular/theme/components/menu/menu.service';
-import {NbMenuService} from '@nebular/theme';
-import {TranslateService} from '@ngx-translate/core';
-
-@UntilDestroy()
-@Component({
-  selector: 'app-objective-header',
-  templateUrl: './objective-header.component.html',
-  styleUrls: ['./objective-header.component.scss']
-})
-export class ObjectiveHeaderComponent implements OnInit {
-
-  selectedProject$: BehaviorSubject<Project> = new BehaviorSubject<Project>(null);
-  // Menu only
-  readonly editIcon = 'edit';
-  readonly fileExportIcon = 'file-export';
-  // Mobile menu properties
-  objectiveActionItems: NbMenuItem[] = [
-    {
-      title: 'global.action.edit',
-      icon: { icon: this.editIcon, pack: 'fas' }
-    },
-    {
-      title: 'global.action.report',
-      icon: { icon: this.fileExportIcon, pack: 'fas' }
-    },
-  ];
-  // HTML only
-  readonly fa = FA;
-  readonly BARS_IMG = 'assets/images/icons/bars.svg';
-  readonly ELLIPSIS_IMG = 'assets/images/icons/ellipsis.svg';
-
-  constructor(private store: Store,
-              private readonly notificationService: NotificationService,
-              private dialogService: DialogService,
-              private projectDialogService: ProjectDialogService,
-              private projectService: ProjectService,
-              private exportReportDialogService: ExportReportDialogService,
-              private readonly router: Router,
-              private translateService: TranslateService,
-              private menuService: NbMenuService
-              ) {
-  }
-
-  ngOnInit(): void {
-    this.store.select(ProjectState.project).pipe(
-      untilDestroyed(this)
-    ).subscribe({
-      next: (selectedProject: Project) => {
-        if (selectedProject) {
-          this.selectedProject$.next(selectedProject);
-        } else {
-          this.router.navigate([Route.PROJECT_OVERVIEW]);
-        }
-      },
-      error: err => {
-        console.error(err);
-      }
-    });
-
-    // Handle user profile menu action selection
-    this.menuService.onItemClick()
-      .pipe(
-        untilDestroyed(this)
-      )
-      .subscribe((menuBag) => {
-        // Makes sure that other menus without icon won't trigger
-        if (menuBag.item.icon) {
-          // tslint:disable-next-line:no-string-literal
-          if (menuBag.item.icon['icon'] === this.editIcon) {
-            this.onClickEditPentestProject();
-          }
-          // tslint:disable-next-line:no-string-literal
-          else if (menuBag.item.icon['icon'] === this.fileExportIcon) {
-            this.onClickGeneratePentestReport();
-          }
-        }
-      });
-    // Setup stream to translate menu action item
-    this.translateService.stream('global.action.edit')
-      .pipe(
-        untilDestroyed(this)
-      ).subscribe((text: string) => {
-      this.objectiveActionItems[0].title = text;
-    });
-    // Setup stream to translate menu action item
-    this.translateService.stream('global.action.report')
-      .pipe(
-        untilDestroyed(this)
-      ).subscribe((text: string) => {
-      this.objectiveActionItems[1].title = text;
-    });
-  }
-
-  onClickRouteBack(): void {
-    this.router.navigate([Route.PROJECT_OVERVIEW])
-      .then(
-        () => this.store.reset({
-          ...this.store.snapshot(),
-          [PROJECT_STATE_NAME]: undefined
-        })
-      ).finally();
-  }
-
-  onClickEditPentestProject(): void {
-    this.projectDialogService.openProjectDialog(
-      ProjectDialogComponent,
-      this.selectedProject$.getValue(),
-      {
-        closeOnEsc: false,
-        hasScroll: false,
-        autoFocus: true,
-        closeOnBackdropClick: false
-      }
-    ).pipe(
-      untilDestroyed(this)
-    ).subscribe({
-      next: (project) => {
-        if (project) {
-          this.store.dispatch(new InitProjectState(
-            project,
-            [],
-            []
-          )).pipe(
-            untilDestroyed(this)
-          ).subscribe();
-        }
-      }
-    });
-  }
-
-  onClickGeneratePentestReport(): void {
-    this.exportReportDialogService.openExportReportDialog(
-      ExportReportDialogComponent,
-      this.selectedProject$.getValue(),
-      {
-        closeOnEsc: true,
-        hasScroll: false,
-        autoFocus: true,
-        closeOnBackdropClick: true
-      }
-    ).pipe(
-      filter(value => !!value),
-      /*ToDo: Needed?*/
-      /*mergeMap((value: ProjectDialogBody) => this.projectService.updateProject(this.selectedProject$.getValue().id, value)),*/
-      untilDestroyed(this)
-    ).subscribe({
-      next: () => {
-        // ToDo: Open report in new Tab or just download it?
-        // this.notificationService.showPopup('project.popup.update.success', PopupType.SUCCESS);
-      },
-      error: error => {
-        console.error(error);
-        // this.notificationService.showPopup('project.popup.update.failed', PopupType.FAILURE);
-      }
-    });
-  }
-}

security-c4po-angular/src/app/objective-overview/objective-overview.module.ts

@@ -1,77 +0,0 @@
-import {NgModule} from '@angular/core';
-import {CommonModule} from '@angular/common';
-import {ObjectiveHeaderComponent} from './objective-header/objective-header.component';
-import {ObjectiveCategoriesComponent} from './objective-categories/objective-categories.component';
-import {ObjectiveTableComponent} from './objective-table/objective-table.component';
-import {
-  NbCardModule,
-  NbLayoutModule,
-  NbTreeGridModule,
-  NbMenuModule,
-  NbListModule,
-  NbButtonModule,
-  NbTooltipModule,
-  NbActionsModule, NbUserModule, NbContextMenuModule, NbSortDirective
-} from '@nebular/theme';
-import {TranslateModule} from '@ngx-translate/core';
-import {StatusTagModule} from '@shared/widgets/status-tag/status-tag.module';
-import {FindigWidgetModule} from '@shared/widgets/findig-widget/findig-widget.module';
-import {RouterModule} from '@angular/router';
-import {FormsModule} from '@angular/forms';
-import {FontAwesomeModule} from '@fortawesome/angular-fontawesome';
-import {FlexLayoutModule} from '@angular/flex-layout';
-import {CommonAppModule} from '../common-app.module';
-import {ObjectiveOverviewRoutingModule} from './objective-overview-routing.module';
-import {ExportReportDialogModule} from '@shared/modules/export-report-dialog/export-report-dialog.module';
-import {ProjectDialogModule} from '@shared/modules/project-dialog/project-dialog.module';
-import {CommentWidgetModule} from '@shared/widgets/comment-widget/comment-widget.module';
-import {ReportStateTagModule} from '@shared/widgets/report-state-tag/report-state-tag.module';
-import {VersionTagModule} from '@shared/widgets/version-tag/version-tag.module';
-
-@NgModule({
-  declarations: [
-    ObjectiveHeaderComponent,
-    ObjectiveCategoriesComponent,
-    ObjectiveTableComponent
-  ],
-  imports: [
-    CommonModule,
-    CommonAppModule,
-    NbLayoutModule,
-    NbCardModule,
-    NbButtonModule,
-    // nbTooltip crashes app right now if used in component,
-    // workaround: use title in html for now
-    NbTooltipModule,
-    NbTreeGridModule,
-    TranslateModule,
-    StatusTagModule,
-    RouterModule,
-    FormsModule,
-    NbListModule,
-    FontAwesomeModule,
-    FlexLayoutModule,
-    NbActionsModule,
-    ExportReportDialogModule,
-    ProjectDialogModule,
-    ObjectiveOverviewRoutingModule,
-    // Table Widgets
-    FindigWidgetModule,
-    CommentWidgetModule,
-    NbMenuModule,
-    ReportStateTagModule,
-    VersionTagModule,
-    NbUserModule,
-    NbContextMenuModule
-  ],
-  exports: [
-    ObjectiveHeaderComponent,
-    ObjectiveCategoriesComponent,
-    ObjectiveTableComponent
-  ],
-  providers: [
-    NbSortDirective
-  ]
-})
-export class ObjectiveOverviewModule {
-}

security-c4po-angular/src/app/objective-overview/objective-table/objective-table.component.html

@@ -1,92 +0,0 @@
-<div class="pentest-table">
-  <table [nbTreeGrid]="dataSource">
-    <!--ToDo: Add the click event to every td manually except the actions column actions-->
-    <tr nbTreeGridHeaderRow *nbTreeGridHeaderRowDef="columns"></tr>
-    <tr nbTreeGridRow *nbTreeGridRowDef="let pentest; columns: columns"
-        class="pentest-cell"
-        [ngClass]="{'disabled-objective' : !pentest.data['enabled']}">
-    </tr>
-    <!-- Test ID -->
-    <ng-container [nbTreeGridColumnDef]="columns[0]">
-      <th nbTreeGridHeaderCell *nbTreeGridHeaderCellDef>
-        {{ 'pentest.testId' | translate }}
-      </th>
-      <td nbTreeGridCell *nbTreeGridCellDef="let pentest" (click)="onClickRouteToObjectivePentest(pentest.data)">
-        <!-- Opens sub categories if row needs to be extendend -->
-        <nb-tree-grid-row-toggle
-          [expanded]="pentest.expanded"
-          *ngIf="pentest.data?.childEntries?.length > 0">
-        </nb-tree-grid-row-toggle>
-        <!---->
-        {{pentest.data['refNumber'] || '-'}}
-      </td>
-    </ng-container>
-    <!-- Title -->
-    <ng-container [nbTreeGridColumnDef]="columns[1]">
-      <th nbTreeGridHeaderCell *nbTreeGridHeaderCellDef>
-        {{ 'pentest.title' | translate }}
-      </th>
-      <td nbTreeGridCell *nbTreeGridCellDef="let pentest" (click)="onClickRouteToObjectivePentest(pentest.data)">
-        {{ getTitle(pentest.data['refNumber']) | translate }}
-      </td>
-    </ng-container>
-    <!-- Status -->
-    <ng-container [nbTreeGridColumnDef]="columns[2]">
-      <th nbTreeGridHeaderCell *nbTreeGridHeaderCellDef>
-        {{ 'pentest.status' | translate }}
-      </th>
-      <td nbTreeGridCell *nbTreeGridCellDef="let pentest" (click)="onClickRouteToObjectivePentest(pentest.data)">
-        <app-status-tag [currentStatus]="pentest.data['status']"></app-status-tag>
-      </td>
-    </ng-container>
-    <!-- Findings -->
-    <ng-container [nbTreeGridColumnDef]="columns[3]">
-      <th nbTreeGridHeaderCell *nbTreeGridHeaderCellDef>
-        {{ 'pentest.findings&comments' | translate }}
-      </th>
-      <td nbTreeGridCell *nbTreeGridCellDef="let pentest" (click)="onClickRouteToObjectivePentest(pentest.data)">
-        <div fxLayout="row" fxLayoutGap="0.5rem" fxLayoutAlign="center center">
-          <app-findig-widget [numberOfFindings]="pentest.data['findingIds'] ? pentest.data['findingIds'].length : 0"></app-findig-widget>
-          <span> / </span>
-          <app-comment-widget [numberOfComments]="pentest.data['commentIds'] ? pentest.data['commentIds'].length : 0"></app-comment-widget>
-        </div>
-      </td>
-    </ng-container>
-    <!-- Actions -->
-    <ng-container [nbTreeGridColumnDef]="columns[4]">
-      <th nbTreeGridHeaderCell *nbTreeGridHeaderCellDef class="cell-actions">
-          {{'global.actions' | translate}}
-      </th>
-      <td nbTreeGridCell *nbTreeGridCellDef="let pentest" class="cell-actions">
-        <div fxLayoutAlign="center center">
-          <ng-container  *ngIf="pentest.data['enabled'] === true; else renderDisablePentestButton">
-            <button
-              nbButton
-              status="danger"
-              size="small"
-              shape="round"
-              title="{{ 'global.action.disable' | translate }}"
-              [disabled]="!pentest.data['id']"
-              (click)="onClickDisableOrEnableObjective(pentest)">
-              <fa-icon [icon]="fa.faBan"></fa-icon>
-            </button>
-          </ng-container>
-          <ng-template #renderDisablePentestButton>
-            <button
-              nbButton
-              status="control"
-              size="small"
-              shape="round"
-              title="{{ 'global.action.enable' | translate }}"
-              [disabled]="!pentest.data['id']"
-              (click)="onClickDisableOrEnableObjective(pentest)">
-              <fa-icon [icon]="fa.faCheck"></fa-icon>
-            </button>
-          </ng-template>
-        </div>
-      </td>
-    </ng-container>
-  </table>
-</div>
-
-<app-loading-spinner [isLoading$]="isLoading()" *ngIf="isLoading() | async"></app-loading-spinner>

security-c4po-angular/src/app/objective-overview/objective-table/objective-table.component.scss

@@ -1,31 +0,0 @@
-@import '../../../assets/@theme/styles/themes';
-
-.pentest-table {
-  // width: calc(78vw - 18%);
-  // width: 100%;
-  // width: calc(100% - 20rem);
-  margin-right: 2rem;
-  padding-right: 2rem;
-
-  .pentest-cell {
-    // Add style here
-  }
-
-  .pentest-cell:hover {
-    cursor: pointer;
-    background-color: nb-theme(color-basic-transparent-focus);
-  }
-
-  .disabled-objective {
-    background-color: nb-theme(color-control-transparent-disabled);
-  }
-
-  .disabled-objective:hover {
-    cursor: not-allowed;
-  }
-
-  .cell-actions {
-    width: max-content;
-    max-width: 180px;
-  }
-}

security-c4po-angular/src/app/objective-overview/objective-table/objective-table.component.ts

@@ -1,192 +0,0 @@
-import {Component, OnInit} from '@angular/core';
-import {NbGetters, NbTreeGridDataSource, NbTreeGridDataSourceBuilder} from '@nebular/theme';
-import {ObjectiveEntry, Pentest, transformPentestsToObjectiveEntries} from '@shared/models/pentest.model';
-import {PentestService} from '@shared/services/api/pentest.service';
-import {Store} from '@ngxs/store';
-import {ProjectState} from '@shared/stores/project-state/project-state';
-import {UntilDestroy, untilDestroyed} from '@ngneat/until-destroy';
-import {catchError, filter, switchMap, tap} from 'rxjs/operators';
-import {BehaviorSubject, Observable, of} from 'rxjs';
-import {getTitleKeyForRefNumber} from '@shared/functions/categories/get-title-key-for-ref-number.function';
-import {Router} from '@angular/router';
-import {ChangePentest} from '@shared/stores/project-state/project-state.actions';
-import {Route} from '@shared/models/route.enum';
-import * as FA from '@fortawesome/free-solid-svg-icons';
-import {DialogService} from '@shared/services/dialog-service/dialog.service';
-import {NotificationService, PopupType} from '@shared/services/toaster-service/notification.service';
-import {Project} from '@shared/models/project.model';
-import {sortDescending} from '@shared/functions/sort-names.function';
-
-@UntilDestroy()
-@Component({
-  selector: 'app-objective-table',
-  templateUrl: './objective-table.component.html',
-  styleUrls: ['./objective-table.component.scss']
-})
-export class ObjectiveTableComponent implements OnInit {
-  // HTML only
-  readonly fa = FA;
-
-  loading$: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(true);
-  columns: Array<ObjectiveColumns> = [
-    ObjectiveColumns.TEST_ID,
-    ObjectiveColumns.TITLE,
-    ObjectiveColumns.STATUS,
-    ObjectiveColumns.FINDINGS_AND_COMMENTS,
-    ObjectiveColumns.ACTIONS
-  ];
-  dataSource: NbTreeGridDataSource<ObjectiveEntry>;
-
-  private data: ObjectiveEntry[] = [];
-  private pentests$: BehaviorSubject<Pentest[]> = new BehaviorSubject<Pentest[]>([]);
-  // Needed for pentest enabling and disabling
-  selectedProjectId$: BehaviorSubject<string> = new BehaviorSubject<string>('');
-
-  getters: NbGetters<ObjectiveEntry, ObjectiveEntry> = {
-    dataGetter: (node: ObjectiveEntry) => node,
-    childrenGetter: (node: ObjectiveEntry) => node.childEntries || undefined,
-    expandedGetter: (node: ObjectiveEntry) => !!node.expanded
-  };
-
-  constructor(
-    private store: Store,
-    private pentestService: PentestService,
-    private dialogService: DialogService,
-    private notificationService: NotificationService,
-    private dataSourceBuilder: NbTreeGridDataSourceBuilder<ObjectiveEntry>,
-    private router: Router
-  ) {
-    this.dataSource = dataSourceBuilder.create(this.data, this.getters);
-  }
-
-  ngOnInit(): void {
-    this.store.selectOnce(ProjectState.project).pipe(
-      untilDestroyed(this)
-    ).subscribe({
-      next: (selectedProject: Project) => {
-        this.selectedProjectId$.next(selectedProject.id);
-      },
-      error: err => {
-        console.error(err);
-      }
-    });
-    this.loadPentestData();
-  }
-
-  loadPentestData(): void {
-    this.store.select(ProjectState.selectedCategory).pipe(
-      switchMap(category => this.pentestService.loadPentests(category)),
-      tap(() => this.loading$.next(true)),
-      catchError(_ => of(null)),
-      untilDestroyed(this)
-    ).subscribe({
-      next: (pentests: Pentest[]) => {
-        // Sort data without before adding as table data source
-        const sortedPentests = pentests.sort((a: Pentest, b: Pentest) =>
-          sortDescending(a.refNumber.toLowerCase(), b.refNumber.toLowerCase())
-        );
-        this.pentests$.next(sortedPentests);
-        this.data = transformPentestsToObjectiveEntries(sortedPentests);
-        this.dataSource.setData(this.data, this.getters);
-        this.loading$.next(false);
-      },
-      error: error => {
-        this.loading$.next(false);
-        console.error(error);
-      }
-    });
-  }
-
-  onClickRouteToObjectivePentest(selectedPentest: Pentest): void {
-    if (selectedPentest.enabled) {
-
-      this.router.navigate([Route.PENTEST_OBJECTIVE])
-        .then(
-          () => this.store.reset({
-            ...this.store.snapshot(),
-          })
-        ).finally();
-      // Change Pentest State
-      const statePentest: Pentest = this.pentests$.getValue().find(pentest => pentest.refNumber === selectedPentest.refNumber);
-      if (statePentest) {
-        this.store.dispatch(new ChangePentest(statePentest));
-      } else {
-        let childEntryStatePentest;
-        // ToDo: Fix wrong selection
-        // tslint:disable-next-line:prefer-for-of
-        for (let i = 0; i < this.pentests$.getValue().length; i++) {
-          if (this.pentests$.getValue()[i].childEntries) {
-            const findingResult = this.pentests$.getValue()[i].childEntries.find(cE => cE.refNumber === selectedPentest.refNumber);
-            if (findingResult) {
-              childEntryStatePentest = findingResult;
-              break;
-            }
-          }
-        }
-        this.store.dispatch(new ChangePentest(childEntryStatePentest));
-      }
-    }
-  }
-
-  onClickDisableOrEnableObjective(pentest): void {
-    if (pentest.data.enabled) {
-      const message = {
-        title: 'pentest.disable.title',
-        key: 'pentest.disable.key',
-        data: {name: pentest.data.refNumber},
-      };
-      this.dialogService.openConfirmDialog(
-        message
-      ).onClose.pipe(
-        filter((confirm) => !!confirm),
-        untilDestroyed(this)
-      ).subscribe({
-        next: () => {
-          this.pentestService.disableObjective(this.selectedProjectId$.getValue(), pentest.data.id).pipe(
-            untilDestroyed(this)
-          ).subscribe({
-            next: () => {
-              this.loadPentestData();
-              this.notificationService.showPopup('pentest.popup.disable.success', PopupType.SUCCESS);
-            },
-            error: (err) => {
-              this.notificationService.showPopup('pentest.popup.disable.failed', PopupType.FAILURE);
-              console.error(err);
-            }
-          });
-        }
-      });
-    } else {
-      this.pentestService.enableObjective(this.selectedProjectId$.getValue(), pentest.data.id).pipe(
-        untilDestroyed(this)
-      ).subscribe({
-        next: () => {
-          this.loadPentestData();
-          this.notificationService.showPopup('pentest.popup.enable.success', PopupType.SUCCESS);
-        },
-        error: (err) => {
-          this.notificationService.showPopup('pentest.popup.enable.failed', PopupType.FAILURE);
-          console.error(err);
-        }
-      });
-    }
-  }
-
-  // HTML only
-  getTitle(refNumber: string): string {
-    return getTitleKeyForRefNumber(refNumber);
-  }
-
-  // HTML only
-  isLoading(): Observable<boolean> {
-    return this.loading$.asObservable();
-  }
-}
-
-enum ObjectiveColumns {
-  TEST_ID = 'testId',
-  TITLE = 'title',
-  STATUS = 'status',
-  FINDINGS_AND_COMMENTS = 'findings&comments',
-  ACTIONS = 'actions'
-}

security-c4po-angular/src/app/pentest-overview/index.ts

@@ -0,0 +1,2 @@
+export {PentestOverviewModule} from './pentest-overview.module';
+export {PentestOverviewRoutingModule} from './pentest-overview-routing.module';

security-c4po-angular/src/app/pentest-overview/pentest-categories/pentest-categories.component.html

@@ -0,0 +1,5 @@
+<div class="pentest-categories">
+  <nb-menu class="menu-style" tag="menu" [items]="categories"></nb-menu>
+</div>
+
+

security-c4po-angular/src/app/pentest-overview/pentest-categories/pentest-categories.component.scss

@@ -1,5 +1,5 @@
 @import '../../../assets/@theme/styles/themes';
 
 .pentest-categories {
-  width: 20rem;
+  width: 22vw;
 }

security-c4po-angular/src/app/pentest-overview/pentest-categories/pentest-categories.component.spec.ts

@@ -1,6 +1,6 @@
 import { ComponentFixture, TestBed } from '@angular/core/testing';
 
-import { ObjectiveCategoriesComponent } from './objective-categories.component';
+import { PentestCategoriesComponent } from './pentest-categories.component';
 import {NbMenuModule, NbMenuService} from '@nebular/theme';
 import {NgxsModule} from '@ngxs/store';
 import {ProjectState} from '@shared/stores/project-state/project-state';
@@ -13,14 +13,14 @@ import {BrowserAnimationsModule} from '@angular/platform-browser/animations';
 import {ThemeModule} from '@assets/@theme/theme.module';
 import {RouterTestingModule} from '@angular/router/testing';
 
-describe('ObjectiveCategoriesComponent', () => {
-  let component: ObjectiveCategoriesComponent;
-  let fixture: ComponentFixture<ObjectiveCategoriesComponent>;
+describe('PentestCategoriesComponent', () => {
+  let component: PentestCategoriesComponent;
+  let fixture: ComponentFixture<PentestCategoriesComponent>;
 
   beforeEach(async () => {
     await TestBed.configureTestingModule({
       declarations: [
-        ObjectiveCategoriesComponent
+        PentestCategoriesComponent
       ],
       imports: [
         CommonModule,
@@ -47,7 +47,7 @@ describe('ObjectiveCategoriesComponent', () => {
   });
 
   beforeEach(() => {
-    fixture = TestBed.createComponent(ObjectiveCategoriesComponent);
+    fixture = TestBed.createComponent(PentestCategoriesComponent);
     component = fixture.componentInstance;
     fixture.detectChanges();
   });

security-c4po-angular/src/app/pentest-overview/pentest-categories/pentest-categories.component.ts

@@ -1,22 +1,23 @@
 import {Component, OnDestroy, OnInit} from '@angular/core';
 import {NbMenuItem, NbMenuService} from '@nebular/theme';
+import {Subject} from 'rxjs';
 import {Store} from '@ngxs/store';
 import {ChangeCategory} from '@shared/stores/project-state/project-state.actions';
 import {Category} from '@shared/models/category.model';
+import {untilDestroyed} from 'ngx-take-until-destroy';
 import {TranslateService} from '@ngx-translate/core';
-import {ProjectState} from '@shared/stores/project-state/project-state';
-import {UntilDestroy, untilDestroyed} from '@ngneat/until-destroy';
 
 @Component({
-  selector: 'app-objective-categories',
-  templateUrl: './objective-categories.component.html',
-  styleUrls: ['./objective-categories.component.scss']
+  selector: 'app-pentest-categories',
+  templateUrl: './pentest-categories.component.html',
+  styleUrls: ['./pentest-categories.component.scss']
 })
-@UntilDestroy()
-export class ObjectiveCategoriesComponent implements OnInit {
+export class PentestCategoriesComponent implements OnInit, OnDestroy {
   categories: NbMenuItem[] = [];
   selectedCategory: Category = 0;
 
+  private destroy$ = new Subject<void>();
+
   constructor(private store: Store,
               private menuService: NbMenuService,
               private translateService: TranslateService) {
@@ -24,38 +25,22 @@ export class ObjectiveCategoriesComponent implements OnInit {
 
   ngOnInit(): void {
     this.initTranslation();
-    this.store.select(ProjectState.selectedCategory).pipe(
-      untilDestroyed(this)
-    ).subscribe({
-      next: (categoryIndex) => {
-        if (categoryIndex) {
-          this.selectedCategory = categoryIndex;
-          this.categories[categoryIndex].selected = true;
-        } else {
-          // Set first item in list as selected
-          this.categories[0].selected = true;
-        }
-      },
-      error: error => {
-        console.error(error);
-      }
-    });
+    // Set first item in list as selected
+    this.categories[0].selected = true;
     this.menuService.onItemClick()
       .pipe(
         untilDestroyed(this)
       )
       .subscribe((menuBag) => {
-        if (menuBag.tag === 'menu') {
-          this.selectedCategory = menuBag.item.data;
-          this.categories.forEach(category => {
-            category.selected = false;
-          });
-          if (this.selectedCategory >= 0) {
-            menuBag.item.selected = true;
-            this.store.dispatch(new ChangeCategory(this.selectedCategory));
-          }
-        }
+        this.selectedCategory = menuBag.item.data;
+        this.categories.forEach(category => {
+          category.selected = false;
+        });
+        menuBag.item.selected = true;
+        this.store.dispatch(new ChangeCategory(this.selectedCategory));
       });
+
+
   }
 
   private initTranslation(): void {
@@ -84,4 +69,9 @@ export class ObjectiveCategoriesComponent implements OnInit {
       }
     }
   }
+
+  ngOnDestroy(): void {
+    this.destroy$.next();
+    this.destroy$.complete();
+  }
 }

security-c4po-angular/src/app/pentest-overview/pentest-header/pentest-header.component.html

@@ -0,0 +1,28 @@
+<div class="pentest-header" fxLayout="row" fxLayoutGap="2rem" fxLayoutAlign="space-between center">
+  <div class="back-button-container">
+    <button nbButton
+            shape="round"
+            title="{{ 'global.action.return' | translate }}"
+            (click)="onClickRouteBack()">
+      <fa-icon [icon]="fa.faLongArrowAltLeft"
+               class="back-element-icon fa-lg"></fa-icon>
+    </button>
+  </div>
+
+  <h4>{{selectedProjectTitle$.getValue()}}</h4>
+
+  <div class="export-button-container">
+    <nb-actions size="medium">
+      <nb-action>
+        <button nbButton hero
+                status="primary"
+                shape="round"
+                (click)="onClickExportPentest()">
+          <fa-icon [icon]="fa.faFileExport"
+                   class="export-element-icon fa-lg"></fa-icon>
+          <span class="export-element-text">{{ 'global.action.export' | translate }}</span>
+        </button>
+      </nb-action>
+    </nb-actions>
+  </div>
+</div>

security-c4po-angular/src/app/pentest-overview/pentest-header/pentest-header.component.scss

@@ -0,0 +1,22 @@
+.pentest-header {
+  width: calc(100vw - 14%);
+
+  .back-button-container {
+    .back-element-icon {
+    }
+  }
+
+  .export-button-container {
+    display: flex;
+    align-content: flex-end;
+    margin-right: 1rem;
+
+    .export-element-icon {
+    }
+
+    .export-element-text {
+      padding-left: 0.5rem;
+      font-size: 0.85rem;
+    }
+  }
+}

security-c4po-angular/src/app/pentest-overview/pentest-header/pentest-header.component.spec.ts

@@ -1,38 +1,32 @@
 import {ComponentFixture, TestBed} from '@angular/core/testing';
 
-import {ObjectiveChartComponent} from './objective-chart.component';
-import {CommonModule} from '@angular/common';
-import {NbButtonModule, NbCardModule, NbFormFieldModule, NbInputModule, NbLayoutModule, NbTagModule} from '@nebular/theme';
-import {FlexLayoutModule} from '@angular/flex-layout';
-import {ReactiveFormsModule} from '@angular/forms';
+import {PentestHeaderComponent} from './pentest-header.component';
 import {BrowserAnimationsModule} from '@angular/platform-browser/animations';
+import {HttpClientTestingModule} from '@angular/common/http/testing';
 import {ThemeModule} from '@assets/@theme/theme.module';
 import {TranslateLoader, TranslateModule} from '@ngx-translate/core';
-import {HttpLoaderFactory} from '../../../app/common-app.module';
-import {HttpClient, HttpClientModule} from '@angular/common/http';
+import {HttpLoaderFactory} from '../../common-app.module';
+import {HttpClient} from '@angular/common/http';
+import {RouterTestingModule} from '@angular/router/testing';
 import {NgxsModule} from '@ngxs/store';
 import {ProjectState} from '@shared/stores/project-state/project-state';
-import {HttpClientTestingModule} from '@angular/common/http/testing';
+import {FontAwesomeModule} from '@fortawesome/angular-fontawesome';
+import {NbActionsModule, NbIconModule} from '@nebular/theme';
 
-describe('ObjectiveChartComponent', () => {
-  let component: ObjectiveChartComponent;
-  let fixture: ComponentFixture<ObjectiveChartComponent>;
+describe('PentestHeaderComponent', () => {
+  let component: PentestHeaderComponent;
+  let fixture: ComponentFixture<PentestHeaderComponent>;
 
   beforeEach(async () => {
     await TestBed.configureTestingModule({
-      declarations: [
-        ObjectiveChartComponent
-      ],
+      declarations: [PentestHeaderComponent],
       imports: [
-        CommonModule,
-        NbLayoutModule,
-        NbCardModule,
-        FlexLayoutModule,
-        NbInputModule,
-        NbTagModule,
-        ReactiveFormsModule,
         BrowserAnimationsModule,
+        HttpClientTestingModule,
         ThemeModule.forRoot(),
+        FontAwesomeModule,
+        NbIconModule,
+        NbActionsModule,
         TranslateModule.forRoot({
           loader: {
             provide: TranslateLoader,
@@ -40,16 +34,15 @@ describe('ObjectiveChartComponent', () => {
             deps: [HttpClient]
           }
         }),
-        NgxsModule.forRoot([ProjectState]),
-        HttpClientModule,
-        HttpClientTestingModule
+        RouterTestingModule.withRoutes([]),
+        NgxsModule.forRoot([ProjectState])
       ]
     })
       .compileComponents();
   });
 
   beforeEach(() => {
-    fixture = TestBed.createComponent(ObjectiveChartComponent);
+    fixture = TestBed.createComponent(PentestHeaderComponent);
     component = fixture.componentInstance;
     fixture.detectChanges();
   });

security-c4po-angular/src/app/pentest-overview/pentest-header/pentest-header.component.ts

@@ -0,0 +1,53 @@
+import {Component, OnInit} from '@angular/core';
+import * as FA from '@fortawesome/free-solid-svg-icons';
+import {Route} from '@shared/models/route.enum';
+import {Store} from '@ngxs/store';
+import {Router} from '@angular/router';
+import {PROJECT_STATE_NAME, ProjectState} from '@shared/stores/project-state/project-state';
+import {UntilDestroy, untilDestroyed} from '@ngneat/until-destroy';
+import {BehaviorSubject} from 'rxjs';
+import {Project} from '@shared/models/project.model';
+
+@UntilDestroy()
+@Component({
+  selector: 'app-pentest-header',
+  templateUrl: './pentest-header.component.html',
+  styleUrls: ['./pentest-header.component.scss']
+})
+export class PentestHeaderComponent implements OnInit {
+
+  readonly fa = FA;
+  selectedProjectTitle$: BehaviorSubject<string> = new BehaviorSubject<string>('');
+
+  constructor(private store: Store,
+              private readonly router: Router) {
+  }
+
+  ngOnInit(): void {
+    this.store.select(ProjectState.project).pipe(
+      untilDestroyed(this)
+    ).subscribe({
+      next: (selectedProject: Project) => {
+        this.selectedProjectTitle$.next(selectedProject?.title);
+      },
+      error: err => {
+        console.error(err);
+      }
+    });
+  }
+
+  onClickRouteBack(): void {
+    this.router.navigate([Route.PROJECT_OVERVIEW])
+      .then(
+        () => this.store.reset({
+          ...this.store.snapshot(),
+          [PROJECT_STATE_NAME]: undefined
+        })
+      ).finally();
+  }
+
+  onClickExportPentest(): void {
+    // tslint:disable-next-line:no-console
+    console.info('To be implemented..');
+  }
+}

security-c4po-angular/src/app/pentest-overview/pentest-overview-routing.module.ts

@@ -8,5 +8,5 @@ const routes: Routes = [
   imports: [RouterModule.forChild(routes)],
   exports: [RouterModule]
 })
-export class PentestRoutingModule {
+export class PentestOverviewRoutingModule {
 }

security-c4po-angular/src/app/pentest-overview/pentest-overview.module.ts

@@ -0,0 +1,58 @@
+import {NgModule} from '@angular/core';
+import {CommonModule} from '@angular/common';
+import {PentestHeaderComponent} from './pentest-header/pentest-header.component';
+import {PentestCategoriesComponent} from './pentest-categories/pentest-categories.component';
+import {PentestTableComponent} from './pentest-table/pentest-table.component';
+import {
+  NbCardModule,
+  NbLayoutModule,
+  NbTreeGridModule,
+  NbMenuModule,
+  NbListModule,
+  NbButtonModule,
+  NbTooltipModule,
+  NbActionsModule
+} from '@nebular/theme';
+import {TranslateModule} from '@ngx-translate/core';
+import {StatusTagModule} from '@shared/widgets/status-tag/status-tag.module';
+import {FindigWidgetModule} from '@shared/widgets/findig-widget/findig-widget.module';
+import {RouterModule} from '@angular/router';
+import {FormsModule} from '@angular/forms';
+import {FontAwesomeModule} from '@fortawesome/angular-fontawesome';
+import {FlexLayoutModule} from '@angular/flex-layout';
+
+@NgModule({
+  declarations: [
+    PentestHeaderComponent,
+    PentestCategoriesComponent,
+    PentestTableComponent
+  ],
+  exports: [
+    PentestHeaderComponent,
+    PentestCategoriesComponent,
+    PentestTableComponent
+  ],
+  imports: [
+    CommonModule,
+    NbLayoutModule,
+    NbCardModule,
+    NbMenuModule.forRoot(),
+    NbButtonModule,
+    // nbTooltip crashes app right now if used in component,
+    // workaround: use title in html for now
+    NbTooltipModule,
+    NbTreeGridModule,
+    TranslateModule,
+    StatusTagModule,
+    FindigWidgetModule,
+    RouterModule,
+    NbMenuModule,
+    FormsModule,
+    NbListModule,
+    FontAwesomeModule,
+    FlexLayoutModule,
+    NbActionsModule
+  ]
+})
+export class PentestOverviewModule {
+}

security-c4po-angular/src/app/pentest-overview/pentest-table/pentest-table.component.html

@@ -0,0 +1,55 @@
+<nb-card class="pentest-table">
+  <table [nbTreeGrid]="dataSource">
+    <tr nbTreeGridHeaderRow *nbTreeGridHeaderRowDef="columns"></tr>
+    <tr nbTreeGridRow *nbTreeGridRowDef="let pentest; columns: columns"
+        class="pentest-cell"
+        routerLink="pentest"
+        fragment="{{pentest.data['refNumber']}}"
+        (click)="selectPentest(pentest.data)"
+        [skipLocationChange]="true">
+    </tr>
+    <!-- Test ID -->
+    <ng-container [nbTreeGridColumnDef]="columns[0]">
+      <th nbTreeGridHeaderCell *nbTreeGridHeaderCellDef>
+        {{ 'pentest.testId' | translate }}
+      </th>
+      <td nbTreeGridCell *nbTreeGridCellDef="let pentest">
+        <!-- Opens sub categories if row needs to be extendend -->
+        <nb-tree-grid-row-toggle
+          [expanded]="pentest.expanded"
+          *ngIf="pentest.data?.childEntries?.length > 0">
+        </nb-tree-grid-row-toggle>
+        <!---->
+        {{pentest.data['refNumber'] || '-'}}
+      </td>
+    </ng-container>
+    <!-- Title -->
+    <ng-container [nbTreeGridColumnDef]="columns[1]">
+      <th nbTreeGridHeaderCell *nbTreeGridHeaderCellDef>
+        {{ 'pentest.title' | translate }}
+      </th>
+      <td nbTreeGridCell *nbTreeGridCellDef="let pentest">
+        {{ getTitle(pentest.data['refNumber']) | translate }}
+      </td>
+    </ng-container>
+    <!-- Status -->
+    <ng-container [nbTreeGridColumnDef]="columns[2]">
+      <th nbTreeGridHeaderCell *nbTreeGridHeaderCellDef>
+        {{ 'pentest.status' | translate }}
+      </th>
+      <td nbTreeGridCell *nbTreeGridCellDef="let pentest">
+        <app-status-tag [currentStatus]="pentest.data['status']"></app-status-tag>
+      </td>
+    </ng-container>
+    <!-- Findings -->
+    <ng-container [nbTreeGridColumnDef]="columns[3]">
+      <th nbTreeGridHeaderCell *nbTreeGridHeaderCellDef>
+        {{ 'pentest.findings' | translate }}
+      </th>
+      <td nbTreeGridCell *nbTreeGridCellDef="let pentest">
+        <app-findig-widget [numberOfFindigs]="pentest.data['findings']"></app-findig-widget>
+        <!--{{pentest.data['findings'] || '-'}}-->
+      </td>
+    </ng-container>
+  </table>
+</nb-card>

security-c4po-angular/src/app/pentest-overview/pentest-table/pentest-table.component.scss

@@ -0,0 +1,14 @@
+@import '../../../assets/@theme/styles/themes';
+
+.pentest-table {
+  width: calc(78vw - 18%);
+
+  .pentest-cell {
+    // Add style here
+  }
+
+  .pentest-cell:hover {
+    cursor: pointer;
+    background-color: nb-theme(color-basic-transparent-focus);
+  }
+}

security-c4po-angular/src/app/pentest-overview/pentest-table/pentest-table.component.spec.ts

@@ -1,6 +1,6 @@
 import {ComponentFixture, TestBed} from '@angular/core/testing';
 
-import {ObjectiveTableComponent} from './objective-table.component';
+import {PentestTableComponent} from './pentest-table.component';
 import {NbCardModule, NbTreeGridModule} from '@nebular/theme';
 import {TranslateLoader, TranslateModule} from '@ngx-translate/core';
 import {HttpLoaderFactory} from '../../common-app.module';
@@ -14,19 +14,15 @@ import {MockComponent} from 'ng-mocks';
 import {NgxsModule} from '@ngxs/store';
 import {ProjectState} from '@shared/stores/project-state/project-state';
 import {HttpClientTestingModule} from '@angular/common/http/testing';
-import {DialogService} from '@shared/services/dialog-service/dialog.service';
-import {DialogServiceMock} from '@shared/services/dialog-service/dialog.service.mock';
-import {NotificationService} from '@shared/services/toaster-service/notification.service';
-import {NotificationServiceMock} from '@shared/services/toaster-service/notification.service.mock';
 
-describe('ObjectiveTableComponent', () => {
-  let component: ObjectiveTableComponent;
-  let fixture: ComponentFixture<ObjectiveTableComponent>;
+describe('PentestTableComponent', () => {
+  let component: PentestTableComponent;
+  let fixture: ComponentFixture<PentestTableComponent>;
 
   beforeEach(async () => {
     await TestBed.configureTestingModule({
       declarations: [
-        ObjectiveTableComponent,
+        PentestTableComponent,
         MockComponent(StatusTagComponent),
         MockComponent(FindigWidgetComponent)
       ],
@@ -45,17 +41,13 @@ describe('ObjectiveTableComponent', () => {
         }),
         RouterTestingModule.withRoutes([]),
         NgxsModule.forRoot([ProjectState])
-      ],
-      providers: [
-        {provide: DialogService, useClass: DialogServiceMock},
-        {provide: NotificationService, useClass: NotificationServiceMock}
       ]
     })
       .compileComponents();
   });
 
   beforeEach(() => {
-    fixture = TestBed.createComponent(ObjectiveTableComponent);
+    fixture = TestBed.createComponent(PentestTableComponent);
     component = fixture.componentInstance;
     fixture.detectChanges();
   });

security-c4po-angular/src/app/pentest-overview/pentest-table/pentest-table.component.ts

@@ -0,0 +1,88 @@
+import {Component, OnInit} from '@angular/core';
+import {NbGetters, NbTreeGridDataSource, NbTreeGridDataSourceBuilder} from '@nebular/theme';
+import {Pentest, PentestEntry, transformPentestsToEntries} from '@shared/models/pentest.model';
+import {PentestService} from '@shared/services/pentest.service';
+import {Store} from '@ngxs/store';
+import {PROJECT_STATE_NAME, ProjectState} from '@shared/stores/project-state/project-state';
+import {UntilDestroy, untilDestroyed} from '@ngneat/until-destroy';
+import {catchError, switchMap} from 'rxjs/operators';
+import {of} from 'rxjs';
+import {getTitleKeyForRefNumber} from '@shared/functions/categories/get-title-key-for-ref-number.function';
+import {Route} from '@shared/models/route.enum';
+import {Router} from '@angular/router';
+import {ChangePentest} from '@shared/stores/project-state/project-state.actions';
+
+@UntilDestroy()
+@Component({
+  selector: 'app-pentest-table',
+  templateUrl: './pentest-table.component.html',
+  styleUrls: ['./pentest-table.component.scss']
+})
+export class PentestTableComponent implements OnInit {
+
+  columns: Array<PentestColumns> = [PentestColumns.TEST_ID, PentestColumns.TITLE, PentestColumns.STATUS, PentestColumns.FINDINGS];
+  dataSource: NbTreeGridDataSource<PentestEntry>;
+
+  private data: PentestEntry[] = [];
+
+  getters: NbGetters<PentestEntry, PentestEntry> = {
+    dataGetter: (node: PentestEntry) => node,
+    childrenGetter: (node: PentestEntry) => node.childEntries || undefined,
+    expandedGetter: (node: PentestEntry) => !!node.expanded,
+  };
+
+  constructor(
+    private store: Store,
+    private pentestService: PentestService,
+    private dataSourceBuilder: NbTreeGridDataSourceBuilder<PentestEntry>,
+    private readonly router: Router
+  ) {
+    this.dataSource = dataSourceBuilder.create(this.data, this.getters);
+  }
+
+  ngOnInit(): void {
+    this.loadPentestData();
+  }
+
+  loadPentestData(): void {
+    this.store.select(ProjectState.selectedCategory).pipe(
+      switchMap(category => this.pentestService.loadPentests(category)),
+      catchError(_ => of(null)),
+      untilDestroyed(this)
+    ).subscribe({
+      next: (pentests: Pentest[]) => {
+        this.data = transformPentestsToEntries(pentests);
+        this.dataSource.setData(this.data, this.getters);
+      },
+      error: error => {
+        console.error(error);
+      }
+    });
+  }
+
+  selectPentest(pentest: Pentest): void {
+    /* ToDo: Include again after fixing pentest route
+    this.router.navigate([Route.PENTEST])
+      .then(
+        () => this.store.reset({
+          ...this.store.snapshot(),
+          [PROJECT_STATE_NAME]: undefined
+        })
+      ).finally();
+    */
+    this.store.dispatch(new ChangePentest(pentest.id));
+
+  }
+
+  // HTML only
+  getTitle(refNumber: string): string {
+    return getTitleKeyForRefNumber(refNumber);
+  }
+}
+
+enum PentestColumns {
+  TEST_ID = 'testId',
+  TITLE = 'title',
+  STATUS = 'status',
+  FINDINGS = 'findings'
+}

security-c4po-angular/src/app/pentest-overview/pentest/pentest-routing.module.ts

@@ -1,12 +1,17 @@
 import {NgModule} from '@angular/core';
 import {RouterModule, Routes} from '@angular/router';
+import {PentestComponent} from './pentest.component';
 
 const routes: Routes = [
+  {
+    path: '',
+    component: PentestComponent
+  },
 ];
 
 @NgModule({
   imports: [RouterModule.forChild(routes)],
   exports: [RouterModule]
 })
-export class ObjectiveOverviewRoutingModule {
+export class PentestRoutingModule {
 }

security-c4po-angular/src/app/pentest-overview/pentest/pentest.component.html

@@ -0,0 +1,5 @@
+<nb-layout>
+  <nb-layout-header>
+    <p>pentest works!</p>
+  </nb-layout-header>
+</nb-layout>

security-c4po-angular/src/app/pentest-overview/pentest/pentest.component.ts

@@ -11,6 +11,7 @@ export class PentestComponent implements OnInit {
 
   ngOnInit(): void {
     // tslint:disable-next-line:no-console
+    console.info('pentest component renderd');
   }
 
 }

security-c4po-angular/src/app/pentest-overview/pentest/pentest.module.ts

@@ -0,0 +1,21 @@
+import {NgModule} from '@angular/core';
+import {CommonModule} from '@angular/common';
+import {RouterModule} from '@angular/router';
+import {PentestComponent} from './pentest.component';
+import {NbLayoutModule} from '@nebular/theme';
+
+@NgModule({
+  declarations: [
+    PentestComponent
+  ],
+  imports: [
+    CommonModule,
+    RouterModule.forChild([{
+      path: '',
+      component: PentestComponent
+    }]),
+    NbLayoutModule
+  ]
+})
+export class PentestModule {
+}

security-c4po-angular/src/app/pentest/pentest-content/pentest-comments/pentest-comments.component.html

@@ -1,76 +0,0 @@
-<div class="comment-table">
-  <table [nbTreeGrid]="dataSource">
-    <tr nbTreeGridHeaderRow *nbTreeGridHeaderRowDef="columns"></tr>
-    <tr nbTreeGridRow *nbTreeGridRowDef="let comment; columns: columns"
-        class="comment-cell"
-        fragment="{{comment.data['commentId']}}">
-    </tr>
-    <!-- Title -->
-    <ng-container [nbTreeGridColumnDef]="columns[0]">
-      <th nbTreeGridHeaderCell *nbTreeGridHeaderCellDef>
-        {{ 'comment.title' | translate }}
-      </th>
-      <td nbTreeGridCell *nbTreeGridCellDef="let comment">
-        <span *ngIf=" comment.data['title'].length < 200; else cutTitle">
-          {{ comment.data['title'] }}
-        </span>
-        <ng-template #cutTitle>
-          {{ comment.data['title'].slice(0, 200) + '...' }}
-        </ng-template>
-      </td>
-    </ng-container>
-    <!-- Description -->
-    <ng-container [nbTreeGridColumnDef]="columns[1]">
-      <th nbTreeGridHeaderCell *nbTreeGridHeaderCellDef>
-        {{ 'comment.description' | translate }}
-      </th>
-      <td nbTreeGridCell *nbTreeGridCellDef="let comment">
-        <span *ngIf=" comment.data['description'].length < 200; else cutDescription">
-          {{ comment.data['description'] }}
-        </span>
-        <ng-template #cutDescription>
-          {{ comment.data['description'].slice(0, 200) + '...' }}
-        </ng-template>
-      </td>
-    </ng-container>
-    <!-- Actions -->
-    <ng-container [nbTreeGridColumnDef]="columns[2]">
-      <th nbTreeGridHeaderCell *nbTreeGridHeaderCellDef class="cell-actions">
-        <button nbButton hero
-                status="info"
-                size="small"
-                shape="round"
-                class="add-comment-button"
-                [disabled]="pentestInfo$.getValue().status !== inProgressStatus"
-                (click)="onClickAddComment()">
-          <fa-icon [icon]="fa.faPlus" class="new-comment-icon"></fa-icon>
-          {{'comment.add' | translate}}
-        </button>
-      </th>
-      <td nbTreeGridCell *nbTreeGridCellDef="let comment" class="cell-actions">
-        <div fxLayout="row" fxLayoutAlign="center center" fxLayoutGap="1rem">
-          <button nbButton
-                  status="primary"
-                  size="small"
-                  (click)="onClickEditComment(comment)">
-            <fa-icon [icon]="fa.faPencilAlt"></fa-icon>
-          </button>
-          <button nbButton
-                  status="danger"
-                  size="small"
-                  (click)="onClickDeleteComment(comment)">
-            <fa-icon [icon]="fa.faTrash"></fa-icon>
-          </button>
-        </div>
-      </td>
-    </ng-container>
-  </table>
-</div>
-
-<div *ngIf="data.length === 0 && loading$.getValue() === false" fxLayout="row" fxLayoutAlign="center center">
-  <p class="error-text">
-    {{'comment.no.comments' | translate}}
-  </p>
-</div>
-
-<app-loading-spinner [isLoading$]="isLoading()" *ngIf="isLoading() | async"></app-loading-spinner>

security-c4po-angular/src/app/pentest/pentest-content/pentest-comments/pentest-comments.component.scss

@@ -1,49 +0,0 @@
-@import '../../../../assets/@theme/styles/themes';
-@import '../../../../assets/@theme/styles/_text-overflow.scss';
-
-.comment-table {
-  margin-right: 2rem;
-  padding-right: 2rem;
-
-  .comment-cell {
-    // Add style here
-    height: 4.5rem !important;
-    // max-height: 4.5rem !important;
-    overflow: hidden;
-  }
-
-  .comment-cell:hover {
-    // cursor: default;
-    background-color: nb-theme(color-basic-transparent-focus);
-  }
-
-  .cell {
-    height: 4.5rem !important;
-    max-height: 4.5rem !important;
-  }
-
-  .related-finding-cell {
-    height: 4.5rem !important;
-    max-height: 4.5rem !important;
-    // cursor: pointer;
-    font-family: Courier, serif;
-    color: nb-theme(color-danger-default);
-  }
-
-  .cell-actions {
-    width: max-content;
-    max-width: 200px;
-
-    .add-comment-button {
-      .new-comment-icon {
-        padding-right: 0.5rem;
-      }
-    }
-  }
-}
-
-.error-text {
-  padding-top: 0.5rem;
-  font-size: 1.25rem;
-  font-weight: bold;
-}

security-c4po-angular/src/app/pentest/pentest-content/pentest-comments/pentest-comments.component.spec.ts

@@ -1,109 +0,0 @@
-import {ComponentFixture, TestBed} from '@angular/core/testing';
-
-import {PentestCommentsComponent} from './pentest-comments.component';
-import {PROJECT_STATE_NAME, ProjectState, ProjectStateModel} from '@shared/stores/project-state/project-state';
-import {Category} from '@shared/models/category.model';
-import {PentestStatus} from '@shared/models/pentest-status.model';
-import {NgxsModule, Store} from '@ngxs/store';
-import {CommonModule} from '@angular/common';
-import {BrowserAnimationsModule} from '@angular/platform-browser/animations';
-import {HttpClientTestingModule} from '@angular/common/http/testing';
-import {FontAwesomeModule} from '@fortawesome/angular-fontawesome';
-import {NbButtonModule, NbTreeGridModule} from '@nebular/theme';
-import {ThemeModule} from '@assets/@theme/theme.module';
-import {TranslateLoader, TranslateModule} from '@ngx-translate/core';
-import {HttpLoaderFactory} from '../../../common-app.module';
-import {HttpClient} from '@angular/common/http';
-import {NotificationService} from '@shared/services/toaster-service/notification.service';
-import {NotificationServiceMock} from '@shared/services/toaster-service/notification.service.mock';
-import {MockComponent} from 'ng-mocks';
-import {LoadingSpinnerComponent} from '@shared/widgets/loading-spinner/loading-spinner.component';
-import {DialogService} from '@shared/services/dialog-service/dialog.service';
-import {DialogServiceMock} from '@shared/services/dialog-service/dialog.service.mock';
-import {CommentDialogService} from '@shared/modules/comment-dialog/service/comment-dialog.service';
-import {CommentDialogServiceMock} from '@shared/modules/comment-dialog/service/comment-dialog.service.mock';
-import {ReportState} from '@shared/models/state.enum';
-
-const DESIRED_PROJECT_STATE_SESSION: ProjectStateModel = {
-  allProjects: [],
-  selectedProject: {
-    id: '56c47c56-3bcd-45f1-a05b-c197dbd33111',
-    client: 'E Corp',
-    title: 'Some Mock API (v1.0) Scanning',
-    createdAt: new Date('2019-01-10T09:00:00'),
-    tester: 'Novatester',
-    summary: '',
-    state: ReportState.NEW,
-    version: '1.0',
-    testingProgress: 0,
-    createdBy: '11c47c56-3bcd-45f1-a05b-c197dbd33110'
-  },
-  // Manages Categories
-  disabledCategories: [],
-  selectedCategory: Category.INFORMATION_GATHERING,
-  // Manages Pentests of Category
-  disabledPentests: [],
-  selectedPentest: {
-    id: '56c47c56-3bcd-45f1-a05b-c197dbd33112',
-    category: Category.INFORMATION_GATHERING,
-    refNumber: 'OTF-001',
-    childEntries: [],
-    status: PentestStatus.NOT_STARTED,
-    enabled: true,
-    findingIds: [],
-    commentIds: ['56c47c56-3bcd-45f1-a05b-c197dbd33112']
-  },
-};
-
-describe('PentestCommentsComponent', () => {
-  let component: PentestCommentsComponent;
-  let fixture: ComponentFixture<PentestCommentsComponent>;
-  let store: Store;
-
-  beforeEach(async () => {
-    await TestBed.configureTestingModule({
-      declarations: [
-        PentestCommentsComponent,
-        MockComponent(LoadingSpinnerComponent)
-      ],
-      imports: [
-        CommonModule,
-        BrowserAnimationsModule,
-        HttpClientTestingModule,
-        FontAwesomeModule,
-        NbButtonModule,
-        NbTreeGridModule,
-        ThemeModule.forRoot(),
-        TranslateModule.forRoot({
-          loader: {
-            provide: TranslateLoader,
-            useFactory: HttpLoaderFactory,
-            deps: [HttpClient]
-          }
-        }),
-        NgxsModule.forRoot([ProjectState])
-      ],
-      providers: [
-        {provide: NotificationService, useValue: new NotificationServiceMock()},
-        {provide: DialogService, useClass: DialogServiceMock},
-        {provide: CommentDialogService, useClass: CommentDialogServiceMock},
-      ]
-    })
-      .compileComponents();
-  });
-
-  beforeEach(() => {
-    fixture = TestBed.createComponent(PentestCommentsComponent);
-    store = TestBed.inject(Store);
-    store.reset({
-      ...store.snapshot(),
-      [PROJECT_STATE_NAME]: DESIRED_PROJECT_STATE_SESSION
-    });
-    component = fixture.componentInstance;
-    fixture.detectChanges();
-  });
-
-  it('should create', () => {
-    expect(component).toBeTruthy();
-  });
-});

security-c4po-angular/src/app/pentest/pentest-content/pentest-comments/pentest-comments.component.ts

@@ -1,235 +0,0 @@
-import {Component, OnInit} from '@angular/core';
-import {BehaviorSubject, Observable} from 'rxjs';
-import {Pentest} from '@shared/models/pentest.model';
-import * as FA from '@fortawesome/free-solid-svg-icons';
-import {NbGetters, NbTreeGridDataSource, NbTreeGridDataSourceBuilder} from '@nebular/theme';
-import {NotificationService, PopupType} from '@shared/services/toaster-service/notification.service';
-import {UntilDestroy, untilDestroyed} from '@ngneat/until-destroy';
-import {filter, tap} from 'rxjs/operators';
-import {
-  Comment,
-  CommentEntry,
-  transformCommentsToObjectiveEntries
-} from '@shared/models/comment.model';
-import {isNotNullOrUndefined} from 'codelyzer/util/isNotNullOrUndefined';
-import {ProjectState} from '@shared/stores/project-state/project-state';
-import {Store} from '@ngxs/store';
-import {PentestStatus} from '@shared/models/pentest-status.model';
-import {DialogService} from '@shared/services/dialog-service/dialog.service';
-import {CommentDialogService} from '@shared/modules/comment-dialog/service/comment-dialog.service';
-import {CommentService} from '@shared/services/api/comment.service';
-import {UpdatePentestComments} from '@shared/stores/project-state/project-state.actions';
-import {CommentDialogComponent} from '@shared/modules/comment-dialog/comment-dialog.component';
-import {Finding} from '@shared/models/finding.model';
-import {FindingService} from '@shared/services/api/finding.service';
-
-@UntilDestroy()
-@Component({
-  selector: 'app-pentest-comments',
-  templateUrl: './pentest-comments.component.html',
-  styleUrls: ['./pentest-comments.component.scss']
-})
-export class PentestCommentsComponent implements OnInit {
-
-  // HTML only
-  readonly fa = FA;
-  // HTML only for button enabling
-  inProgressStatus: PentestStatus = PentestStatus.IN_PROGRESS;
-
-  pentestInfo$: BehaviorSubject<Pentest> = new BehaviorSubject<Pentest>(null);
-  // comments$: BehaviorSubject<Comment[]> = new BehaviorSubject<Comment[]>(null);
-  loading$: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(true);
-
-  columns: Array<CommentColumns> = [
-    CommentColumns.TITLE, CommentColumns.DESCRIPTION, CommentColumns.ACTIONS
-  ];
-  dataSource: NbTreeGridDataSource<CommentEntry>;
-  data: CommentEntry[] = [];
-
-  getters: NbGetters<CommentEntry, CommentEntry> = {
-    dataGetter: (node: CommentEntry) => node,
-    childrenGetter: (node: CommentEntry) => node.childEntries || undefined,
-    expandedGetter: (node: CommentEntry) => !!node.expanded,
-  };
-
-  constructor(private readonly commentService: CommentService,
-              private readonly findingService: FindingService,
-              private dataSourceBuilder: NbTreeGridDataSourceBuilder<CommentEntry>,
-              private notificationService: NotificationService,
-              private dialogService: DialogService,
-              private commentDialogService: CommentDialogService,
-              private store: Store) {
-    this.dataSource = dataSourceBuilder.create(this.data, this.getters);
-  }
-
-  ngOnInit(): void {
-    this.store.select(ProjectState.pentest).pipe(
-      untilDestroyed(this)
-    ).subscribe({
-      next: (selectedPentest: Pentest) => {
-        this.pentestInfo$.next(selectedPentest);
-        this.loadCommentsData();
-        this.requestFindingsData(selectedPentest.id);
-      },
-      error: err => {
-        console.error(err);
-      }
-    });
-  }
-
-  loadCommentsData(): void {
-    this.commentService.getCommentsByPentestId(this.pentestInfo$.getValue() ? this.pentestInfo$.getValue().id : '')
-      .pipe(
-        untilDestroyed(this),
-        /*filter(isNotNullOrUndefined),*/
-        tap(() => this.loading$.next(true))
-      )
-      .subscribe({
-        next: (comments: Comment[]) => {
-          if (comments) {
-            this.data = transformCommentsToObjectiveEntries(comments);
-          } else {
-            this.data = [];
-          }
-          this.dataSource.setData(this.data, this.getters);
-          this.loading$.next(false);
-        },
-        error: err => {
-          console.error(err);
-          // ToDo: Implement again after proper lazy loading and routing
-          // this.notificationService.showPopup('comment.popup.not.found', PopupType.FAILURE);
-          this.loading$.next(false);
-        }
-      });
-  }
-
-  onClickAddComment(): void {
-    this.commentDialogService.openCommentDialog(
-      CommentDialogComponent,
-      this.pentestInfo$.getValue().findingIds,
-      null,
-      {
-        closeOnEsc: false,
-        hasScroll: false,
-        autoFocus: true,
-        closeOnBackdropClick: false
-      },
-      this.pentestInfo$.getValue()
-    ).pipe(
-      untilDestroyed(this)
-    ).subscribe({
-      next: (newComment: Comment) => {
-        this.loadCommentsData();
-      }
-    });
-  }
-
-  onClickEditComment(commentEntry): void {
-    this.commentService.getCommentById(commentEntry.data.commentId).pipe(
-      filter(isNotNullOrUndefined),
-      untilDestroyed(this)
-    ).subscribe({
-      next: (existingComment: Comment) => {
-        if (existingComment) {
-          this.commentDialogService.openCommentDialog(
-            CommentDialogComponent,
-            this.pentestInfo$.getValue().findingIds,
-            existingComment,
-            {
-              closeOnEsc: false,
-              hasScroll: false,
-              autoFocus: true,
-              closeOnBackdropClick: false
-            },
-            this.pentestInfo$.getValue()
-          ).pipe(
-            untilDestroyed(this)
-          ).subscribe({
-            next: (updatedComment: Comment) => {
-              this.loadCommentsData();
-            }
-          });
-        } else {
-          this.notificationService.showPopup('comment.popup.not.available', PopupType.INFO);
-        }
-      },
-      error: err => {
-        console.error(err);
-      }
-    });
-  }
-
-  requestFindingsData(pentestId: string): void {
-    this.findingService.getFindingsByPentestId(pentestId).pipe(
-      untilDestroyed(this)
-    ).subscribe({
-      next: (findings: Finding[]) => {
-        // findings.forEach(finding => this.objectiveFindings.push({id: finding.id, title: finding.title} as RelatedFindingOption));
-      },
-      error: err => {
-        console.error(err);
-      }
-    });
-  }
-
-  onClickDeleteComment(commentEntry): void {
-    const message = {
-      title: 'comment.delete.title',
-      key: 'comment.delete.key',
-      data: {name: commentEntry.data.title},
-    };
-    this.dialogService.openConfirmDialog(
-      message
-    ).onClose.pipe(
-      untilDestroyed(this)
-    ).subscribe({
-      next: () => {
-        this.deleteComment(commentEntry);
-      }
-    });
-  }
-
-  // HTML only
-  isLoading(): Observable<boolean> {
-    return this.loading$.asObservable();
-  }
-
-  private deleteComment(commentEntry): void {
-    this.commentService.deleteCommentByPentestAndCommentId(
-      this.pentestInfo$.getValue() ? this.pentestInfo$.getValue().id : '',
-      commentEntry.data.commentId)
-      .pipe(
-        untilDestroyed(this)
-      ).subscribe({
-      next: (deletedComment: any) => {
-        this.store.dispatch(new UpdatePentestComments(deletedComment.id));
-        this.loadCommentsData();
-        this.notificationService.showPopup('comment.popup.delete.success', PopupType.SUCCESS);
-      }, error: error => {
-        console.error(error);
-        this.onRequestFailed(commentEntry);
-        this.notificationService.showPopup('comment.popup.delete.failed', PopupType.FAILURE);
-      }
-    });
-  }
-
-  private onRequestFailed(retryParameter: any): void {
-    this.dialogService.openRetryDialog({key: 'global.retry.dialog', data: null}).onClose
-      .pipe(
-        untilDestroyed(this)
-      )
-      .subscribe((ref) => {
-        if (ref.retry) {
-          this.deleteComment(retryParameter);
-        }
-      });
-  }
-}
-
-enum CommentColumns {
-  COMMENT_ID = 'commentId',
-  TITLE = 'title',
-  DESCRIPTION = 'description',
-  RELATED_FINDINGS = 'relatedFindings',
-  ACTIONS = 'actions'
-}

security-c4po-angular/src/app/pentest/pentest-content/pentest-content.component.html

@@ -1,22 +0,0 @@
-<div class="pentest-content">
-  <div class="content">
-    <nb-tabset>
-      <nb-tab class="pentest-tabset" tabTitle="{{ 'global.action.info' | translate }}">
-        <app-pentest-info></app-pentest-info>
-      </nb-tab>
-      <nb-tab class="pentest-tabset" tabTitle="{{ 'pentest.findings' | translate }}"
-              badgeText="{{currentNumberOfFindings$.getValue()}}" badgeStatus="danger">
-        <app-pentest-findings></app-pentest-findings>
-      </nb-tab>
-      <nb-tab class="pentest-tabset" tabTitle="{{ 'pentest.comments' | translate }}"
-              badgeText="{{currentNumberOfComments$.getValue()}}" badgeStatus="control">
-        <app-pentest-comments></app-pentest-comments>
-      </nb-tab>
-    </nb-tabset>
-  </div>
-
-  <div fxLayoutAlign="end end" class="content-footer">
-    <!--ToDo: Use to put element in bottom-right corner -->
-  </div>
-</div>
-

security-c4po-angular/src/app/pentest/pentest-content/pentest-content.component.scss

@@ -1,20 +0,0 @@
-.pentest-content {
-  width: 100%;
-  height: 100%;
-
-  .content {
-    height: 95%;
-    overflow: auto !important;
-    // overflow: hidden !important;
-
-    // ToDo: Fixes tab header but also disables scrolling for content
-    /*nb-tab {
-      position: fixed;
-    }*/
-
-    .content-footer {
-      height: 5%;
-      margin: 1rem 6rem 1rem 0;
-    }
-  }
-}

security-c4po-angular/src/app/pentest/pentest-content/pentest-content.component.spec.ts

@@ -1,93 +0,0 @@
-import {ComponentFixture, TestBed} from '@angular/core/testing';
-
-import {PentestContentComponent} from './pentest-content.component';
-import {TranslateLoader, TranslateModule} from '@ngx-translate/core';
-import {HttpLoaderFactory} from '../../common-app.module';
-import {HttpClient} from '@angular/common/http';
-import {RouterTestingModule} from '@angular/router/testing';
-import {NgxsModule, Store} from '@ngxs/store';
-import {PROJECT_STATE_NAME, ProjectState, ProjectStateModel} from '@shared/stores/project-state/project-state';
-import {BrowserAnimationsModule} from '@angular/platform-browser/animations';
-import {HttpClientTestingModule} from '@angular/common/http/testing';
-import {Category} from '@shared/models/category.model';
-import {PentestStatus} from '@shared/models/pentest-status.model';
-import {NotificationService} from '@shared/services/toaster-service/notification.service';
-import {NotificationServiceMock} from '@shared/services/toaster-service/notification.service.mock';
-import {ReportState} from '@shared/models/state.enum';
-
-const DESIRED_PROJECT_STATE_SESSION: ProjectStateModel =  {
-  allProjects: [],
-  selectedProject: {
-    id: '56c47c56-3bcd-45f1-a05b-c197dbd33111',
-    client: 'E Corp',
-    title: 'Some Mock API (v1.0) Scanning',
-    createdAt: new Date('2019-01-10T09:00:00'),
-    tester: 'Novatester',
-    summary: '',
-    state: ReportState.NEW,
-    version: '1.0',
-    testingProgress: 0,
-    createdBy: '11c47c56-3bcd-45f1-a05b-c197dbd33110'
-  },
-  // Manages Categories
-  disabledCategories: [],
-  selectedCategory: Category.INFORMATION_GATHERING,
-  // Manages Pentests of Category
-  disabledPentests: [],
-  selectedPentest: {
-    id: '56c47c56-3bcd-45f1-a05b-c197dbd33112',
-    category: Category.INFORMATION_GATHERING,
-    refNumber: 'OTF-001',
-    childEntries: [],
-    status: PentestStatus.NOT_STARTED,
-    enabled: true,
-    findingIds: [],
-    commentIds: []
-  },
-};
-
-describe('PentestContentComponent', () => {
-  let component: PentestContentComponent;
-  let fixture: ComponentFixture<PentestContentComponent>;
-  let store: Store;
-
-  beforeEach(async () => {
-    await TestBed.configureTestingModule({
-      declarations: [
-        PentestContentComponent
-      ],
-      imports: [
-        BrowserAnimationsModule,
-        HttpClientTestingModule,
-        TranslateModule.forRoot({
-          loader: {
-            provide: TranslateLoader,
-            useFactory: HttpLoaderFactory,
-            deps: [HttpClient]
-          }
-        }),
-        RouterTestingModule.withRoutes([]),
-        NgxsModule.forRoot([ProjectState])
-      ],
-      providers: [
-        {provide: NotificationService, useValue: new NotificationServiceMock()}
-      ]
-    })
-      .compileComponents();
-  });
-
-  beforeEach(() => {
-    fixture = TestBed.createComponent(PentestContentComponent);
-    store = TestBed.inject(Store);
-    store.reset({
-      ...store.snapshot(),
-      [PROJECT_STATE_NAME]: DESIRED_PROJECT_STATE_SESSION
-    });
-    component = fixture.componentInstance;
-    fixture.detectChanges();
-  });
-
-  it('should create', () => {
-    expect(component).toBeTruthy();
-  });
-});

security-c4po-angular/src/app/pentest/pentest-content/pentest-content.component.ts

@@ -1,54 +0,0 @@
-import {Component, OnInit} from '@angular/core';
-import * as FA from '@fortawesome/free-solid-svg-icons';
-import {BehaviorSubject} from 'rxjs';
-import {Store} from '@ngxs/store';
-import {ProjectState} from '@shared/stores/project-state/project-state';
-import {UntilDestroy, untilDestroyed} from '@ngneat/until-destroy';
-import {Pentest} from '@shared/models/pentest.model';
-import {PentestService} from '@shared/services/api/pentest.service';
-import {NotificationService} from '@shared/services/toaster-service/notification.service';
-import {Router} from '@angular/router';
-import {Route} from '@shared/models/route.enum';
-
-@UntilDestroy()
-@Component({
-  selector: 'app-pentest-content',
-  templateUrl: './pentest-content.component.html',
-  styleUrls: ['./pentest-content.component.scss']
-})
-export class PentestContentComponent implements OnInit {
-  // HTML only
-  readonly fa = FA;
-
-  pentest$: BehaviorSubject<Pentest> = new BehaviorSubject<Pentest>(null);
-  currentNumberOfFindings$: BehaviorSubject<number> = new BehaviorSubject<number>(0);
-  currentNumberOfComments$: BehaviorSubject<number> = new BehaviorSubject<number>(0);
-
-  constructor(
-    private readonly pentestService: PentestService,
-    private notificationService: NotificationService,
-    private router: Router,
-    private store: Store) {
-  }
-
-  ngOnInit(): void {
-    this.store.select(ProjectState.pentest).pipe(
-      untilDestroyed(this)
-    ).subscribe({
-      next: (selectedPentest: Pentest) => {
-        if (selectedPentest) {
-          this.pentest$.next(selectedPentest);
-          const findings = selectedPentest.findingIds ? selectedPentest.findingIds.length : 0;
-          this.currentNumberOfFindings$.next(findings);
-          const comments = selectedPentest.commentIds ? selectedPentest.commentIds.length : 0;
-          this.currentNumberOfComments$.next(comments);
-        } else {
-          this.router.navigate([Route.PROJECT_OVERVIEW]);
-        }
-      },
-      error: err => {
-        console.error(err);
-      }
-    });
-  }
-}

security-c4po-angular/src/app/pentest/pentest-content/pentest-findings/pentest-findings.component.html

@@ -1,101 +0,0 @@
-<div class="finding-table">
-  <table [nbTreeGrid]="dataSource">
-    <tr nbTreeGridHeaderRow *nbTreeGridHeaderRowDef="columns"></tr>
-    <tr nbTreeGridRow *nbTreeGridRowDef="let finding; columns: columns"
-        class="finding-cell"
-        fragment="{{finding.data['findingId']}}">
-    </tr>
-    <!-- Title -->
-    <ng-container [nbTreeGridColumnDef]="columns[0]">
-      <th nbTreeGridHeaderCell *nbTreeGridHeaderCellDef>
-        {{ 'finding.title' | translate }}
-      </th>
-      <td nbTreeGridCell *nbTreeGridCellDef="let finding">
-        <span *ngIf=" finding.data['title'].length < 200; else cutTitle">
-          {{ finding.data['title'] }}
-        </span>
-        <ng-template #cutTitle>
-          {{ finding.data['title'].slice(0, 200) + '...' }}
-        </ng-template>
-      </td>
-    </ng-container>
-    <!-- Severity -->
-    <ng-container [nbTreeGridColumnDef]="columns[1]">
-      <th nbTreeGridHeaderCell *nbTreeGridHeaderCellDef class="cell-severity">
-        {{ 'finding.severity' | translate }}
-      </th>
-      <td nbTreeGridCell *nbTreeGridCellDef="let finding" class="cell-severity border-style">
-        <div fxLayoutAlign="center center">
-          <app-severity-tag [currentSeverity]="finding.data['severity']"></app-severity-tag>
-        </div>
-      </td>
-    </ng-container>
-    <!-- Description -->
-    <ng-container [nbTreeGridColumnDef]="columns[2]">
-      <th nbTreeGridHeaderCell *nbTreeGridHeaderCellDef>
-        {{ 'finding.description' | translate }}
-      </th>
-      <td nbTreeGridCell *nbTreeGridCellDef="let finding">
-        <span *ngIf=" finding.data['description'].length < 200; else cutDescription">
-          {{ finding.data['description'] }}
-        </span>
-        <ng-template #cutDescription>
-          {{ finding.data['description'].slice(0, 200) + '...' }}
-        </ng-template>
-      </td>
-    </ng-container>
-    <!-- Impact -->
-    <ng-container [nbTreeGridColumnDef]="columns[3]">
-      <th nbTreeGridHeaderCell *nbTreeGridHeaderCellDef>
-        {{ 'finding.impact' | translate }}
-      </th>
-      <td nbTreeGridCell *nbTreeGridCellDef="let finding">
-        <span *ngIf=" finding.data['impact'].length < 200; else cutImpact">
-          {{ finding.data['impact'] }}
-        </span>
-        <ng-template #cutImpact>
-          {{ finding.data['impact'].slice(0, 200) + '...' }}
-        </ng-template>
-      </td>
-    </ng-container>
-    <!-- Actions -->
-    <ng-container [nbTreeGridColumnDef]="columns[4]">
-      <th nbTreeGridHeaderCell *nbTreeGridHeaderCellDef class="cell-actions">
-        <button nbButton hero
-                status="info"
-                size="small"
-                shape="round"
-                class="add-finding-button"
-                [disabled]="pentestInfo$.getValue().status !== inProgressStatus"
-                (click)="onClickAddFinding()">
-          <fa-icon [icon]="fa.faPlus" class="new-finding-icon"></fa-icon>
-          {{'finding.add' | translate}}
-        </button>
-      </th>
-      <td nbTreeGridCell *nbTreeGridCellDef="let finding" class="cell-actions">
-        <div fxLayout="row" fxLayoutAlign="center center" fxLayoutGap="1rem">
-          <button nbButton
-                  status="primary"
-                  size="small"
-                  (click)="onClickEditFinding(finding)">
-            <fa-icon [icon]="fa.faPencilAlt"></fa-icon>
-          </button>
-          <button nbButton
-                  status="danger"
-                  size="small"
-                  (click)="onClickDeleteFinding(finding)">
-            <fa-icon [icon]="fa.faTrash"></fa-icon>
-          </button>
-        </div>
-      </td>
-    </ng-container>
-  </table>
-</div>
-
-<div *ngIf="data.length === 0 && loading$.getValue() === false" fxLayout="row" fxLayoutAlign="center center">
-  <p class="error-text">
-    {{'finding.no.findings' | translate}}
-  </p>
-</div>
-
-<app-loading-spinner [isLoading$]="isLoading()" *ngIf="isLoading() | async"></app-loading-spinner>

security-c4po-angular/src/app/pentest/pentest-content/pentest-findings/pentest-findings.component.scss

@@ -1,54 +0,0 @@
-@import '../../../../assets/@theme/styles/themes';
-@import '../../../../assets/@theme/styles/_text-overflow.scss';
-
-.finding-table {
-  margin-right: 2rem;
-  padding-right: 2rem;
-
-  .finding-cell {
-    // Add style here
-    height: 4.5rem !important;
-    // max-height: 4.5rem !important;
-    overflow: hidden;
-  }
-
-  .finding-cell:hover {
-    // cursor: default;
-    background-color: nb-theme(color-basic-transparent-focus);
-  }
-
-  .cell-severity {
-    //width: 125px;
-    // max-width: 125px;
-    // border-style: none;
-    // ToDo: Fix size issue on lower screen resolution
-    // height: 4.5rem !important;
-  }
-
-  .cell {
-    height: 4.5rem !important;
-    max-height: 4.5rem !important;
-  }
-
-  .border-style {
-    border-top-style: none;
-    border-left-style: none;
-  }
-
-  .cell-actions {
-    width: max-content;
-    max-width: 180px;
-
-    .add-finding-button {
-      .new-finding-icon {
-        padding-right: 0.5rem;
-      }
-    }
-  }
-}
-
-.error-text {
-  padding-top: 0.5rem;
-  font-size: 1.25rem;
-  font-weight: bold;
-}

security-c4po-angular/src/app/pentest/pentest-content/pentest-findings/pentest-findings.component.spec.ts

@@ -1,110 +0,0 @@
-import {ComponentFixture, TestBed} from '@angular/core/testing';
-
-import {PentestFindingsComponent} from './pentest-findings.component';
-import {BrowserAnimationsModule} from '@angular/platform-browser/animations';
-import {HttpClientTestingModule} from '@angular/common/http/testing';
-import {TranslateLoader, TranslateModule} from '@ngx-translate/core';
-import {HttpLoaderFactory} from '../../../common-app.module';
-import {HttpClient} from '@angular/common/http';
-import {NgxsModule, Store} from '@ngxs/store';
-import {PROJECT_STATE_NAME, ProjectState, ProjectStateModel} from '@shared/stores/project-state/project-state';
-import {NbButtonModule, NbTreeGridModule} from '@nebular/theme';
-import {NotificationService} from '@shared/services/toaster-service/notification.service';
-import {NotificationServiceMock} from '@shared/services/toaster-service/notification.service.mock';
-import {CommonModule} from '@angular/common';
-import {MockComponent} from 'ng-mocks';
-import {LoadingSpinnerComponent} from '@shared/widgets/loading-spinner/loading-spinner.component';
-import {FontAwesomeModule} from '@fortawesome/angular-fontawesome';
-import {ThemeModule} from '@assets/@theme/theme.module';
-import {Category} from '@shared/models/category.model';
-import {PentestStatus} from '@shared/models/pentest-status.model';
-import {FindingDialogService} from '@shared/modules/finding-dialog/service/finding-dialog.service';
-import {FindingDialogServiceMock} from '@shared/modules/finding-dialog/service/finding-dialog.service.mock';
-import {DialogService} from '@shared/services/dialog-service/dialog.service';
-import {DialogServiceMock} from '@shared/services/dialog-service/dialog.service.mock';
-import {ReportState} from '@shared/models/state.enum';
-
-const DESIRED_PROJECT_STATE_SESSION: ProjectStateModel =  {
-  allProjects: [],
-  selectedProject: {
-    id: '56c47c56-3bcd-45f1-a05b-c197dbd33111',
-    client: 'E Corp',
-    title: 'Some Mock API (v1.0) Scanning',
-    createdAt: new Date('2019-01-10T09:00:00'),
-    tester: 'Novatester',
-    summary: '',
-    state: ReportState.NEW,
-    version: '1.0',
-    testingProgress: 0,
-    createdBy: '11c47c56-3bcd-45f1-a05b-c197dbd33110'
-  },
-  // Manages Categories
-  disabledCategories: [],
-  selectedCategory: Category.INFORMATION_GATHERING,
-  // Manages Pentests of Category
-  disabledPentests: [],
-  selectedPentest: {
-    id: '56c47c56-3bcd-45f1-a05b-c197dbd33112',
-    category: Category.INFORMATION_GATHERING,
-    refNumber: 'OTF-001',
-    childEntries: [],
-    status: PentestStatus.NOT_STARTED,
-    enabled: true,
-    findingIds: ['56c47c56-3bcd-45f1-a05b-c197dbd33112'],
-    commentIds: []
-  },
-};
-
-describe('PentestFindingsComponent', () => {
-  let component: PentestFindingsComponent;
-  let fixture: ComponentFixture<PentestFindingsComponent>;
-  let store: Store;
-
-  beforeEach(async () => {
-    await TestBed.configureTestingModule({
-      declarations: [
-        PentestFindingsComponent,
-        MockComponent(LoadingSpinnerComponent)
-      ],
-      imports: [
-        CommonModule,
-        BrowserAnimationsModule,
-        HttpClientTestingModule,
-        FontAwesomeModule,
-        NbButtonModule,
-        NbTreeGridModule,
-        ThemeModule.forRoot(),
-        TranslateModule.forRoot({
-          loader: {
-            provide: TranslateLoader,
-            useFactory: HttpLoaderFactory,
-            deps: [HttpClient]
-          }
-        }),
-        NgxsModule.forRoot([ProjectState])
-      ],
-      providers: [
-        {provide: NotificationService, useValue: new NotificationServiceMock()},
-        {provide: DialogService, useClass: DialogServiceMock},
-        {provide: FindingDialogService, useClass: FindingDialogServiceMock},
-      ]
-    })
-      .compileComponents();
-  });
-
-  beforeEach(() => {
-    fixture = TestBed.createComponent(PentestFindingsComponent);
-    store = TestBed.inject(Store);
-    store.reset({
-      ...store.snapshot(),
-      [PROJECT_STATE_NAME]: DESIRED_PROJECT_STATE_SESSION
-    });
-    component = fixture.componentInstance;
-    component.pentestInfo$.next(DESIRED_PROJECT_STATE_SESSION.selectedPentest);
-    fixture.detectChanges();
-  });
-
-  it('should create', () => {
-    expect(component).toBeTruthy();
-  });
-});

security-c4po-angular/src/app/pentest/pentest-content/pentest-findings/pentest-findings.component.ts

@@ -1,217 +0,0 @@
-import {Component, OnInit} from '@angular/core';
-import {BehaviorSubject, Observable} from 'rxjs';
-import {Pentest} from '@shared/models/pentest.model';
-import {UntilDestroy, untilDestroyed} from '@ngneat/until-destroy';
-import { filter, tap} from 'rxjs/operators';
-import {NotificationService, PopupType} from '@shared/services/toaster-service/notification.service';
-import {
-  Finding,
-  FindingEntry,
-  transformFindingsToObjectiveEntries,
-} from '@shared/models/finding.model';
-import {NbGetters, NbTreeGridDataSource, NbTreeGridDataSourceBuilder} from '@nebular/theme';
-import * as FA from '@fortawesome/free-solid-svg-icons';
-import {isNotNullOrUndefined} from 'codelyzer/util/isNotNullOrUndefined';
-import {FindingDialogService} from '@shared/modules/finding-dialog/service/finding-dialog.service';
-import {FindingDialogComponent} from '@shared/modules/finding-dialog/finding-dialog.component';
-import {PentestStatus} from '@shared/models/pentest-status.model';
-import {Store} from '@ngxs/store';
-import {UpdatePentestFindings} from '@shared/stores/project-state/project-state.actions';
-import {ProjectState} from '@shared/stores/project-state/project-state';
-import {DialogService} from '@shared/services/dialog-service/dialog.service';
-import {FindingService} from '@shared/services/api/finding.service';
-
-@UntilDestroy()
-@Component({
-  selector: 'app-pentest-findings',
-  templateUrl: './pentest-findings.component.html',
-  styleUrls: ['./pentest-findings.component.scss']
-})
-export class PentestFindingsComponent implements OnInit {
-
-  constructor(private findingService: FindingService,
-              private dataSourceBuilder: NbTreeGridDataSourceBuilder<FindingEntry>,
-              private readonly notificationService: NotificationService,
-              private dialogService: DialogService,
-              private findingDialogService: FindingDialogService,
-              private store: Store) {
-    this.dataSource = dataSourceBuilder.create(this.data, this.getters);
-  }
-
-  pentestInfo$: BehaviorSubject<Pentest> = new BehaviorSubject<Pentest>(null);
-  loading$: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(true);
-
-  // HTML only
-  readonly fa = FA;
-  // HTML only for button enabling
-  inProgressStatus: PentestStatus = PentestStatus.IN_PROGRESS;
-
-  columns: Array<FindingColumns> = [
-    FindingColumns.TITLE, FindingColumns.SEVERITY, FindingColumns.DESCRIPTION, FindingColumns.IMPACT, FindingColumns.ACTIONS
-  ];
-  dataSource: NbTreeGridDataSource<FindingEntry>;
-
-  data: FindingEntry[] = [];
-
-  getters: NbGetters<FindingEntry, FindingEntry> = {
-    dataGetter: (node: FindingEntry) => node,
-    childrenGetter: (node: FindingEntry) => node.childEntries || undefined,
-    expandedGetter: (node: FindingEntry) => !!node.expanded,
-  };
-
-  ngOnInit(): void {
-    this.store.select(ProjectState.pentest).pipe(
-      untilDestroyed(this)
-    ).subscribe({
-      next: (selectedPentest: Pentest) => {
-        this.pentestInfo$.next(selectedPentest);
-        this.loadFindingsData();
-      },
-      error: err => {
-        console.error(err);
-      }
-    });
-  }
-
-  loadFindingsData(): void {
-    this.findingService.getFindingsByPentestId(this.pentestInfo$.getValue() ? this.pentestInfo$.getValue().id : '')
-      .pipe(
-        untilDestroyed(this),
-        /*filter(isNotNullOrUndefined),*/
-        tap(() => this.loading$.next(true))
-      )
-      .subscribe({
-        next: (findings: Finding[]) => {
-          // ToDo: Handle this case before in pipe
-          if (findings) {
-            this.data = transformFindingsToObjectiveEntries(findings);
-          } else {
-            this.data = [];
-          }
-          this.dataSource.setData(this.data, this.getters);
-          this.loading$.next(false);
-        },
-        error: err => {
-          console.error(err);
-          // ToDo: Implement again after proper lazy loading and routing
-          // this.notificationService.showPopup('findings.popup.not.found', PopupType.FAILURE);
-          this.loading$.next(false);
-        }
-      });
-  }
-
-  onClickAddFinding(): void {
-    this.findingDialogService.openFindingDialog(
-      FindingDialogComponent,
-      null,
-      {
-        closeOnEsc: false,
-        hasScroll: false,
-        autoFocus: true,
-        closeOnBackdropClick: false
-      },
-      this.pentestInfo$.getValue()
-    ).pipe(
-      untilDestroyed(this)
-    ).subscribe({
-      next: (newFinding: Finding) => {
-        this.loadFindingsData();
-      }
-    });
-  }
-
-  onClickEditFinding(findingEntry): void {
-    this.findingService.getFindingById(findingEntry.data.findingId).pipe(
-      filter(isNotNullOrUndefined),
-      untilDestroyed(this)
-    ).subscribe({
-      next: (existingFinding: Finding) => {
-        if (existingFinding) {
-          this.findingDialogService.openFindingDialog(
-            FindingDialogComponent,
-            existingFinding,
-            {
-              closeOnEsc: false,
-              hasScroll: false,
-              autoFocus: true,
-              closeOnBackdropClick: false
-            },
-            this.pentestInfo$.getValue()
-          ).pipe(
-            untilDestroyed(this)
-          ).subscribe({
-            next: (updatedFinding: Finding) => {
-              this.loadFindingsData();
-            }
-          });
-        } else {
-          this.notificationService.showPopup('finding.popup.not.available', PopupType.INFO);
-        }
-      },
-      error: err => {
-        console.error(err);
-      }
-    });
-  }
-
-  onClickDeleteFinding(findingEntry): void {
-    const message = {
-      title: 'finding.delete.title',
-      key: 'finding.delete.key',
-      data: {name: findingEntry.data.title},
-    };
-    this.dialogService.openConfirmDialog(
-      message
-    ).onClose.pipe(
-      untilDestroyed(this)
-    ).subscribe({
-      next: () => {
-        this.deleteFinding(findingEntry);
-      }
-    });
-  }
-
-  isLoading(): Observable<boolean> {
-    return this.loading$.asObservable();
-  }
-
-  private deleteFinding(findingEntry): void {
-    this.findingService.deleteFindingByPentestAndFindingId(
-      this.pentestInfo$.getValue() ? this.pentestInfo$.getValue().id : '',
-      findingEntry.data.findingId)
-      .pipe(
-        untilDestroyed(this)
-      ).subscribe({
-      next: (deletedFinding: any) => {
-        this.store.dispatch(new UpdatePentestFindings(deletedFinding.id));
-        this.loadFindingsData();
-        this.notificationService.showPopup('finding.popup.delete.success', PopupType.SUCCESS);
-      }, error: error => {
-        console.error(error);
-        this.onRequestFailed(findingEntry);
-        this.notificationService.showPopup('finding.popup.delete.failed', PopupType.FAILURE);
-      }
-    });
-  }
-
-  private onRequestFailed(retryParameter: any): void {
-    this.dialogService.openRetryDialog({key: 'global.retry.dialog', data: null}).onClose
-      .pipe(
-        untilDestroyed(this)
-      )
-      .subscribe((ref) => {
-        if (ref.retry) {
-          this.deleteFinding(retryParameter);
-        }
-      });
-  }
-}
-
-enum FindingColumns {
-  FINDING_ID = 'findingId',
-  TITLE = 'title',
-  SEVERITY = 'severity',
-  DESCRIPTION = 'description',
-  IMPACT = 'impact',
-  ACTIONS = 'actions'
-}

security-c4po-angular/src/app/pentest/pentest-content/pentest-info/pentest-info.component.html

@@ -1,11 +0,0 @@
-<div class="pentest-info">
-  <h4>
-    {{ getPentestHeaderForObjective(pentestInfo$.getValue().refNumber) | translate}}
-  </h4>
-  <div class="description">
-    <div>
-          {{ getPentestInfoForObjective(pentestInfo$.getValue().refNumber) | translate }}
-    </div>
-  </div>
-  <!--ToDo: Add tooling hints after description (maybe in pentest-header component)-->
-</div>

security-c4po-angular/src/app/pentest/pentest-content/pentest-info/pentest-info.component.scss

@@ -1,16 +0,0 @@
-.pentest-info {
-  overflow: hidden !important;
-  position: relative !important;
-
-  .description {
-    // ToDo: Make only description scrollable
-    // Scrollbar
-    overflow-y: scroll !important;
-    overflow-x: hidden;
-    scroll-behavior: smooth;
-
-    width: 60vw;
-    font-size: 1rem;
-    white-space: pre-line;
-  }
-}

security-c4po-angular/src/app/pentest/pentest-content/pentest-info/pentest-info.component.spec.ts

@@ -1,102 +0,0 @@
-import {ComponentFixture, TestBed} from '@angular/core/testing';
-
-import {PentestInfoComponent} from './pentest-info.component';
-import {CommonModule} from '@angular/common';
-import {BrowserAnimationsModule} from '@angular/platform-browser/animations';
-import {HttpClientTestingModule} from '@angular/common/http/testing';
-import {FontAwesomeModule} from '@fortawesome/angular-fontawesome';
-import {ThemeModule} from '@assets/@theme/theme.module';
-import {TranslateLoader, TranslateModule} from '@ngx-translate/core';
-import {HttpLoaderFactory} from '../../../common-app.module';
-import {HttpClient} from '@angular/common/http';
-import {NgxsModule, Store} from '@ngxs/store';
-import {PROJECT_STATE_NAME, ProjectState, ProjectStateModel} from '@shared/stores/project-state/project-state';
-import {Category} from '@shared/models/category.model';
-import {PentestStatus} from '@shared/models/pentest-status.model';
-import {ReportState} from '@shared/models/state.enum';
-
-const DESIRED_PROJECT_STATE_SESSION: ProjectStateModel =  {
-  allProjects: [],
-  selectedProject: {
-    id: '56c47c56-3bcd-45f1-a05b-c197dbd33111',
-    client: 'E Corp',
-    title: 'Some Mock API (v1.0) Scanning',
-    createdAt: new Date('2019-01-10T09:00:00'),
-    tester: 'Novatester',
-    summary: '',
-    state: ReportState.NEW,
-    version: '1.0',
-    testingProgress: 0,
-    createdBy: '11c47c56-3bcd-45f1-a05b-c197dbd33110'
-  },
-  // Manages Categories
-  disabledCategories: [],
-  selectedCategory: Category.INFORMATION_GATHERING,
-  // Manages Pentests of Category
-  disabledPentests: [],
-  selectedPentest: {
-    id: '56c47c56-3bcd-45f1-a05b-c197dbd33112',
-    category: Category.INFORMATION_GATHERING,
-    refNumber: 'OTF-001',
-    childEntries: [],
-    status: PentestStatus.NOT_STARTED,
-    enabled: true,
-    findingIds: ['56c47c56-3bcd-45f1-a05b-c197dbd33112'],
-    commentIds: []
-  },
-};
-
-describe('PentestInfoComponent', () => {
-  let component: PentestInfoComponent;
-  let fixture: ComponentFixture<PentestInfoComponent>;
-  let store: Store;
-
-  beforeEach(async () => {
-    await TestBed.configureTestingModule({
-      declarations: [
-        PentestInfoComponent
-      ],
-      imports: [
-        CommonModule,
-        BrowserAnimationsModule,
-        HttpClientTestingModule,
-        FontAwesomeModule,
-        ThemeModule.forRoot(),
-        TranslateModule.forRoot({
-          loader: {
-            provide: TranslateLoader,
-            useFactory: HttpLoaderFactory,
-            deps: [HttpClient]
-          }
-        }),
-        NgxsModule.forRoot([ProjectState])
-      ],
-    })
-      .compileComponents();
-  });
-
-  beforeEach(() => {
-    fixture = TestBed.createComponent(PentestInfoComponent);
-    store = TestBed.inject(Store);
-    store.reset({
-      ...store.snapshot(),
-      [PROJECT_STATE_NAME]: DESIRED_PROJECT_STATE_SESSION
-    });
-    component = fixture.componentInstance;
-    component.pentestInfo$.next({
-      id: '56c47c56-3bcd-45f1-a05b-c197dbd33112',
-      category: Category.INFORMATION_GATHERING,
-      refNumber: 'OTF-001',
-      childEntries: [],
-      status: PentestStatus.NOT_STARTED,
-      enabled: true,
-      findingIds: [],
-      commentIds: []
-    });
-    fixture.detectChanges();
-  });
-
-  it('should create', () => {
-    expect(component).toBeTruthy();
-  });
-});

security-c4po-angular/src/app/pentest/pentest-content/pentest-info/pentest-info.component.ts

@@ -1,43 +0,0 @@
-import {Component, Input, OnInit} from '@angular/core';
-import {BehaviorSubject} from 'rxjs';
-import {Pentest} from '@shared/models/pentest.model';
-import {getPentestInfoForObjective} from '@shared/functions/infos/get-pentest-info-for-objective';
-import {getTitleKeyForRefNumber} from '@shared/functions/categories/get-title-key-for-ref-number.function';
-import {ProjectState} from '@shared/stores/project-state/project-state';
-import {UntilDestroy, untilDestroyed} from '@ngneat/until-destroy';
-import {Store} from '@ngxs/store';
-
-@UntilDestroy()
-@Component({
-  selector: 'app-pentest-info',
-  templateUrl: './pentest-info.component.html',
-  styleUrls: ['./pentest-info.component.scss']
-})
-export class PentestInfoComponent implements OnInit {
-
-  pentestInfo$: BehaviorSubject<Pentest> = new BehaviorSubject<Pentest>(null);
-
-  constructor(private store: Store) { }
-
-  ngOnInit(): void {
-    this.store.selectOnce(ProjectState.pentest).pipe(
-      untilDestroyed(this)
-    ).subscribe({
-      next: (selectedPentest: Pentest) => {
-        this.pentestInfo$.next(selectedPentest);
-      },
-      error: err => {
-        console.error(err);
-      }
-    });
-  }
-
-  getPentestHeaderForObjective(refNumber: string): string {
-    return getTitleKeyForRefNumber(refNumber);
-  }
-
-  getPentestInfoForObjective(refNumber: string): string {
-    return getPentestInfoForObjective(refNumber);
-  }
-
-}

security-c4po-angular/src/app/pentest/pentest-header/pentest-header.component.html

@@ -1,41 +0,0 @@
-<div class="pentest-header" fxLayout="row" fxLayoutGap="2rem" fxLayoutAlign="space-between center">
-  <div class="exit-button-container">
-    <button nbButton
-            shape="round"
-            title="{{ 'global.action.exit' | translate }}"
-            (click)="onClickRouteBack()">
-      <fa-icon [icon]="fa.faLongArrowAltLeft"
-               class="exit-element-icon fa-lg">
-      </fa-icon>
-      <span class="exit-element-text"> {{ 'global.action.exit' | translate }} </span>
-    </button>
-  </div>
-
-  <div class="header-info" fxLayout="row" fxHide.lt-lg>
-    <span class="project-title">{{selectedProjectTitle$.getValue()}}</span>
-    <span class="pentest-ref">{{" / " + pentest$.getValue().refNumber}}</span>
-  </div>
-  <div class="header-info-mobile" fxHide fxShow.lt-lg>
-    <span class="pentest-ref">{{pentest$.getValue().refNumber}}</span>
-  </div>
-
-  <div class="pentest-status-container" fxLayout="row" fxLayoutGap="2.5rem" fxLayoutAlign="end center">
-    <!-- Pentest Timer-->
-    <div class="timer-component">
-      <app-timer></app-timer>
-    </div>
-    <!-- Complete Pentest -->
-    <div>
-      <button nbButton
-              class="complete-pentest-button"
-              status="success"
-              [disabled]="!pentestStatusChanged() || !pentestHasFindingsOrComments()"
-              title="{{ 'global.action.save' | translate }}"
-              (click)="onClickCompletePentest()">
-        <fa-icon [icon]="fa.faSquare"></fa-icon>
-        <span class="action-element-text"> {{ 'global.action.complete' | translate }} </span>
-      </button>
-    </div>
-  </div>
-</div>
-

security-c4po-angular/src/app/pentest/pentest-header/pentest-header.component.scss

@@ -1,94 +0,0 @@
-@import '../../../assets/@theme/styles/_text-overflow.scss';
-
-.pentest-header {
-  width: 100vw;
-
-  .header-info {
-    position: absolute;
-    margin-left: 10rem;
-    margin-right: 10rem;
-    text-align: center;
-
-    .project-title {
-      @include multiLineEllipsis($font-size: 1.5rem, $font-weight: bold, $line-height: 2rem, $lines-to-show: 1, $max-width: 32rem);
-    }
-
-    .pentest-ref {
-      font-size:  1.5rem;
-      font-weight: bold;
-      line-height: 2rem;
-    }
-  }
-
-  .header-info-mobile{
-    position: absolute;
-    margin-left: 10rem;
-    margin-right: 10rem;
-    text-align: center;
-
-    .pentest-ref {
-      font-size:  1.5rem;
-      font-weight: bold;
-      line-height: 2rem;
-    }
-  }
-
-  .exit-button-container {
-    .exit-element-icon {
-    }
-
-    .exit-element-text {
-      padding-left: 0.5rem;
-    }
-  }
-
-  .pentest-status-container {
-    position: fixed;
-    right: 4rem;
-    // display: flex;
-    // align-content: flex-end;
-
-    .timer-component {
-      height: 2rem !important;
-      max-height: 2rem !important;
-      margin: 0.5rem 2.25rem 1rem 0;
-    }
-
-    .complete-pentest-button {
-      // position: absolute;
-
-      .action-element-text {
-        padding-left: 0.5rem;
-      }
-    }
-
-    .pentest-status-dialog {
-      margin: 1rem 2.25rem 1rem 0;
-
-      .status {
-        width: 12rem;
-      }
-
-      .basic {
-        background-color: nb-theme(color-basic-default);
-      }
-
-      .info {
-        background-color: nb-theme(color-info-default);
-      }
-
-      .warning {
-        background-color: nb-theme(color-warning-default);
-      }
-
-      .success {
-        background-color: nb-theme(color-success-default);
-      }
-    }
-
-    .save-pentest-button {
-      // height: 1rem !important;
-      margin: 1rem 0 1rem 0;
-    }
-  }
-}

security-c4po-angular/src/app/pentest/pentest-header/pentest-header.component.spec.ts

@@ -1,91 +0,0 @@
-import {ComponentFixture, TestBed} from '@angular/core/testing';
-
-import {PentestHeaderComponent} from './pentest-header.component';
-import {BrowserAnimationsModule} from '@angular/platform-browser/animations';
-import {HttpClientTestingModule} from '@angular/common/http/testing';
-import {TranslateLoader, TranslateModule} from '@ngx-translate/core';
-import {HttpLoaderFactory} from '../../common-app.module';
-import {HttpClient} from '@angular/common/http';
-import {RouterTestingModule} from '@angular/router/testing';
-import {NgxsModule, Store} from '@ngxs/store';
-import {PROJECT_STATE_NAME, ProjectState, ProjectStateModel} from '@shared/stores/project-state/project-state';
-import {Category} from '@shared/models/category.model';
-import {PentestStatus} from '@shared/models/pentest-status.model';
-import {NotificationService} from '@shared/services/toaster-service/notification.service';
-import {NotificationServiceMock} from '@shared/services/toaster-service/notification.service.mock';
-import {ReportState} from '@shared/models/state.enum';
-
-const DESIRED_PROJECT_STATE_SESSION: ProjectStateModel = {
-  allProjects: [],
-  selectedProject: {
-    id: '56c47c56-3bcd-45f1-a05b-c197dbd33111',
-    client: 'E Corp',
-    title: 'Some Mock API (v1.0) Scanning',
-    createdAt: new Date('2019-01-10T09:00:00'),
-    tester: 'Novatester',
-    summary: '',
-    state: ReportState.NEW,
-    version: '1.0',
-    testingProgress: 0,
-    createdBy: '11c47c56-3bcd-45f1-a05b-c197dbd33110'
-  },
-  // Manages Categories
-  disabledCategories: [],
-  selectedCategory: Category.INFORMATION_GATHERING,
-  // Manages Pentests of Category
-  disabledPentests: [],
-  selectedPentest: {
-    id: '56c47c56-3bcd-45f1-a05b-c197dbd33112',
-    category: Category.INFORMATION_GATHERING,
-    refNumber: 'OTF-001',
-    childEntries: [],
-    status: PentestStatus.NOT_STARTED,
-    enabled: true,
-    findingIds: [],
-    commentIds: []
-  },
-};
-
-describe('PentestHeaderComponent', () => {
-  let component: PentestHeaderComponent;
-  let fixture: ComponentFixture<PentestHeaderComponent>;
-  let store: Store;
-
-  beforeEach(async () => {
-    await TestBed.configureTestingModule({
-      declarations: [PentestHeaderComponent],
-      imports: [
-        BrowserAnimationsModule,
-        HttpClientTestingModule,
-        TranslateModule.forRoot({
-          loader: {
-            provide: TranslateLoader,
-            useFactory: HttpLoaderFactory,
-            deps: [HttpClient]
-          }
-        }),
-        RouterTestingModule.withRoutes([]),
-        NgxsModule.forRoot([ProjectState])
-      ],
-      providers: [
-        {provide: NotificationService, useValue: new NotificationServiceMock()},
-      ]
-    })
-      .compileComponents();
-  });
-
-  beforeEach(() => {
-    fixture = TestBed.createComponent(PentestHeaderComponent);
-    store = TestBed.inject(Store);
-    store.reset({
-      ...store.snapshot(),
-      [PROJECT_STATE_NAME]: DESIRED_PROJECT_STATE_SESSION
-    });
-    component = fixture.componentInstance;
-    fixture.detectChanges();
-  });
-
-  it('should create', () => {
-    expect(component).toBeTruthy();
-  });
-});

security-c4po-angular/src/app/pentest/pentest-header/pentest-header.component.ts

@@ -1,177 +0,0 @@
-import {Component, OnDestroy, OnInit} from '@angular/core';
-import * as FA from '@fortawesome/free-solid-svg-icons';
-import {UntilDestroy, untilDestroyed} from '@ngneat/until-destroy';
-import {Route} from '@shared/models/route.enum';
-import {Store} from '@ngxs/store';
-import {Router} from '@angular/router';
-import {ChangePentest} from '@shared/stores/project-state/project-state.actions';
-import {BehaviorSubject} from 'rxjs';
-import {ProjectState} from '@shared/stores/project-state/project-state';
-import {Project} from '@shared/models/project.model';
-import {Pentest, transformPentestToRequestBody} from '@shared/models/pentest.model';
-import {NotificationService, PopupType} from '@shared/services/toaster-service/notification.service';
-import {PentestStatus} from '@shared/models/pentest-status.model';
-import {PentestService} from '@shared/services/api/pentest.service';
-import {StatusText} from '@shared/widgets/status-tag/status-tag.component';
-
-@UntilDestroy()
-@Component({
-  selector: 'app-pentest-header',
-  templateUrl: './pentest-header.component.html',
-  styleUrls: ['./pentest-header.component.scss']
-})
-export class PentestHeaderComponent implements OnInit, OnDestroy {
-  // HTML only
-  readonly fa = FA;
-
-  pentest$: BehaviorSubject<Pentest> = new BehaviorSubject<Pentest>(null);
-  selectedProjectTitle$: BehaviorSubject<string> = new BehaviorSubject<string>('');
-  pentestChanged$: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(false);
-
-  // Pentest Timer Handler
-  currentTimeSpent = 0;
-  private initialTimeSpent: number;
-
-  // Pentest Status Handler
-  status = PentestStatus;
-  currentStatus: PentestStatus = PentestStatus.NOT_STARTED;
-  private initialPentestStatus: PentestStatus;
-
-  // Status Text Translation Texts
-  readonly statusTexts: Array<StatusText> = [
-    {value: PentestStatus.NOT_STARTED, translationText: 'pentest.statusText.not_started'},
-    /* ToDo: Disabled not needed inside pentest */
-    /*{value: PentestStatus.DISABLED, translationText: 'pentest.statusText.disabled'},*/
-    {value: PentestStatus.PAUSED, translationText: 'pentest.statusText.paused'},
-    {value: PentestStatus.IN_PROGRESS, translationText: 'pentest.statusText.in_progress'},
-    {value: PentestStatus.COMPLETED, translationText: 'pentest.statusText.completed'}
-  ];
-
-  selectedProjectId$: BehaviorSubject<string> = new BehaviorSubject<string>('');
-
-  constructor(private store: Store,
-              private pentestService: PentestService,
-              private notificationService: NotificationService,
-              private readonly router: Router) {
-  }
-
-  ngOnInit(): void {
-    this.store.selectOnce(ProjectState.project).pipe(
-      untilDestroyed(this)
-    ).subscribe({
-      next: (selectedProject: Project) => {
-        this.selectedProjectId$.next(selectedProject.id);
-        this.selectedProjectTitle$.next(selectedProject?.title);
-      },
-      error: err => {
-        console.error(err);
-      }
-    });
-
-    this.store.select(ProjectState.pentest).pipe(
-      untilDestroyed(this)
-    ).subscribe({
-      next: (selectedPentest: Pentest) => {
-        this.currentStatus = selectedPentest.status;
-        this.currentTimeSpent = selectedPentest.timeSpent ? selectedPentest.timeSpent : 0;
-        this.pentest$.next(selectedPentest);
-      },
-      error: err => {
-        console.error(err);
-      }
-    });
-    // Setup initial values for status and time outside of store subscription
-    this.initialPentestStatus = this.currentStatus;
-    this.initialTimeSpent = this.currentTimeSpent;
-  }
-
-  onClickRouteBack(): void {
-    // Route back to overview
-    this.router.navigate([Route.OBJECTIVE_OVERVIEW])
-      .then(
-        () => {
-          this.store.dispatch(new ChangePentest(null));
-        }
-      ).finally();
-  }
-
-  onClickCompletePentest(): void {
-    // Update existing Pentest
-    this.pentest$.next({...this.pentest$.getValue(), status: PentestStatus.COMPLETED, timeSpent: this.currentTimeSpent});
-    this.updatePentest();
-  }
-
-  private updatePentest(): void {
-    this.pentestService.updatePentest(transformPentestToRequestBody(this.pentest$.getValue()))
-      .subscribe({
-        next: (pentest: Pentest) => {
-          this.store.dispatch(new ChangePentest(pentest));
-          this.initialTimeSpent = pentest.timeSpent;
-          this.notificationService.showPopup('pentest.popup.update.success', PopupType.SUCCESS);
-        },
-        error: err => {
-          console.log(err);
-          this.notificationService.showPopup('pentest.popup.update.failed', PopupType.FAILURE);
-        }
-      });
-  }
-
-  /**
-   * @return true if initial pentest Status is different from current pentest status
-   */
-  pentestStatusChanged(): boolean {
-    if (this.initialTimeSpent !== this.currentTimeSpent && this.currentTimeSpent !== 0) {
-      this.pentestChanged$.next(true);
-    } else {
-      this.pentestChanged$.next(false);
-    }
-    return this.pentestChanged$.getValue();
-  }
-
-  /**
-   * @return true if pentest includes at least one finding or comment
-   */
-  pentestHasFindingsOrComments(): boolean {
-    const pentest: Pentest = this.pentest$.getValue();
-    // Check if pentest includes any findings or comments
-    return pentest?.findingIds?.length > 0 || pentest?.commentIds?.length > 0;
-  }
-
-  /**
-   * @return the correct nb-status for current pentest-status
-   */
-  getPentestFillStatus(value: PentestStatus): string {
-    let pentestFillStatus;
-    switch (value) {
-      case PentestStatus.NOT_STARTED: {
-        pentestFillStatus = 'basic';
-        break;
-      }
-      case PentestStatus.PAUSED: {
-        pentestFillStatus = 'info';
-        break;
-      }
-      case PentestStatus.IN_PROGRESS: {
-        pentestFillStatus = 'warning';
-        break;
-      }
-      case PentestStatus.COMPLETED: {
-        pentestFillStatus = 'success';
-        break;
-      }
-      default: {
-        pentestFillStatus = 'basic';
-        break;
-      }
-    }
-    return pentestFillStatus;
-  }
-
-  ngOnDestroy(): void {
-    if (this.pentestStatusChanged()) {
-      // Save current Pentest before exiting
-      this.pentest$.next({...this.pentest$.getValue(), status: PentestStatus.PAUSED, timeSpent: this.currentTimeSpent});
-      this.updatePentest();
-    }
-  }
-}

security-c4po-angular/src/app/pentest/pentest.component.html

@@ -1,15 +0,0 @@
-<div fxFlex class="pentest">
-  <nb-layout fxFlex>
-    <nb-layout-header fxFlex="0 1 max-content" class="stepper-column">
-      <app-pentest-header></app-pentest-header>
-    </nb-layout-header>
-
-    <nb-layout-column fxFlex="0 1 max-content" class="column-wrapper">
-      <nb-card class="content-column">
-        <nb-card-body>
-          <app-pentest-content></app-pentest-content>
-        </nb-card-body>
-      </nb-card>
-    </nb-layout-column>
-  </nb-layout>
-</div>

security-c4po-angular/src/app/pentest/pentest.component.scss

@@ -1,24 +0,0 @@
-@import '../../assets/@theme/styles/themes';
-@import '../../assets/@theme/styles/variables';
-
-.pentest {
-  width: 100vw;
-  height: calc(100vh - #{$header-height});
-  overflow: hidden;
-
-  .header-column {
-    width: 100vw;
-    height: $pentest-header-height;
-  }
-
-  .column-wrapper {
-    padding-left: 0 !important;
-
-    .content-column {
-      overflow: auto !important;
-      width: 100vw;
-      max-width: 100vw;
-      height: calc(100vh - #{$pentest-header-height} - #{$header-height});
-    }
-  }
-}

security-c4po-angular/src/app/pentest/pentest.module.ts

@@ -1,58 +0,0 @@
-import {NgModule} from '@angular/core';
-import {CommonModule} from '@angular/common';
-import {RouterModule} from '@angular/router';
-import {PentestComponent} from './pentest.component';
-import {NbButtonModule, NbCardModule, NbLayoutModule, NbSelectModule, NbTabsetModule, NbTreeGridModule} from '@nebular/theme';
-import {PentestHeaderComponent} from './pentest-header/pentest-header.component';
-import {PentestContentComponent} from './pentest-content/pentest-content.component';
-import {FlexLayoutModule} from '@angular/flex-layout';
-import {FontAwesomeModule} from '@fortawesome/angular-fontawesome';
-import {TranslateModule} from '@ngx-translate/core';
-import {StatusTagModule} from '@shared/widgets/status-tag/status-tag.module';
-import {PentestInfoComponent} from './pentest-content/pentest-info/pentest-info.component';
-import {PentestFindingsComponent} from './pentest-content/pentest-findings/pentest-findings.component';
-import {PentestCommentsComponent} from './pentest-content/pentest-comments/pentest-comments.component';
-import {CommonAppModule} from '../common-app.module';
-import {SeverityTagModule} from '@shared/widgets/severity-tag/severity-tag.module';
-import {FindingDialogModule} from '@shared/modules/finding-dialog/finding-dialog.module';
-import {CommentDialogModule} from '@shared/modules/comment-dialog/comment-dialog.module';
-import {FindigWidgetModule} from '@shared/widgets/findig-widget/findig-widget.module';
-import {TimerModule} from '@shared/modules/timer/timer.module';
-
-@NgModule({
-  declarations: [
-    PentestComponent,
-    PentestHeaderComponent,
-    PentestContentComponent,
-    PentestInfoComponent,
-    PentestFindingsComponent,
-    PentestCommentsComponent
-  ],
-    imports: [
-        CommonModule,
-        CommonAppModule,
-        RouterModule.forChild([{
-            path: '',
-            component: PentestComponent
-        }]),
-        NbLayoutModule,
-        NbCardModule,
-        FlexLayoutModule,
-        FontAwesomeModule,
-        TranslateModule,
-        NbButtonModule,
-        StatusTagModule,
-        NbTabsetModule,
-        NbTreeGridModule,
-        SeverityTagModule,
-        NbSelectModule,
-        // Dialog Modules
-        FindingDialogModule,
-        CommentDialogModule,
-        FindigWidgetModule,
-        // Modules
-        TimerModule,
-    ]
-})
-export class PentestModule {
-}

security-c4po-angular/src/app/project-overview/project-overview-routing.module.ts

@@ -1,10 +1,14 @@
 import { NgModule } from '@angular/core';
 import {RouterModule, Routes} from '@angular/router';
-import {Route} from '@shared/models/route.enum';
+import {ProjectOverviewComponent} from './project-overview.component';
 
 const routes: Routes = [
   {
-    path: Route.OBJECTIVE_OVERVIEW,
+    path: '',
+    component: ProjectOverviewComponent
+  },
+  {
+    path: 'id',
     loadChildren: () => import('./project').then(mod => mod.ProjectModule),
   }
 ];

security-c4po-angular/src/app/project-overview/project-overview.component.html

@@ -1,68 +1,84 @@
-<div fxFlex="0 1 max-content" fxLayout="column" class="pentest-overview">
-  <nb-layout fxFlex>
-    <!--Header-->
-    <nb-layout-header class="pentest-overview-header">
-      <div fxLayout="row" fxLayoutGap="2rem" fxLayoutAlign="space-between center">
-        <!--Filter-->
-        <div fxLayout="row" fxLayoutGap="1rem" class="header-filer">
-          <!--Actions-->
-          <form class="project-filter-input">
-            <nb-form-field>
-              <fa-icon nbPrefix class="search-prefix-icon" [icon]="fa.faSearch"></fa-icon>
-              <input type="search"
-                     fullWidth nbInput
-                     class="search-field"
-                     [formControl]="projectSearch"
-                     placeholder="{{ 'project.filter.placeholder' | translate: this.allProjectsCount$?.getValue() }}"
-                     status="basic"
-                     shape="semi-round"
-                     fieldSize="medium">
-            </nb-form-field>
-          </form>
-          <!--ToDo: Add dropdown to filter for specific state-->
+<div fxLayout="row" fxLayoutGap="2rem">
+  <div *ngFor="let project of projects | async">
+    <nb-card class="project-card" accent="success">
+      <nb-card-header fxLayoutAlign="start center"
+                      routerLink="id"
+                      fragment="{{project.id}}"
+                      class="project-link project-header"
+                      [state]="{selectedProject:project}">
+        <h4>{{project?.title}}</h4>
+      </nb-card-header>
+      <nb-card-body class="project-link"
+                    routerLink="id"
+                    fragment="{{project.id}}"
+                    [state]="{selectedProject:project}">
+        <p class="project-subheader">
+          {{'project.client' | translate}}:
+        </p>
+        <span class="project-paragraph">
+          {{project?.client}}
+        </span>
+
+        <p class="project-subheader">
+          {{'project.tester' | translate}}:
+        </p>
+        <span class="project-paragraph">
+          {{project?.tester}}
+        </span>
+
+        <p class="project-subheader">
+          {{'project.createdAt' | translate}}:
+        </p>
+        <span class="project-paragraph">
+          {{project?.createdAt | dateTimeFormat}}
+        </span>
+      </nb-card-body>
+      <nb-card-footer>
+        <!--ToDo: Display correct progress of project-->
+        <div fxLayout="row" fxLayoutGap="1rem" fxLayoutAlign="start end">
+          <nb-progress-bar class="project-progress"
+                           status="warning"
+                           [value]="40"
+                           [displayValue]="true">
+          </nb-progress-bar>
+          <button nbButton
+                  status="primary"
+                  size="small"
+                  class="project-button"
+                  (click)="onClickEditProject(project)">
+            <fa-icon [icon]="fa.faPencilAlt"></fa-icon>
+          </button>
           <button nbButton
                   status="danger"
-                  outline
-                  size="medium"
-                  shape="semi-round"
-                  class="reset-filter-btn"
-                  [disabled]="projectSearch.value === ''"
-                  (click)="onClickResetFilter()">
-            <fa-icon [icon]="fa.faFilterCircleXmark" class="btn-icon"></fa-icon>
-            {{'global.action.reset' | translate}}
+                  size="small"
+                  class="project-button"
+                  (click)="onClickDeleteProject(project)">
+            <fa-icon [icon]="fa.faTrash"></fa-icon>
           </button>
         </div>
-        <!--Button-->
-        <div class="header-project-button">
-          <button nbButton hero
-                  status="info"
-                  size="medium"
-                  shape="round"
-                  class="add-project-button"
-                  (click)="onClickAddProject()">
-            <fa-icon [icon]="fa.faPlus" class="btn-icon"></fa-icon>
-            {{'project.overview.add.project' | translate}}
-          </button>
-        </div>
-      </div>
-    </nb-layout-header>
-    <!--Column-->
-    <!--ToDo: Fix the column style for multiple projects in css-->
-    <nb-layout-column class="pentest-overview-column">
-      <div class="project-grid">
-        <div class="project" *ngFor="let project of projects$ | async">
-          <app-project-widget [project]="project"></app-project-widget>
-        </div>
-      </div>
-      <!--Error Text-->
-      <div *ngIf="projects$.getValue() == null || projects$.getValue().length === 0 && loading$.getValue() === false"
-           fxLayout="row" fxLayoutAlign="center center">
-        <p class="error-text">
-          {{'project.overview.no.projects' | translate}}
-        </p>
-      </div>
-      <!--Loading Spinner-->
-      <app-loading-spinner [isLoading$]="isLoading()" *ngIf="isLoading() | async"></app-loading-spinner>
-    </nb-layout-column>
-  </nb-layout>
+      </nb-card-footer>
+    </nb-card>
+  </div>
 </div>
+
+<div *ngIf="projects.getValue().length === 0 || !isLoading()" fxLayout="row" fxLayoutAlign="center center">
+  <p class="error-text">
+    {{'project.overview.no.projects' | translate}}
+  </p>
+</div>
+
+<div fxLayoutAlign="end end">
+  <button nbButton
+          status="primary"
+          size="large"
+          shape="round"
+          class="add-project-button"
+          (click)="onClickAddProject()">
+    <fa-icon [icon]="fa.faPlus" class="new-project-icon"></fa-icon>
+    {{'project.overview.add.project' | translate}}
+  </button>
+</div>
+
+<app-loading-spinner [isLoading$]="isLoading()" *ngIf="isLoading() | async"></app-loading-spinner>
+
+

security-c4po-angular/src/app/project-overview/project-overview.component.scss

@@ -1,88 +1,62 @@
 @import '../../assets/@theme/styles/themes';
-@import '../../assets/@theme/styles/variables';
-@import '../../assets/@theme/styles/_text-overflow.scss';
 
-.pentest-overview {
-  width: 100vw;
-  height: 85vh;
-  overflow: hidden !important;
+.project-card {
+  max-width: 22rem;
+  width: 22rem;
+  min-width: 20rem;
+  max-height: 100%;
+  height: 100%;
+  min-height: 100%;
 
-  .pentest-overview-header {
-    width: 100vw;
-    height: 5rem;
-
-    .header-filer {
-      .project-filter-input {
-        width: 24rem;
-        border-color: nb-theme(color-control-default);
-
-
-        .search-field:active {
-          color: nb-theme(color-info-default);
-          // opacity: initial;
-        }
-
-        .search-prefix-icon:active {
-          color: nb-theme(color-info-default);
-        }
-      }
-
-      .state-dialog {
-        margin-left: auto;
-        margin-right: 0;
-
-        .states {
-          width: 14rem !important;
-        }
-      }
-
-      .reset-filter-btn {
-        .btn-icon {
-          padding-right: 0.5rem;
-        }
-      }
-    }
-
-    .header-project-button {
-      position: fixed;
-      right: 1.5rem;
-
-      .add-project-button {
-        // align-content: flex-end;
-        margin: 6rem 2rem 6rem 0;
-
-        .btn-icon {
-          padding-right: 0.5rem;
-        }
-      }
-    }
+  .project-header {
+    max-height: 8rem;
+    height: 8rem;
+    min-height: 6rem;
   }
 
-  .pentest-overview-column {
-    width: 100vw;
-    // ToDo: Adjust this property when adding footer
-    height: calc(100% - 15rem) !important;
-    max-height: 100vh !important;
-    margin-top: 1.25rem;
-    // Scrollbar
-    overflow-y: scroll !important;
-    overflow-x: hidden;
-    scroll-behavior: smooth;
+  .project-subheader {
+    font-size: 1.25rem;
+    font-weight: bold;
+  }
 
-      .project-grid {
-        display: grid;
-        /* define the number of grid columns */
-        grid-template-columns: repeat( auto-fill, minmax(24rem, 1fr) );
+  .project-paragraph {
+    font-size: 1.15rem;
+    font-style: italic;
+  }
 
-        .project {
-          padding-bottom: 1.25rem;
-          height: max-content;
-        }
-      }
+  .project-progress {
+    max-width: 65%;
+    width: 65%;
+    min-width: 65%;
+  }
 
-    .error-text {
-      font-size: 1.25rem;
-      font-weight: bold;
-    }
+  .project-button {
+    height: 1.425rem;
   }
 }
+
+.project-card:hover {
+  background-color: nb-theme(color-basic-transparent-focus);
+  // Increases element size on hover
+  // Decreases usability which is why it is commented out
+  /*
+  margin-top: +0.625rem;
+  transform: scale(1.025);
+  */
+}
+
+.project-link:hover {
+  cursor: pointer !important;
+}
+
+.add-project-button {
+  margin: 6rem 2rem 6rem 0;
+  .new-project-icon {
+    padding-right: 0.5rem;
+  }
+}
+
+.error-text {
+  font-size: 1.25rem;
+  font-weight: bold;
+}

security-c4po-angular/src/app/project-overview/project-overview.component.spec.ts

@@ -8,17 +8,17 @@ import {NbButtonModule, NbCardModule, NbProgressBarModule, NbSpinnerModule} from
 import {FlexLayoutModule} from '@angular/flex-layout';
 import {FontAwesomeModule} from '@fortawesome/angular-fontawesome';
 import {TranslateLoader, TranslateModule} from '@ngx-translate/core';
-import {ProjectService} from '@shared/services/api/project.service';
+import {ProjectService} from '@shared/services/project.service';
 import {HttpLoaderFactory} from '../common-app.module';
-import {HttpClient} from '@angular/common/http';
+import {HttpClient, HttpClientModule} from '@angular/common/http';
 import {RouterTestingModule} from '@angular/router/testing';
 import {NgxsModule} from '@ngxs/store';
 import {SessionState} from '@shared/stores/session-state/session-state';
 import {HttpClientTestingModule} from '@angular/common/http/testing';
 import {BrowserAnimationsModule} from '@angular/platform-browser/animations';
-import {NotificationService} from '@shared/services/toaster-service/notification.service';
-import {NotificationServiceMock} from '@shared/services/toaster-service/notification.service.mock';
-import {ProjectServiceMock} from '@shared/services/api/project.service.mock';
+import {NotificationService} from '@shared/services/notification.service';
+import {NotificationServiceMock} from '@shared/services/notification.service.mock';
+import {ProjectServiceMock} from '@shared/services/project.service.mock';
 import {ThemeModule} from '@assets/@theme/theme.module';
 import {LoadingSpinnerComponent} from '@shared/widgets/loading-spinner/loading-spinner.component';
 import {KeycloakService} from 'keycloak-angular';
@@ -26,7 +26,7 @@ import {DialogService} from '@shared/services/dialog-service/dialog.service';
 import {DialogServiceMock} from '@shared/services/dialog-service/dialog.service.mock';
 import {ProjectDialogService} from '@shared/modules/project-dialog/service/project-dialog.service';
 import {ProjectDialogServiceMock} from '@shared/modules/project-dialog/service/project-dialog.service.mock';
-import {MockComponent} from 'ng-mocks';
+import {MockComponent, MockPipe} from 'ng-mocks';
 
 describe('ProjectOverviewComponent', () => {
   let component: ProjectOverviewComponent;
@@ -36,17 +36,19 @@ describe('ProjectOverviewComponent', () => {
     await TestBed.configureTestingModule({
       declarations: [
         ProjectOverviewComponent,
-        MockComponent(LoadingSpinnerComponent)
+        MockComponent(LoadingSpinnerComponent),
+        MockPipe(DateTimeFormatPipe)
       ],
       imports: [
         CommonModule,
+        ProjectOverviewRoutingModule,
         NbCardModule,
         NbButtonModule,
         FlexLayoutModule,
         BrowserAnimationsModule,
         FontAwesomeModule,
         TranslateModule,
-        ProjectOverviewRoutingModule,
+        NbProgressBarModule,
         NbSpinnerModule,
         HttpClientTestingModule,
         ThemeModule.forRoot(),
@@ -65,7 +67,7 @@ describe('ProjectOverviewComponent', () => {
         {provide: ProjectService, useValue: new ProjectServiceMock()},
         {provide: ProjectDialogService, useClass: ProjectDialogServiceMock},
         {provide: DialogService, useClass: DialogServiceMock},
-        {provide: NotificationService, useClass: NotificationServiceMock}
+        {provide: NotificationService, useValue: new NotificationServiceMock()}
       ]
     })
       .compileComponents();

security-c4po-angular/src/app/project-overview/project-overview.component.ts

@@ -1,19 +1,14 @@
 import {Component, OnInit} from '@angular/core';
 import * as FA from '@fortawesome/free-solid-svg-icons';
-import {Project} from '@shared/models/project.model';
+import {Project, ProjectDialogBody} from '@shared/models/project.model';
 import {BehaviorSubject, Observable} from 'rxjs';
 import {UntilDestroy, untilDestroyed} from '@ngneat/until-destroy';
-import {ProjectService} from '@shared/services/api/project.service';
-import {NotificationService, PopupType} from '@shared/services/toaster-service/notification.service';
-import {startWith, tap} from 'rxjs/operators';
+import {ProjectService} from '@shared/services/project.service';
+import {NotificationService, PopupType} from '@shared/services/notification.service';
+import {catchError, filter, mergeMap, switchMap, tap} from 'rxjs/operators';
 import {DialogService} from '@shared/services/dialog-service/dialog.service';
 import {ProjectDialogComponent} from '@shared/modules/project-dialog/project-dialog.component';
 import {ProjectDialogService} from '@shared/modules/project-dialog/service/project-dialog.service';
-import {Router} from '@angular/router';
-import {Store} from '@ngxs/store';
-import {UntypedFormControl} from '@angular/forms';
-import {ProjectState} from '@shared/stores/project-state/project-state';
-import {SetAvailableProjects} from '@shared/stores/project-state/project-state.actions';
 
 @UntilDestroy()
 @Component({
@@ -22,67 +17,32 @@ import {SetAvailableProjects} from '@shared/stores/project-state/project-state.a
   styleUrls: ['./project-overview.component.scss']
 })
 export class ProjectOverviewComponent implements OnInit {
-  // HTML only
+
   readonly fa = FA;
 
   loading$: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(true);
-  projects$: BehaviorSubject<Project[]> = new BehaviorSubject<Project[]>([]);
-  allProjects$: BehaviorSubject<Project[]> = new BehaviorSubject<Project[]>([]);
-
-  // Search
-  projectSearch: UntypedFormControl = new UntypedFormControl();
-  protected filter$: Observable<string>;
-  allProjectsCount$: BehaviorSubject<any> = new BehaviorSubject<any>({allProjectsCount: 0});
+  projects: BehaviorSubject<Project[]> = new BehaviorSubject<Project[]>([]);
 
   constructor(
-    private readonly notificationService: NotificationService,
-    private store: Store,
-    private router: Router,
-    private projectService: ProjectService,
-    private dialogService: DialogService,
-    private projectDialogService: ProjectDialogService) {
+    private readonly projectService: ProjectService,
+    private readonly dialogService: DialogService,
+    private readonly projectDialogService: ProjectDialogService,
+    private readonly notificationService: NotificationService) {
   }
 
   ngOnInit(): void {
-    // Load all available projects
     this.loadProjects();
-    // Subscribe to project store
-    this.store.select(ProjectState.allProjects).pipe(
-      untilDestroyed(this)
-    ).subscribe({
-      next: (projects: Project[]) => {
-        // tslint:disable-next-line:no-console
-        if (projects && projects.length === 0) {
-          this.loadProjects();
-        }
-        // Setup Search Form
-        this.projectSearch = new UntypedFormControl({value: '', disabled: projects?.length === 0});
-        this.setFilterObserverForProjects();
-      },
-      error: err => {
-        console.error(err);
-      },
-    });
   }
 
   loadProjects(): void {
     this.projectService.getProjects()
       .pipe(
-        tap(() => this.loading$.next(true)),
-        untilDestroyed(this)
+        untilDestroyed(this),
+        tap(() => this.loading$.next(true))
       )
       .subscribe({
         next: (projects: Project[]) => {
-          if (projects) {
-            this.projects$.next(projects);
-            this.allProjects$.next(projects);
-            this.allProjectsCount$.next({allProjectsCount: projects.length});
-            this.store.dispatch(new SetAvailableProjects(projects));
-          } else {
-            this.projects$.next([]);
-            this.allProjects$.next([]);
-            this.allProjectsCount$.next({allProjectsCount: 0});
-          }
+          this.projects.next(projects);
           this.loading$.next(false);
         },
         error: err => {
@@ -100,50 +60,78 @@ export class ProjectOverviewComponent implements OnInit {
       {
         closeOnEsc: false,
         hasScroll: false,
-        autoFocus: true,
+        autoFocus: false,
         closeOnBackdropClick: false
       }
     ).pipe(
+      filter(value => !!value),
+      mergeMap((value: ProjectDialogBody) => this.projectService.saveProject(value)),
       untilDestroyed(this)
     ).subscribe({
       next: () => {
         this.loadProjects();
+        this.notificationService.showPopup('project.popup.save.success', PopupType.SUCCESS);
+      },
+      error: error => {
+        console.error(error);
+        this.notificationService.showPopup('project.popup.save.failed', PopupType.FAILURE);
+      }
+    });
+  }
+
+  onClickEditProject(project: Project): void {
+    this.projectDialogService.openProjectDialog(
+      ProjectDialogComponent,
+      project,
+      {
+        closeOnEsc: false,
+        hasScroll: false,
+        autoFocus: false,
+        closeOnBackdropClick: false
+      }
+    ).pipe(
+      filter(value => !!value),
+      mergeMap((value: ProjectDialogBody) => this.projectService.updateProject(project.id, value)),
+      untilDestroyed(this)
+    ).subscribe({
+      next: () => {
+        this.loadProjects();
+        this.notificationService.showPopup('project.popup.update.success', PopupType.SUCCESS);
+      },
+      error: error => {
+        console.error(error);
+        this.notificationService.showPopup('project.popup.update.failed', PopupType.FAILURE);
+      }
+    });
+  }
+
+  onClickDeleteProject(project: Project): void {
+    const message = {
+      title: 'project.delete.title',
+      key: 'project.delete.key',
+      data: {name: project.title},
+    };
+    this.dialogService.openConfirmDialog(
+      message
+    ).onClose.pipe(
+      filter((confirm) => !!confirm),
+      switchMap(() => this.projectService.deleteProjectById(project.id)),
+      catchError(() => {
+        this.notificationService.showPopup('project.popup.delete.failed', PopupType.FAILURE);
+        return [];
+      }),
+      untilDestroyed(this)
+    ).subscribe({
+      next: () => {
+        this.loadProjects();
+        this.notificationService.showPopup('project.popup.delete.success', PopupType.SUCCESS);
+      }, error: error => {
+        console.error(error);
       }
     });
   }
 
-  // HTML only
   isLoading(): Observable<boolean> {
     return this.loading$.asObservable();
   }
-
-  onClickResetFilter(): void {
-    this.projectSearch.reset('');
-    this.projects$.next(this.allProjects$.getValue());
-  }
-
-  private setFilterObserverForProjects(): void {
-    this.filter$ = this.projectSearch.valueChanges.pipe(startWith(''));
-    this.filter$.subscribe(
-      (filterString: string) => {
-        if (filterString.length === 0) {
-          this.projects$.next(this.allProjects$.getValue());
-        } else {
-          const matchingProjects: Project[] = [];
-          this.allProjects$.getValue().forEach(project => {
-            // Project attributes that the user can filter through
-            if (
-              project.title.toLowerCase().includes(filterString.toLowerCase())
-              || project.client.toLowerCase().includes(filterString.toLowerCase())
-              || project.tester.toLowerCase().includes(filterString.toLowerCase())
-              || project.state.toString().toLowerCase().includes(filterString.toLowerCase())
-            ) {
-              matchingProjects.push(project);
-            }
-          });
-          this.projects$.next(matchingProjects);
-        }
-      }
-    );
-  }
 }

security-c4po-angular/src/app/project-overview/project-overview.module.ts

@@ -2,55 +2,34 @@ import {NgModule} from '@angular/core';
 import {CommonModule} from '@angular/common';
 import {ProjectOverviewComponent} from './project-overview.component';
 import {ProjectOverviewRoutingModule} from './project-overview-routing.module';
-import {
-  NbButtonModule,
-  NbCardModule,
-  NbFormFieldModule,
-  NbInputModule,
-  NbLayoutModule,
-  NbProgressBarModule,
-  NbSelectModule
-} from '@nebular/theme';
+import {NbButtonModule, NbCardModule, NbMenuModule, NbProgressBarModule, NbSidebarModule, NbSpinnerModule} from '@nebular/theme';
 import {FlexLayoutModule} from '@angular/flex-layout';
 import {FontAwesomeModule} from '@fortawesome/angular-fontawesome';
 import {TranslateModule} from '@ngx-translate/core';
+import {DateTimeFormatPipe} from '@shared/pipes/date-time-format.pipe';
 import {ProjectDialogModule} from '@shared/modules/project-dialog/project-dialog.module';
-import {CommonAppModule} from '../common-app.module';
-import {ConfirmDialogModule} from '@shared/modules/confirm-dialog/confirm-dialog.module';
-import {SecurityConfirmDialogModule} from '@shared/modules/security-confirm-dialog/security-confirm-dialog.module';
-import {RouterModule} from '@angular/router';
-import {ReportStateTagModule} from '@shared/widgets/report-state-tag/report-state-tag.module';
-import {ReactiveFormsModule} from '@angular/forms';
-import {ProjectWidgetModule} from '@shared/widgets/project-widget/project-widget.module';
+import {LoadingSpinnerComponent} from '@shared/widgets/loading-spinner/loading-spinner.component';
 
 @NgModule({
   declarations: [
-    ProjectOverviewComponent
+    ProjectOverviewComponent,
+    DateTimeFormatPipe,
+    LoadingSpinnerComponent
   ],
   imports: [
     CommonModule,
-    CommonAppModule,
-    RouterModule.forChild([{
-      path: '',
-      component: ProjectOverviewComponent
-    }]),
     NbCardModule,
     NbButtonModule,
+    NbSpinnerModule,
     NbProgressBarModule,
     ProjectOverviewRoutingModule,
     FlexLayoutModule,
     FontAwesomeModule,
     TranslateModule,
-    ProjectDialogModule,
-    ConfirmDialogModule,
-    ReportStateTagModule,
-    SecurityConfirmDialogModule,
-    NbLayoutModule,
-    NbInputModule,
-    NbFormFieldModule,
-    ReactiveFormsModule,
-    NbSelectModule,
-    ProjectWidgetModule
+    ProjectDialogModule
+  ],
+  exports: [
+    LoadingSpinnerComponent
   ]
 })
 export class ProjectOverviewModule {

security-c4po-angular/src/app/project-overview/project/project-routing.module.ts

@@ -1,11 +1,15 @@
 import {NgModule} from '@angular/core';
 import {RouterModule, Routes} from '@angular/router';
-import {Route} from '@shared/models/route.enum';
+import {ProjectComponent} from './project.component';
 
 const routes: Routes = [
   {
-    path: Route.PENTEST_OBJECTIVE,
-    loadChildren: () => import('../../pentest').then(mod => mod.PentestModule),
+    path: '',
+    component: ProjectComponent
+  },
+  {
+    path: 'pentest',
+    loadChildren: () => import('../../pentest-overview/pentest').then(mod => mod.PentestModule),
   },
 ];
 

security-c4po-angular/src/app/project-overview/project/project.component.html

@@ -2,19 +2,19 @@
   <nb-layout fxFlex>
 
     <nb-layout-header fxFlex="0 1 max-content" class="header-column">
-      <app-objective-header></app-objective-header>
+      <app-pentest-header></app-pentest-header>
     </nb-layout-header>
 
     <nb-layout-column fxFlex="0 1 max-content" class="column-wrapper">
       <nb-card class="categories-column">
-        <app-objective-categories></app-objective-categories>
+        <app-pentest-categories></app-pentest-categories>
       </nb-card>
     </nb-layout-column>
 
-    <nb-layout-column fxFlex=" max-content" class="table-wrapper" >
+    <nb-layout-column fxFlex="0 1  max-content" class="table-wrapper" >
       <nb-card class="table-column">
         <nb-card-body>
-          <app-objective-table></app-objective-table>
+          <app-pentest-table></app-pentest-table>
         </nb-card-body>
       </nb-card>
     </nb-layout-column>

security-c4po-angular/src/app/project-overview/project/project.component.scss

@@ -8,24 +8,22 @@
 
   .header-column {
     width: 100vw;
-    height: $pentest-header-height;
   }
 
   .column-wrapper {
     padding-left: 0 !important;
 
     .categories-column {
-      height: calc(100vh - #{$pentest-header-height} - #{$header-height});
+      height: calc(100vh - #{$pentest-header-height});
     }
   }
 
   .table-wrapper{
     padding-right: 0 !important;
-    border-style: none;
 
     .table-column {
       overflow: auto !important;
-      height: calc(100vh - #{$pentest-header-height} - #{$header-height});
+      height: calc(100vh - #{$pentest-header-height});
     }
   }
 }

security-c4po-angular/src/app/project-overview/project/project.component.spec.ts

@@ -7,66 +7,18 @@ import {TranslateLoader, TranslateModule} from '@ngx-translate/core';
 import {HttpLoaderFactory} from '../../common-app.module';
 import {HttpClient, HttpClientModule} from '@angular/common/http';
 import {RouterTestingModule} from '@angular/router/testing';
-import {NgxsModule, Store} from '@ngxs/store';
+import {NgxsModule} from '@ngxs/store';
+import {SessionState} from '@shared/stores/session-state/session-state';
 import {HttpClientTestingModule} from '@angular/common/http/testing';
-import {NbCardModule, NbDialogRef, NbLayoutModule} from '@nebular/theme';
+import {NbCardModule, NbLayoutModule} from '@nebular/theme';
 import {KeycloakService} from 'keycloak-angular';
-import {ObjectiveOverviewModule} from '../../objective-overview';
-import {NotificationService} from '@shared/services/toaster-service/notification.service';
-import {NotificationServiceMock} from '@shared/services/toaster-service/notification.service.mock';
-import {DialogService} from '@shared/services/dialog-service/dialog.service';
-import {DialogServiceMock} from '@shared/services/dialog-service/dialog.service.mock';
-import {ProjectService} from '@shared/services/api/project.service';
-import {ProjectServiceMock} from '@shared/services/api/project.service.mock';
-import {ProjectDialogService} from '@shared/modules/project-dialog/service/project-dialog.service';
-import {ProjectDialogServiceMock} from '@shared/modules/project-dialog/service/project-dialog.service.mock';
-import {PROJECT_STATE_NAME, ProjectState, ProjectStateModel} from '@shared/stores/project-state/project-state';
-import {Category} from '@shared/models/category.model';
-import {PentestStatus} from '@shared/models/pentest-status.model';
-import {createSpyObj} from '@shared/modules/finding-dialog/finding-dialog.component.spec';
-import {ExportReportDialogService} from '@shared/modules/export-report-dialog/service/export-report-dialog.service';
-import {ExportReportDialogServiceMock} from '@shared/modules/export-report-dialog/service/export-report-dialog.service.mock';
-import {ReportState} from '@shared/models/state.enum';
-
-const DESIRED_PROJECT_STATE_SESSION: ProjectStateModel = {
-  allProjects: [],
-  selectedProject: {
-    id: '56c47c56-3bcd-45f1-a05b-c197dbd33111',
-    client: 'E Corp',
-    title: 'Some Mock API (v1.0) Scanning',
-    createdAt: new Date('2019-01-10T09:00:00'),
-    tester: 'Novatester',
-    summary: '',
-    state: ReportState.NEW,
-    version: '1.0',
-    testingProgress: 0,
-    createdBy: '11c47c56-3bcd-45f1-a05b-c197dbd33110'
-  },
-  // Manages Categories
-  disabledCategories: [],
-  selectedCategory: Category.INFORMATION_GATHERING,
-  // Manages Pentests of Category
-  disabledPentests: [],
-  selectedPentest: {
-    id: '56c47c56-3bcd-45f1-a05b-c197dbd33112',
-    category: Category.INFORMATION_GATHERING,
-    refNumber: 'OTF-001',
-    childEntries: [],
-    status: PentestStatus.NOT_STARTED,
-    enabled: true,
-    findingIds: [],
-    commentIds: ['56c47c56-3bcd-45f1-a05b-c197dbd33112']
-  },
-};
+import {PentestOverviewModule} from '../../pentest-overview';
 
 describe('ProjectComponent', () => {
   let component: ProjectComponent;
   let fixture: ComponentFixture<ProjectComponent>;
-  let store: Store;
 
   beforeEach(async () => {
-    const dialogSpy = createSpyObj('NbDialogRef', ['close']);
-
     await TestBed.configureTestingModule({
       declarations: [
         ProjectComponent
@@ -75,7 +27,7 @@ describe('ProjectComponent', () => {
         CommonModule,
         NbLayoutModule,
         NbCardModule,
-        ObjectiveOverviewModule,
+        PentestOverviewModule,
         ThemeModule.forRoot(),
         TranslateModule.forRoot({
           loader: {
@@ -85,18 +37,12 @@ describe('ProjectComponent', () => {
           }
         }),
         RouterTestingModule.withRoutes([]),
-        NgxsModule.forRoot([ProjectState]),
+        NgxsModule.forRoot([SessionState]),
         HttpClientModule,
         HttpClientTestingModule
       ],
       providers: [
-        KeycloakService,
-        {provide: ProjectService, useValue: new ProjectServiceMock()},
-        {provide: DialogService, useClass: DialogServiceMock},
-        {provide: NbDialogRef, useValue: dialogSpy},
-        {provide: ExportReportDialogService, useClass: ExportReportDialogServiceMock},
-        {provide: ProjectDialogService, useClass: ProjectDialogServiceMock},
-        {provide: NotificationService, useClass: NotificationServiceMock}
+        KeycloakService
       ]
     })
       .compileComponents();
@@ -104,11 +50,6 @@ describe('ProjectComponent', () => {
 
   beforeEach(() => {
     fixture = TestBed.createComponent(ProjectComponent);
-    store = TestBed.inject(Store);
-    store.reset({
-      ...store.snapshot(),
-      [PROJECT_STATE_NAME]: DESIRED_PROJECT_STATE_SESSION
-    });
     component = fixture.componentInstance;
     fixture.detectChanges();
   });

security-c4po-angular/src/app/project-overview/project/project.component.ts

@@ -1,9 +1,9 @@
 import {Component, OnInit} from '@angular/core';
 import {Store} from '@ngxs/store';
+import {InitProjectState} from '@shared/stores/project-state/project-state.actions';
 import {Router} from '@angular/router';
-import {UntilDestroy, untilDestroyed} from '@ngneat/until-destroy';
 import {Route} from '@shared/models/route.enum';
-import {ProjectState} from '@shared/stores/project-state/project-state';
+import {UntilDestroy, untilDestroyed} from '@ngneat/until-destroy';
 import {Project} from '@shared/models/project.model';
 
 @UntilDestroy()
@@ -20,23 +20,19 @@ export class ProjectComponent implements OnInit {
   }
 
   ngOnInit(): void {
-    this.store.select(ProjectState.project).pipe(
-      untilDestroyed(this)
-    ).subscribe({
-      next: (selectedProject: Project) => {
-        this.initProjectStore();
-      },
-      error: err => {
-        console.error(err);
-      }
-    });
+    if (history?.state && 'selectedProject' in history?.state) {
+      this.initProjectStore();
+    } else {
+      this.router.navigate([Route.PROJECT_OVERVIEW]).finally();
+    }
   }
 
   private initProjectStore(): void {
-    this.router.navigate([Route.OBJECTIVE_OVERVIEW]).then(() => {
-    }, err => {
-      this.router.navigate([Route.PROJECT_OVERVIEW]);
-      console.error(err);
-    });
+    const project: Project = history?.state?.selectedProject ? history?.state?.selectedProject : null;
+    this.store.dispatch(new InitProjectState(
+      project,
+      [],
+      []
+    )).pipe(untilDestroyed(this)).subscribe();
   }
 }

security-c4po-angular/src/app/project-overview/project/project.module.ts

@@ -2,20 +2,22 @@ import {NgModule} from '@angular/core';
 import {CommonModule} from '@angular/common';
 import {RouterModule} from '@angular/router';
 import {ProjectComponent} from './project.component';
-import {NbCardModule, NbLayoutModule} from '@nebular/theme';
+import {NbCardModule, NbLayoutModule, NbMenuModule, NbSidebarModule} from '@nebular/theme';
 import {FlexLayoutModule} from '@angular/flex-layout';
 import {TranslateModule} from '@ngx-translate/core';
+import {ProjectDialogModule} from '@shared/modules/project-dialog/project-dialog.module';
 import {ProjectRoutingModule} from './project-routing.module';
-import {ObjectiveOverviewModule} from '../../objective-overview';
-import {CommonAppModule} from '../../common-app.module';
+import {PentestOverviewModule} from '../../pentest-overview';
 
 @NgModule({
   declarations: [
     ProjectComponent
   ],
+  exports: [
+    ProjectComponent
+  ],
   imports: [
     CommonModule,
-    CommonAppModule,
     NbCardModule,
     NbLayoutModule,
     RouterModule.forChild([{
@@ -25,10 +27,8 @@ import {CommonAppModule} from '../../common-app.module';
     ProjectRoutingModule,
     TranslateModule,
     FlexLayoutModule,
-    ObjectiveOverviewModule
-  ],
-  exports: [
-    ProjectComponent
+    ProjectDialogModule,
+    PentestOverviewModule
   ]
 })
 export class ProjectModule {

security-c4po-angular/src/assets/@theme/styles/_dialog.scss

@@ -1,5 +1,5 @@
 .dialog-header {
-  height: 6.75vh !important;
+  height: 6.75vh;
   font-size: 1.5rem;
 
   .dialog-headline {
@@ -8,13 +8,11 @@
 }
 
 .dialog-body {
-  font-size: 1rem;
-  white-space: pre-line;
+  font-size: 1.15rem;
 }
 
 .dialog-button {
-  width: 5.75rem !important;
-  height: 2.15rem !important;
-  text-transform: none !important;
-  font-size: 0.85rem;
+  width: 5.25rem;
+  height: 2.5rem;
+  // font-size: 0.85rem;
 }

security-c4po-angular/src/assets/@theme/styles/_text-overflow.scss

@@ -1,16 +0,0 @@
-/* mixin for multiline */
-@mixin multiLineEllipsis($font-size, $font-weight, $line-height, $lines-to-show, $max-width) {
-  // Fallback for non-webkit
-  display: block;
-  display: -webkit-box;
-  max-width: $max-width;
-  // Fallback for non-webkit
-  height: calc(#{$font-size} * #{$line-height} * #{$lines-to-show});
-  font-size: $font-size;
-  font-weight: $font-weight;
-  line-height: $line-height;
-  -webkit-line-clamp: $lines-to-show;
-  -webkit-box-orient: vertical;
-  overflow: hidden;
-  text-overflow: ellipsis;
-}

security-c4po-angular/src/assets/@theme/styles/styles.scss

@@ -2,17 +2,13 @@
 @import 'themes';
 
 // framework component themes (styles tied to theme variables)
-@import '@nebular/theme/styles/globals';
+@import '~@nebular/theme/styles/globals';
 
 // loading progress bar theme
 @import './pace.theme';
 @import './overrides';
 @import './variables';
 
-// loading glide
-@import "@glidejs/glide/src/assets/sass/glide.core";
-@import "@glidejs/glide/src/assets/sass/glide.theme";
-
 * {
   font-family: Roboto, "Helvetica Neue", sans-serif;
 }

security-c4po-angular/src/assets/@theme/styles/themes.scss

@@ -1,7 +1,7 @@
 // @nebular theming framework
-@import '@nebular/theme/styles/theming';
+@import '~@nebular/theme/styles/theming';
 // @nebular out of the box themes
-@import '@nebular/theme/styles/themes';
+@import '~@nebular/theme/styles/themes';
 // enable custom css properties
 $nb-enable-css-custom-properties: true;
 

security-c4po-angular/src/assets/i18n/de-DE.json

@@ -1,40 +1,17 @@
 {
   "global": {
-    "actions": "Aktionen",
-    "action.profile": "Profil",
     "action.login": "Einloggen",
-    "action.logout": "Ausloggen",
     "action.retry": "Erneut Versuchen",
-    "action.info": "Info",
     "action.save": "Speichern",
     "action.confirm": "Bestätigen",
     "action.cancel": "Abbrechen",
     "action.return": "Zurück",
-    "action.exit": "Beenden",
     "action.update": "Speichern",
-    "action.edit": "Editieren",
     "action.export": "Exportieren",
-    "action.download": "Herunterladen",
-    "action.report": "Bericht",
-    "action.reset": "Zurücksetzen",
-    "action.complete": "Fertig",
-    "action.disable": "Deaktivieren",
-    "action.enable": "Aktivieren",
-    "action.close": "Schließen",
     "action.yes": "Ja",
     "action.no": "Nein",
     "username": "Nutzername",
-    "password": "Passwort",
-    "no.progress": "Kein Fortschritt",
-    "project": "Projekt",
-    "version": "Version",
-    "validationMessage": {
-      "inputNotMatching": "Eingabe stimmt nicht überein!"
-    },
-    "retry.dialog": {
-      "title": "Etwas ist schief gelaufen...",
-      "information": "Fehler beim verarbeiten Ihrer Anfrage. \nBitte versuchen Sie es erneut oder zu einem späteren Zeitpunkt."
-    }
+    "password": "Passwort"
   },
   "languageKeys":{
     "de-DE": "Deutsch",
@@ -58,105 +35,18 @@
     "failed": "Benutzername oder Passwort falsch",
     "unauthorized": "Benutzer nicht gefunden. Bitte registrieren und erneut versuchen"
   },
-  "profile": {
-    "header": "Nutzerprofil",
-    "username": {
-      "title": "Nutzername",
-      "placeholder": "Nutzername"
-    },
-    "firstName": {
-      "title": "Vorname",
-      "placeholder": "Vorname"
-    },
-    "lastName": {
-      "title": "Nachname",
-      "placeholder": "Nachname"
-    },
-    "eMail": {
-      "title": "E-Mail",
-      "placeholder": "Keine E-Mail bestätigt."
-    },
-    "validationMessage": {
-      "firstNameRequired": "Vorname ist erforderlich.",
-      "lastNameRequired": "Nachname ist erforderlich."
-    },
-    "languageLabel": "Sprache ändern:",
-    "password": {
-      "title": "Passwort ändern:",
-      "button" : "Passwort ändern",
-      "old": "Altes Passwort",
-      "new": "Neues Passwort",
-      "confirmNew": "Neues Passwort bestätigen",
-      "validationMessage": {
-        "passwordRequired": "Passwort ist erforderlich."
-      }
-    }
-  },
-  "tutorial": {
-    "header": "Erste Schritte mit C4PO",
-    "carousel": {
-      "project_overview": "Die Projektübersicht gibt Ihnen einen Überblick über alle Ihre aktuellen Projekte.\nHier können Sie neue erstellen, bestehende bearbeiten oder löschen oder nach einem bestimmten Projekt filtern.\nSehen Sie den aktuellen Stand Ihrer Projekte sowie den Fortschritt zusammen mit einigen zusätzlichen Informationen wie Name, Kunde, Tester und wann es erstellt wurde.",
-      "project_overview_filtered": "Das Filtern in der Projektübersicht kann Ihnen helfen, das/die gesuchte(n) Projekt(e) zu finden.\nGeben Sie bestimmte Schlüsselwörter wie den Titel eines Projekts oder einen speziellen Status wie „Benötigt weitere Informationen“ ein oder suchen Sie nach einem wichtigen Kunden.",
-      "create_edit_project": "Erstellen Sie ein neues oder ein bestehendes Projekt, geben Sie ihm einen Titel und einen Kundennamen, weisen Sie einen Tester zu und schreiben Sie eine Zusammenfassung für den Pentest (nur im Bearbeitungsmodus verfügbar).\nDarüber hinaus können Sie auch einen bestimmten Status für das Projekt auswählen, um anzuzeigen, ob der Pentest derzeit „in Arbeit“ ist oder darauf wartet, dass der Kunde den Bericht überprüft.",
-      "userprofile": "Ändern Sie Ihre Einstellungen.\nEgal, ob Sie nur die Sprache der Anwendung auswählen oder Ihr Passwort ändern.",
-      "category&objective_overview": "Sehen Sie sich hier jedes Ziel jeder Kategorie an.\nDerselbe Inhalt ist auch im OWASP Web Testing Guide enthalten.\nSie können sich einen guten Überblick über alle Ziele verschaffen, die in einer bestimmten Kategorie enthalten sind, sehen, wie viele Ergebnisse und Kommentare hinzugefügt wurden, und sogar bestimmte Ziele deaktivieren, was zur Folge hat, dass sie nicht in den Bericht aufgenommen werden.",
-      "objective_info": "Lesen Sie die wichtigsten Informationen zum gewählten Ziel.\nZu diesen Informationen gehört, was am Ziel zu tun ist, welche Probleme am häufigsten auftreten und wie Sie sie ausnutzen können.",
-      "objective_finding_overview": "Sehen Sie sich alle Funde an, die sich auf das ausgewählte Ziel beziehen.\nSie können den Titel, den Schweregrad, einen Teil der Beschreibung und die Auswirkung des Befundes sehen.\nDarüber hinaus können Sie einen bestimmten Befund auch bearbeiten oder sogar löschen.",
-      "create_edit_finding": "Bearbeiten oder erstellen Sie neue Funde für das Ziel.\nDokumentieren Sie hier den Titel, die Beschreibung, die betroffenen Anwendungsteile, die betroffenen URLs oder APIs und eine Schweregradbewertung zusammen mit Reproduktionsschritten und einem Abhilfevorschlag.\nSie können Befunde erst erstellen, wenn Sie den Timer gestartet haben, damit Ihre Arbeit nachverfolgt wird.",
-      "objective_comment_overview": "Sehen Sie sich alle Kommentare an, die sich auf das ausgewählte Ziel beziehen.\nSie können den Titel und einen Teil der Beschreibung des Kommentars sehen.\nDarüber hinaus können Sie einen bestimmten Kommentar auch bearbeiten oder sogar löschen.",
-      "create_edit_comment": "Bearbeiten oder erstellen Sie neue Kommentare für das Ziel.\nDokumentieren Sie hier den Titel und eine Beschreibung.\nSie können Kommentare erst erstellen, wenn Sie den Timer gestartet haben, damit Ihre Arbeit nachverfolgt wird.",
-      "generate_report": "Generieren und exportieren Sie Ihren Bericht. Sie können den Namen und die Version Ihres Projekts sowie einige Statistiken darüber sehen, wie viele Ihrer Ziele abgeschlossen, in Bearbeitung, pausiert, nicht gestartet oder deaktiviert sind.\nNur Ihre abgeschlossenen Ziele werden in den Abschlussbericht aufgenommen.\nStellen Sie vor dem Exportieren sicher, dass Sie die richtige Sprache für Ihren Bericht auswählen.",
-      "report": "Laden Sie Ihren generierten Bericht als PDF herunter und senden Sie ihn direkt an den Kunden.\nDer Bericht enthält alle Informationen, die Sie in der C4PO-Anwendung eingegeben haben.\nDer Bericht besteht aus einem Deckblatt, einem Inhaltsverzeichnis, dem Stand der Vertraulichkeit, einer Zusammenfassung, technischen Details zu den Ergebnissen sowie Kommentaren und Anhängen."
-    }
-  },
-  "state": {
-    "new": "Neu",
-    "needs_more_info": "Benötigt mehr Informationen",
-    "pre_submission": "Voranmeldung",
-    "pending": "Pending",
-    "triaged": "Ausstehend",
-    "retesting": "Erneutes Testen",
-    "resolved": "Aufgeklärt",
-    "informative": "Informativ",
-    "duplicate": "Duplikat",
-    "not_applicable": "Unzutreffend",
-    "spam": "Spam",
-    "out_of_scope": "Außerhalb Anwendungsbereich",
-    "accepted_risk": "Akzeptiertes Risiko"
-  },
-  "report": {
-    "dialog": {
-      "header": "Penetrationstestbereicht exportieren",
-      "formatLabel": "Wählen Sie das Exportformat für den Bericht:",
-      "languageLabel": "Wählen Sie die Berichtssprache:"
-    },
-    "popup": {
-      "generation.success": "Bericht erfolgreich generiert",
-      "generation.failed": "Bericht konnte nicht generiert werden"
-    },
-    "generate": "Bericht generieren",
-    "hint": "{{completedObjectivesNumber}} Ihrer abgeschlossenen Ziele wird in den Pentestbericht aufgenommen."
-  },
   "project": {
     "title.label": "Projekt Titel",
     "client.label": "Name des Auftraggebers",
     "tester.label": "Name des Pentester",
-    "state.label": "Penteststatus",
-    "summary.label": "Zusammenfassung",
-    "summary.placeholder": "Sollte eine Zusammenfassung, einen Ansatz, einen Umfang und eine Bewertungsübersicht sowie allgemeine Empfehlungen enthalten",
     "title": "Titel",
     "client": "Klient",
     "tester": "Tester",
-    "state": "Penteststatus",
-    "summary": "Zusammenfassung",
     "createdAt": "Erstellt am",
     "overview": {
       "add.project": "Projekt hinzufügen",
       "no.projects": "Keine Projekte verfügbar"
     },
-    "filter": {
-      "placeholder": "Alle {{allProjectsCount}} Projekt(e) durchsuchen.."
-    },
     "create": {
       "header": "Neues Projekt erstellen"
     },
@@ -165,16 +55,12 @@
     },
     "delete": {
       "title": "Projekt löschen",
-      "key": "Möchten Sie das Projekt \"{{name}}\" unwiderruflich löschen?",
-      "confirmStringPlaceholder": "Geben Sie zur Bestätigung den Projekttitel ein",
-      "sec.key": "Möchten Sie das Projekt \"{{name}}\" unwiderruflich löschen? \nSie löschen damit auch alle zugehörigen Daten."
+      "key": "Möchten Sie das Projekt \"{{name}}\" unwiderruflich löschen?"
     },
     "validationMessage": {
       "titleRequired": "Titel ist erforderlich.",
       "clientRequired": "Klient ist erforderlich.",
-      "testerRequired": "Tester ist erforderlich.",
-      "stateRequired": "Status ist erforderlich.",
-      "summaryRequired": "Zusammenfassung ist erforderlich."
+      "testerRequired": "Tester ist erforderlich."
     },
     "popup": {
       "not.found": "Keine Projekte gefunden",
@@ -186,155 +72,20 @@
       "delete.failed": "Projekt konnte nicht gelöscht werden"
     }
   },
-  "categories": {
-    "INFORMATION_GATHERING": "Informationsbeschaffung",
-    "CONFIGURATION_AND_DEPLOY_MANAGEMENT_TESTING": "Konfig- & Einsatzmanagement-Testing",
-    "IDENTITY_MANAGEMENT_TESTING": "Identitätsmanagement-Testing",
-    "AUTHENTICATION_TESTING": "Authentifizierungs-Testing",
-    "AUTHORIZATION_TESTING": "Autorisations-Testing",
-    "SESSION_MANAGEMENT_TESTING": "Sitzungsmanagement-Testing",
-    "INPUT_VALIDATION_TESTING": "Eingabevalidierungs-Testing",
-    "ERROR_HANDLING": "Fehlerbehandlung",
-    "CRYPTOGRAPHY": "Kryptographie",
-    "BUSINESS_LOGIC_TESTING": "Business-Logik-Testing",
-    "CLIENT_SIDE_TESTING": "Clientseitiges-Testing",
-    "API_TESTING": "API Testing"
-  },
-  "finding": {
-    "findingId": "Fund Id",
-    "severity": "Schwere",
-    "title": "Titel",
-    "description": "Beschreibung",
-    "impact": "Auswirkung",
-    "affectedUrls": "Betroffene URL's / API's",
-    "reproduction": "Reproduktion",
-    "mitigation": "Minderung",
-    "add": "Fund hinzufügen",
-    "add.url": "Betroffene URL / API hinzufügen",
-    "affectedUrls.placeholder": "Betroffene URL oder API hier eingeben..",
-    "create": {
-      "header": "Neuen Fund erstellen"
-    },
-    "edit": {
-      "header": "Fund editieren"
-    },
-    "delete": {
-      "title": "Fund löschen",
-      "key": "Möchten Sie den Fund \"{{name}}\" unwiderruflich löschen?"
-    },
-    "severity.label": "Schwere des Funds",
-    "title.label": "Fundtitel",
-    "description.label": "Beschreibung des Funds",
-    "impact.label": "Auswirkung auf Anwendung",
-    "affectedUrls.label": "Betroffene URL's / API's",
-    "reproduction.label": "Reproduktionsschritte",
-    "mitigation.label": "Minderungsvorschlag",
-    "no.findings": "Keine Funde verfügbar",
-    "validationMessage": {
-      "titleRequired": "Titel ist erforderlich.",
-      "severityRequired": "Schwere ist erforderlich.",
-      "descriptionRequired": "Beschreibung ist erforderlich.",
-      "impactRequired": "Auswirkung ist erforderlich.",
-      "affectedUrlsRequired": "Betroffene URL's erforderlich.",
-      "reproductionRequired": "Reproduktionschritt(e) sind erforderlich.",
-      "mitigationRequired": "Minderungsvorschlag ist erforderlich."
-    },
-    "popup": {
-      "not.found": "Keine Funde gefunden",
-      "save.success": "Fund erfolgreich gespeichert",
-      "save.failed": "Fund konnte nicht gespeichert werden",
-      "update.success": "Fund erfolgreich aktualisiert",
-      "update.failed": "Fund konnte nicht aktualisiert werden",
-      "delete.success": "Fund erfolgreich gelöscht",
-      "delete.failed": "Fund konnte nicht gelöscht werden",
-      "not.available": "Fund ist nicht mehr verfügbar"
-    }
-  },
-  "severities": {
-    "low": "Niedrig",
-    "medium": "Mittel",
-    "high": "Hoch",
-    "critical": "Kritisch"
-  },
-  "comment": {
-    "commentId": "Kommentar Id",
-    "title": "Titel",
-    "description": "Beschreibung",
-    "relatedFindings": "Verbundene Funde",
-    "add": "Kommentar hinzufügen",
-    "add.finding": "Fund hinzufügen",
-    "no.comments": "Keine Kommentare verfügbar",
-    "no.relatedFindings": "Nicht verbunden mit einem Fund",
-    "relatedFindingsPlaceholder": "Fund auswählen",
-    "noFindingsInObjectivePlaceholder": "Ziel hat keine Befunde, auf die es sich beziehen könnte.",
-    "create": {
-      "header": "Neuen Kommentar erstellen"
-    },
-    "edit": {
-      "header": "Kommentar editieren"
-    },
-    "delete": {
-      "title": "Kommentar löschen",
-      "key": "Möchten Sie den Kommentar \"{{name}}\" unwiderruflich löschen?"
-    },
-    "title.label": "Kommentartitel",
-    "description.label": "Beschreibung des Kommentars",
-    "relatedFindings.label": "Verbundene Funde",
-    "validationMessage": {
-      "titleRequired": "Titel ist erforderlich.",
-      "descriptionRequired": "Beschreibung ist erforderlich.",
-      "relatedFindings": "Verwandte Funde erforderlich."
-    },
-    "popup": {
-      "not.found": "Keine Kommentare gefunden",
-      "save.success": "Kommentar erfolgreich gespeichert",
-      "save.failed": "Kommentar konnte nicht gespeichert werden",
-      "update.success": "Kommentar erfolgreich aktualisiert",
-      "update.failed": "Kommentar konnte nicht aktualisiert werden",
-      "delete.success": "Kommentar erfolgreich gelöscht",
-      "delete.failed": "Kommentar konnte nicht gelöscht werden",
-      "not.available": "Kommentar ist nicht mehr verfügbar"
-    }
-  },
   "pentest": {
     "testId": "Nr.",
     "title": "Titel",
     "findings": "Funde",
     "comments": "Kommentare",
-    "findings&comments": "Funde & Kommentare",
     "status": "Status",
     "statusText": {
       "not_started": "Nicht angefangen",
       "disabled": "Deaktiviert",
       "open": "Offen",
-      "paused": "Pausiert",
-      "in_progress": "In Bearbeitung",
-      "completed": "Fertig"
-    },
-    "disable": {
-      "title": "Ziel deaktivieren",
-      "key": "Möchten Sie den Pentest \"{{name}}\" deaktivieren?"
-    },
-    "enable": {
-      "title": "Ziel aktivieren",
-      "key": "Möchten Sie den Pentest \"{{name}}\" aktivieren?"
-    },
-    "popup": {
-      "not.found": "Keine pentests gefunden",
-      "initial.save.success": "Initialer Pentest erfolgreich aufgesetzt",
-      "initial.save.failed": "Initialer Pentest konnte nicht aufgesetzt werden",
-      "save.success": "Pentest erfolgreich gespeichert",
-      "save.failed": "Pentest konnte nicht gespeichert werden",
-      "complete.success":  "Pentest erfolgreich vervollständigt",
-      "complete.failed": "Pentest konnte nicht vervollständigt werden",
-      "update.success": "Pentest erfolgreich aktualisiert",
-      "update.failed": "Pentest konnte nicht aktualisiert werden",
-      "delete.success": "Pentest erfolgreich gelöscht",
-      "delete.failed": "Pentest konnte nicht gelöscht werden",
-      "disable.success": "Ziel erfolgreich deaktiviert",
-      "disable.failed": "Ziel konnte nicht deaktiviert werden",
-      "enable.success": "Ziel erfolgreich aktiviert",
-      "enable.failed": "Ziel konnte nicht aktiviert werden"
+      "checked": "Geprüft",
+      "reported": "Gemeldet",
+      "under_review": "Unter Beurteilung",
+      "triaged": "Triagiert"
     },
     "info": {
       "001": "Nutze Suchmaschinenerkennung und -aufklärung für Informationslecks",
@@ -342,7 +93,7 @@
       "003": "Prüfe Webserver-Metadateien auf Informationslecks",
       "004": "Anwendungen auf dem Webserver auflisten",
       "005": "Prüfe Webseitenkommentare und Metadaten auf Informationslecks",
-      "006": "Identifizieren der Einstiegspunkte",
+      "006": "Einstiegspunkte für Identitätsanträge",
       "007": "Zuordnen von Ausführungspfade der Anwendung",
       "008": "Framework für Fingerabdruck-Webanwendungen",
       "009": "Fingerabdruck-Webanwendungen",
@@ -352,21 +103,20 @@
       "001": "Netzwerk-/Infrastrukturkonfiguration testen",
       "002": "Testen Sie die Konfiguration der Anwendungsplattform",
       "003": "Testen der Behandlung von Dateierweiterungen für vertrauliche Informationen",
-      "004": "Prüfen von Backups und Dateien für sensible Informationen",
+      "004": "Backup und nicht referenzierte Dateien für sensible Informationen",
       "005": "Aufzählen der Infrastruktur- und Anwendungsverwaltungsschnittstellen",
       "006": "HTTP-Methoden testen",
       "007": "Testen Sie HTTP Strict Transport Security",
-      "008": "Testen der domänenübergreifende RIA-Richtlinie",
-      "009": "Dateiberechtigung testen",
-      "010": "Test auf Subdomain-Übernahme",
-      "011": "Cloud-Speicher testen"
+      "008": "Testen der domänenübergreifende RIA-Richtlinie"
     },
     "ident": {
       "001": "Rollendefinitionen testen",
       "002": "Registrierungsprozess testen",
       "003": "Konto-Bereitstellungsprozess testen",
       "004": "Testen auf Kontoaufzählung und erratbares Benutzerkonto",
-      "005": "Test auf schwache oder nicht erzwungene Richtlinie für Benutzernamen"
+      "005": "Test auf schwache oder nicht erzwungene Richtlinie für Benutzernamen",
+      "006": "Testberechtigungen von Gast-/Schulungskonten",
+      "007": "Sperrung/Wiederaufnahme des Kontos testen"
     },
     "authn": {
       "001": "Testen auf Anmeldeinformationen, die über einen verschlüsselten Kanal transportiert werden",
@@ -394,49 +144,45 @@
       "005": "Prüfung auf Cross-Site-Request-Forgery",
       "006": "Testen der Abmeldefunktion",
       "007": "Testen der Sitzungszeitüberschreitung",
-      "008": "Testen auf Session-Puzzle",
-      "009": "Testen auf Session Hijacking"
+      "008": "Testen auf Session-Rätsel"
     },
     "inpval": {
-      "001": "Testen auf Reflected Cross-Site-Scripting",
-      "002": "Testen auf Stored Cross-Site-Scripting",
+      "001": "Testen auf reflektiertes Cross-Site-Scripting",
+      "002": "Testen auf konserviertes Cross Site Scripting",
       "003": "Testen auf HTTP-Verb-Manipulation",
       "004": "Prüfung auf HTTP-Parameterverschmutzung",
-      "005": "Testen auf SQL-Injection",
-      "005_1": "Oracle-Tests",
-      "005_2": "MySQL-Tests",
-      "005_3": "SQL Server-Tests",
-      "005_4": "Testen von PostgreSQL",
-      "005_5": "MS-Access-Tests",
-      "005_6": "Testen auf NoSQL-Injection",
-      "005_7": "Testen auf ORM-Injection",
-      "005_8": "Testen für Clientseite",
-      "006": "Testen auf LDAP-Injection",
-      "007": "Testen auf XML-Injection",
-      "008": "Prüfung auf SSI-Injection",
-      "009": "Testen auf XPath-Injection",
-      "010": "IMAP/SMTP-Injection",
-      "011": "Testen auf Code-Injection",
-      "011_1": "Testen der lokalen Dateieinbindung",
-      "011_2": "Testen der Remote-Dateieinbindung",
-      "012": "Testen auf Command Injection",
-      "013": "Testen auf Format-String-Injection",
-      "014": "Testen auf bestehende Schwachstellen",
-      "015": "Testen auf HTTP-Splitting/-Smuggling",
-      "016": "Testen auf eingehende HTTP-Anfragen",
-      "017": "Testen auf Host-Header-Injection",
-      "018": "Testen auf serverseitige Template-Injection",
-      "019": "Testen auf serverseitige Request Forgery"
+      "005": "N/A",
+      "006": "Testen auf SQL-Injection",
+      "006_1": "Oracle-Tests",
+      "006_2": "SQL Server-Tests",
+      "006_3": "Testen von PostgreSQL",
+      "006_4": "MS-Access-Tests",
+      "006_5": "Testen auf NoSQL-Injection",
+      "007": "Testen auf LDAP-Injection",
+      "008": "Prüfung auf ORM-Injection",
+      "009": "Testen auf XML-Injection",
+      "010": "Prüfung auf SSI-Injection",
+      "011": "Testen auf XPath-Injection",
+      "012": "IMAP/SMTP-Injection",
+      "013": "Testen auf Code-Injection",
+      "013_1": "Testen der lokalen Dateieinbindung",
+      "013_2": "Testen der Remote-Dateieinbindung",
+      "014": "Testen auf BefehlInjection",
+      "015": "Test auf Pufferüberlauf",
+      "015_1": "Test auf Heap-Überlauf",
+      "015_2": "Test auf Stack-Überlauf",
+      "015_3": "Testen auf Formatzeichenfolge",
+      "016": "Testen auf inkubierte Schwachstellen",
+      "017": "Testen auf HTTP-Splitting/-Schmuggel"
     },
     "err": {
       "001": "Analyse von Fehlercodes",
       "002": "Analyse von Stack-Traces"
     },
     "crypst": {
-      "001": "Testen auf schwache SSL/TLS-Chiffren, unzureichenden Transportschichtschutz",
+      "001": "Testen auf schwache SSL/TSL-Chiffren, unzureichenden Transportschichtschutz",
       "002": "Testen für Padding Oracle",
-      "003": "Prüfung auf sensible Informationen, die über unverschlüsselte Kanäle gesendet werden",
-      "004": "Testing auf Schwache Verschlüsselung"
+      "003": "Prüfung auf sensible Informationen, die über unverschlüsselte Kanäle gesendet werden"
     },
     "buslogic": {
       "001": "Testen Sie die Datenvalidierung der Geschäftslogik",
@@ -461,146 +207,21 @@
       "009": "Test auf Clickjacking",
       "010": "Testen von WebSockets",
       "011": "Testen von Web-Messaging",
-      "012": "Lokalen Speicher testen",
-      "013": "Testen auf Cross-Site-Script-Integration"
-    },
-    "api": {
-      "001": "Testen von GraphQL"
+      "012": "Lokalen Speicher testen"
     }
   },
-  "objectives": {
-    "info": {
-      "001": "Ziel ist es zu verstehen, welche sensiblen Design- und Konfigurationsinformationen der Anwendung, des Systems oder der Organisation direkt (auf der Website der Organisation) oder indirekt (auf der Website eines Drittanbieters) offengelegt werden.\n\n Es gibt direkte und indirekte Elemente der Suchmaschinenerkennung und -aufklärung.\n Direkte Methoden beziehen sich auf das Durchsuchen der Indizes und der zugehörigen Inhalte aus Caches.\n Indirekte Methoden beziehen sich auf das Sammeln vertraulicher Design- und Konfigurationsinformationen durch das Durchsuchen von Foren, Newsgroups und Ausschreibungswebsites.\n\n Verwenden Sie eine Suchmaschine, um nach Folgendem zu suchen:\n• Netzwerkdiagramme und -konfigurationen\n• Archivierte Beiträge und E-Mails von Administratoren oder anderen wichtigen Mitarbeitern\n• Anmeldeverfahren und Benutzernamenformate\n• Benutzernamen und Passwörter\n• Inhalt der Fehlermeldung\n• Entwicklungs-, Test-, UAT- und Staging-Versionen der Website",
-      "002": "Das Ziel besteht darin, die Version und den Typ eines laufenden Webservers zu finden, um bekannte Schwachstellen und die geeigneten Exploits zu ermitteln, die während des Tests verwendet werden können.\n\n Webserver-Fingerprinting ist eine kritische Aufgabe für den Penetrationstester.\nDie Kenntnis der Version und des Typs eines laufenden Webservers ermöglicht es Testern, bekannte Schwachstellen und die geeigneten Exploits zu ermitteln, die während des Tests verwendet werden können.\n\n Es gibt heute mehrere verschiedene Anbieter und Versionen von Webservern auf dem Markt. Die Kenntnis des Typs des getesteten Webservers hilft erheblich beim Testprozess und kann auch den Verlauf des Tests verändern. Die einfachste und grundlegendste Art, einen Webserver zu identifizieren, besteht darin, sich das Serverfeld im HTTP-Antwortheader anzusehen.\n\n Indem der Tester weiß, wie jeder Webservertyp auf bestimmte Befehle reagiert, und diese Informationen in einer Fingerprint-Datenbank des Webservers speichert, kann ein Penetrationstester diese Befehle an den Webserver senden, die Antwort analysieren und sie mit der Datenbank bekannter Signaturen vergleichen.",
-      "003": "Das Ziel hier ist, die robots.txt-Datei auf Informationslecks des Verzeichnisses oder der Ordnerpfade der Webanwendung zu überprüfen.\n\n 1. Informationsverlust des Verzeichnisses oder der Ordnerpfade der Webanwendung.\n 2. Erstellen Sie die Liste der Verzeichnisse, die von Spiders, Robots oder Crawlern vermieden werden sollen.\n\n Darüber hinaus kann die Liste der Verzeichnisse, die von Spidern, Robots oder Crawlern vermieden werden sollen, auch als Abhängigkeit für Map execution paths durch die Anwendung erstellt werden.\n Webspider, Robots oder Crawler rufen eine Webseite ab und durchlaufen dann rekursiv Hyperlinks, um weitere Webinhalte abzurufen. Ihr akzeptiertes Verhalten wird durch das Robots Exclusion Protocol der robots.txt-Datei im Web-Root-Verzeichnis angegeben.",
-      "004": "Das Ziel besteht darin, die Anwendungen innerhalb des Gültigkeitsbereichs aufzuzählen, die auf einem Webserver vorhanden sind.\n\n Viele Anwendungen haben bekannte Schwachstellen und bekannte Angriffsstrategien, die ausgenutzt werden können, um eine Fernsteuerung zu erlangen oder Daten auszunutzen. Außerdem sind viele Anwendungen oft falsch konfiguriert oder werden nicht aktualisiert.\n Die Erkennung von Webanwendungen ist ein Prozess, der darauf abzielt, Webanwendungen in einer bestimmten Infrastruktur zu identifizieren. Letzteres wird normalerweise als eine Reihe von IP-Adressen (möglicherweise ein Netzblock) angegeben, kann aber auch aus einer Reihe symbolischer DNS-Namen oder einer Mischung aus beiden bestehen.",
-      "005": "Ziel ist es, Webseitenkommentare und Metadaten zu überprüfen, um die Anwendung besser zu verstehen und Informationslecks zu finden.\n\n HTML-Kommentare werden häufig von den Entwicklern verwendet, um Debugging-Informationen über die Anwendung einzufügen. Manchmal vergessen sie die Kommentare.\n\n Überprüfen Sie den HTML-Quellcode auf Kommentare mit vertraulichen Informationen, die dem Angreifer helfen können, mehr Einblick in die Anwendung zu gewinnen. Dies können SQL-Code, Benutzernamen und Passwörter, interne IP-Adressen oder Debugging-Informationen sein.",
-      "006": "Ziel ist es zu verstehen, wie Anfragen gebildet werden und typische Antworten der Anwendung.\n\n Die Aufzählung der Anwendung und ihrer Angriffsfläche ist ein wichtiger Vorläufer bevor gründliche Tests durchgeführt werden können, da es dem Tester ermöglicht, wahrscheinliche Schwachstellen zu identifizieren. Dies soll dazu beitragen, Bereiche innerhalb der Anwendung zu identifizieren und zu kartieren, die untersucht werden sollten, sobald die Aufzählung und Kartierung abgeschlossen sind.\n\n  Achten Sie beim Durchlaufen der Anwendung besonders auf alle HTTP-Anforderungen (GET- und POST-Methoden, auch bekannt als Verben) sowie auf alle Parameter und Formularfelder, die an die Anwendung übergeben werden.\n Beachten Sie außerdem alle interessanten Parameter in der URL, den benutzerdefinierten Headern oder dem Text der Anfragen/Antworten und speichern Sie sie.\n Sobald jeder Bereich der Anwendung abgebildet ist, gehen Sie die Anwendung durch und testen Sie jeden der identifizierten Bereiche und machen Sie sich Notizen darüber, was funktioniert hat und was nicht.",
-      "007": "Ziel ist es, die Zielanwendung abzubilden und die wichtigsten Arbeitsabläufe zu verstehen.\n\n Bevor Sie mit Sicherheitstests beginnen, ist es von größter Bedeutung, die Struktur der Anwendung zu verstehen.\nEs gibt mehrere Möglichkeiten, an das Testen und Messen der Codeabdeckung heranzugehen:\n\n 1. Pfad:\n Testen Sie jeden der Pfade durch eine Anwendung, die kombinatorische und Grenzwertanalysetests für jeden Entscheidungspfad umfasst. Während dieser Ansatz Gründlichkeit bietet, wächst die Anzahl der testbaren Pfade exponentiell mit jedem Entscheidungszweig.\n\n 2. Datenfluss (oder Taint-Analyse):\n Testet die Zuweisung von Variablen durch externe Interaktion (normalerweise Benutzer).\n Konzentriert sich auf die Abbildung des Flusses, der Transformation und der Verwendung von Daten in einer Anwendung.\n\n 3. Rennen:\n Testet mehrere gleichzeitige Instanzen der Anwendung, die dieselben Daten manipulieren.",
-      "008": "Ziel ist es, den Typ des verwendeten Web-Frameworks zu definieren, um ein besseres Verständnis der Sicherheitstestmethodik zu erlangen.\n\n Die Art des Frameworks zu kennen, kann automatisch einen großen Vorteil bringen, wenn ein solches Framework bereits vom Penetrationstester getestet wurde. Nicht nur die bekannten Schwachstellen in ungepatchten Versionen, sondern auch spezifische Fehlkonfigurationen im Framework und der bekannten Dateistruktur machen den Fingerprinting-Prozess so wichtig.\n\n Es gibt mehrere gängige Orte, an denen Sie nachsehen können, um den aktuellen Rahmen zu definieren:\n• HTTP-Header\n• Cookies\n• HTML-Quellcode\n• Bestimmte Dateien und Ordner",
-      "009": "Ziel ist es, die Webanwendung und -version zu identifizieren, um bekannte Schwachstellen und die geeigneten Exploits zu ermitteln, die während des Tests verwendet werden können.\n\n Bei der großen Anzahl von Free- und Open-Source-Softwareprojekten, die weltweit aktiv entwickelt und eingesetzt werden, ist es sehr wahrscheinlich, dass ein Anwendungssicherheitstest auf eine Zielseite trifft, die ganz oder teilweise von diesen bekannten Anwendungen abhängig ist (z. B. Wordpress, phpBB, Mediawiki usw.).\n\nDie Kenntnis der zu testenden Webanwendungskomponenten hilft erheblich beim Testprozess.\nDiese wohlbekannten Webanwendungen haben bekannte HTML-Kopfzeilen, Cookies und Verzeichnisstrukturen, die aufgezählt werden können, um die Anwendung zu identifizieren.",
-      "010": "Die Anwendungsarchitektur muss durch einige Tests abgebildet werden, um festzustellen, welche verschiedenen Komponenten zum Erstellen der Webanwendung verwendet werden.\n\n In kleinen Setups, wie z. B. einer einfachen CGI-basierten Anwendung, kann ein einzelner Server verwendet werden, auf dem der Webserver ausgeführt wird, der die C-, Perl- oder Shell-CGIs-Anwendung und möglicherweise auch den Authentifizierungsmechanismus ausführt.\n Bei komplexeren Setups können mehrere Server beteiligt sein. Dazu können ein Reverse-Proxy, ein Frontend-Webserver, ein Anwendungsserver und ein Datenbankserver oder LDAP-Server gehören.\nJeder dieser Server wird für unterschiedliche Zwecke verwendet und kann sogar in verschiedene Netzwerke mit Firewalls dazwischen (DMZs) unterteilt sein.\n\n Darüber hinaus ist das Verständnis der bereitgestellten Konfiguration des Servers, auf dem die Webanwendung gehostet wird, fast so wichtig wie das Testen der Anwendungssicherheit selbst."
-    },
-    "config": {
-      "001": "Die intrinsische Komplexität einer vernetzten und heterogenen Webserver-Infrastruktur, die Hunderte von Webanwendungen umfassen kann, macht das Konfigurationsmanagement und die Überprüfung zu einem grundlegenden Schritt beim Testen und Bereitstellen jeder einzelnen Anwendung. Es braucht nur eine einzige Schwachstelle, um die Sicherheit der gesamten Infrastruktur zu untergraben. Um diese Probleme anzugehen, ist es von größter Bedeutung, eine gründliche Überprüfung der Konfiguration und bekannter Sicherheitsprobleme durchzuführen.\n\nZum Testen der Konfigurationsmanagement-Infrastruktur müssen die folgenden Schritte ausgeführt werden:\n\nSchritt 1:\n Die verschiedenen Elemente, aus denen die Infrastruktur besteht, müssen bestimmt werden, um zu verstehen, wie sie mit einer Webanwendung interagieren und wie sie sich auf deren Sicherheit auswirken.\n\nSchritt 2:\n Alle Elemente der Infrastruktur müssen überprüft werden, um sicherzustellen, dass sie keine bekannten Schwachstellen enthalten.\n\nSchritt 3:\n Es muss eine Überprüfung der Verwaltungsinstrumente durchgeführt werden, die zur Pflege aller verschiedenen Elemente verwendet werden.\n\nSchritt 4:\n Die Authentifizierungssysteme müssen überprüft werden, um sicherzustellen, dass sie die Anforderungen der Anwendung erfüllen und nicht von externen Benutzern manipuliert werden können, um den Zugriff zu nutzen.\n\nSchritt 5:\n Eine Liste definierter Ports, die für die Anwendung erforderlich sind, sollte gepflegt und unter Änderungskontrolle gehalten werden.",
-      "002": "Die Überprüfung und das Testen der Konfiguration ist eine kritische Aufgabe beim Erstellen und Verwalten einer Architektur. Dies liegt daran, dass viele verschiedene Systeme normalerweise mit generischen Konfigurationen bereitgestellt werden, die möglicherweise nicht für die Aufgabe geeignet sind, die sie an dem spezifischen Standort ausführen, an dem sie installiert sind.\n\n Während die typische Web- und Anwendungsserverinstallation viele Funktionen (wie Anwendungsbeispiele, Dokumentation, Testseiten) enthält, sollte das, was nicht unbedingt erforderlich ist, vor der Bereitstellung entfernt werden, um eine Ausnutzung nach der Installation zu vermeiden.\n\nCGI-Scanner enthalten eine detaillierte Liste bekannter Dateien und Verzeichnisbeispiele, die von verschiedenen Web- oder Anwendungsservern bereitgestellt werden.\nAußerdem enthalten Ereignisprotokolle oft Daten, die für einen Angreifer nützlich sind (Information Leakage) oder direkt in Exploits verwendet werden können.",
-      "003": "Dateierweiterungen werden häufig in Webservern verwendet, um einfach zu bestimmen, welche Technologien, Sprachen und Plugins verwendet werden müssen, um die Webanforderung zu erfüllen.\nObwohl dieses Verhalten mit RFCs und Webstandards übereinstimmt, liefert die Verwendung von Standarddateierweiterungen dem Penetrationstester nützliche Informationen über die zugrunde liegenden Technologien, die in einer Web-Appliance verwendet werden.\n\n Die Feststellung, wie Webserver Anfragen verarbeiten, die Dateien mit unterschiedlichen Erweiterungen entsprechen, kann helfen, das Verhalten von Webservern in Abhängigkeit von der Art der Dateien, auf die zugegriffen wird, zu verstehen.\n\nDie folgenden Dateierweiterungen sollten niemals von einem Webserver zurückgegeben werden, da sie sich auf Dateien beziehen, die möglicherweise vertrauliche Informationen enthalten:\n • .asa \n• .inc\n\n Die folgenden Dateierweiterungen beziehen sich auf Dateien, die beim Zugriff entweder angezeigt oder vom Browser heruntergeladen werden.\n Daher müssen Dateien mit diesen Erweiterungen überprüft werden, um sicherzustellen, dass sie tatsächlich geliefert werden sollen:\n• .zip, .tar, .gz, .tgz, .rar, ...: (Komprimierte) Archivdateien\n• .java: Kein Grund, Zugriff auf Java-Quelldateien zu gewähren\n• .txt: Textdateien\n• .pdf: PDF-Dokumente\n• .doc, .rtf, .xls, .ppt, ...: Office-Dokumente\n• .bak, .old und andere Erweiterungen, die auf Sicherungsdateien hinweisen\n\n Um Dateien mit bestimmten Erweiterungen zu identifizieren, kann eine Mischung von Techniken eingesetzt werden.\nDiese Techniken können Vulnerability Scanners, Spidering- und Mirroring-Tools, die manuelle Überprüfung der Anwendung oder Abfragen von Suchmaschinen umfassen.",
-      "004": "Eine wichtige Schwachstellenquelle sind Dateien, die nichts mit der Anwendung zu tun haben, aber als Folge der Bearbeitung von Anwendungsdateien oder nach dem Erstellen von Sicherungskopien im laufenden Betrieb oder durch das Belassen alter Dateien im Webbaum oder ohne Referenz erstellt wurden Dateien.\n\n Theoretisch sollte die Untersuchung von Hand durchgeführt werden, um gründlich zu sein. Da jedoch in den meisten Fällen Kopien von Dateien oder Backup-Dateien unter Verwendung der gleichen Namenskonventionen erstellt werden, kann die Suche einfach per Skript durchgeführt werden.",
-      "005": "Administratorschnittstellen können in der Anwendung oder auf dem Anwendungsserver vorhanden sein, um bestimmten Benutzern zu ermöglichen, privilegierte Aktivitäten auf der Website durchzuführen. Es sollten Tests durchgeführt werden, um festzustellen, ob und wie diese privilegierte Funktionalität von einem nicht autorisierten oder normalen Benutzer abgerufen werden kann.\n\nEine Anwendung erfordert möglicherweise eine Administratorschnittstelle, um einem privilegierten Benutzer den Zugriff auf Funktionen zu ermöglichen, die Änderungen an der Funktionsweise der Site vornehmen können.\nSolche Änderungen können Folgendes umfassen:\n• Bereitstellung von Benutzerkonten\n• Website-Design und -Layout\n• Datenmanipulation\n• Konfigurationsänderungen\n\nIm Folgenden werden Vektoren beschrieben, die zum Testen auf das Vorhandensein von Verwaltungsschnittstellen verwendet werden können:\n• Verzeichnis- und Dateiaufzählung\n• Brute-Forcing-Tools wie THC-HYDRA\n• Kommentare und Links im Quellcode\n• Überprüfung der Server- und Anwendungsdokumentation\n• Öffentlich zugängliche Informationen (z. B. Standardpasswörter)\n• Alternativer Serverport\n• Manipulation von Parametern",
-      "006": "Um diesen Test durchzuführen, muss der Tester irgendwie herausfinden, welche HTTP-Methoden werden vom untersuchten Webserver unterstützt. Die HTTP-Methode OPTIONS bietet dem Tester am meisten direkter und effektiver Weg, dies zu tun. RFC 2616 besagt: „Die OPTIONS-Methode stellt eine Anfrage nach Informationen über die verfügbaren Kommunikationsoptionen in der Anfrage-/Antwortkette dar, die durch den Request-URI identifiziert wird“.\n\n Einige der HTTP-Methoden können potenziell ein Sicherheitsrisiko für eine Webanwendung darstellen, da sie es einem Angreifer ermöglichen, die auf dem Webserver gespeicherten Dateien zu ändern und in einigen Szenarien die Anmeldeinformationen legitimer Benutzer zu stehlen. Genauer gesagt, die Methoden, die deaktiviert werden sollten, sind die folgenden:\n• PUT: Ermöglicht dem Client, Dateien auf den Webserver hochzuladen\n• DELETE: Allwas-Client zum Löschen von Dateien vom Webserver\n• CONNECT: ermöglicht dem Client, den Webserver als Proxy zu verwenden\n• TRACE: Gibt an den Client zurück, was er an den Server gesendet hat",
-      "007": "Die HTTP Strict Transport Security (HSTS)-Funktion ermöglicht es einer Webanwendung, den Browser durch die Verwendung eines speziellen Antwortheaders darüber zu informieren, dass er niemals eine Verbindung zu den angegebenen Domänenservern über HTTP herstellen sollte.\n\n Der strenge HTTP-Transportsicherheitsheader verwendet zwei Anweisungen:\n• max-age\n• includeSubDomain\n\nDas Testen auf das Vorhandensein des HSTS-Headers kann durchgeführt werden, indem das Vorhandensein des HSTS-Headers in der Antwort des Servers in einem Interception-Proxy überprüft wird, oder indem curl verwendet wird.",
-      "008": "Rich Internet Applications (RIA) haben die crossdomain.xml-Richtliniendateien von Adobe übernommen, um einen kontrollierten domänenübergreifenden Zugriff auf Daten und Dienstnutzung mit Technologien wie Oracle Java, Silverlight und Adobe Flash zu ermöglichen. Daher kann eine Domäne den Fernzugriff auf ihre Dienste von einer anderen Domäne aus gewähren.\nOft sind die Richtliniendateien, die die Zugriffsbeschränkungen beschreiben, jedoch schlecht konfiguriert. Eine schlechte Konfiguration der Richtliniendateien ermöglicht Cross-Site Request Forgery-Angriffe.\n\n Um die Schwäche der RIA-Richtliniendatei zu testen, sollte der Tester versuchen, die Richtliniendateien crossdomain.xml und clientaccesspolicy.xml aus dem Stammverzeichnis der Anwendung und aus jedem gefundenen Ordner abzurufen.",
-      "009": "Wenn einer Ressource eine Berechtigungseinstellung zugewiesen wird, die einem größeren Spektrum an Akteuren als erforderlich Zugriff gewährt, kann dies zur Offenlegung vertraulicher Informationen oder zur Änderung dieser Ressource durch unbeabsichtigte Parteien führen. Dies ist besonders gefährlich, wenn die Ressource mit der Programmkonfiguration, der Ausführung oder vertraulichen Benutzerdaten zusammenhängt.\n\nEin klares Beispiel ist eine Ausführungsdatei, die von nicht autorisierten Benutzern ausgeführt werden kann. Ein weiteres Beispiel: Kontoinformationen oder ein Token-Wert für den Zugriff auf eine API – was zunehmend in modernen Webdiensten oder Microservices vorkommt – können in einer Konfigurationsdatei gespeichert werden, deren Berechtigungen bei der Installation standardmäßig auf weltweit lesbar eingestellt sind. Solche sensiblen Daten können durch interne böswillige Akteure des Hosts oder durch einen Remote-Angreifer offengelegt werden, der den Dienst durch andere Schwachstellen kompromittiert, sich aber nur normale Benutzerrechte verschafft hat.\n\nZu den Dateien und Verzeichnissen, die einen Dateiberechtigungstest erfordern, gehören unter anderem:\n• Webdateien/Verzeichnis\n• Konfigurationsdateien/Verzeichnis\n• Sensible Dateien (verschlüsselte Daten, Passwort, Schlüssel)/Verzeichnis\n• Protokolldateien (Sicherheitsprotokolle, Betriebsprotokolle, Administratorprotokolle)/Verzeichnis\n• Ausführbare Dateien (Skripte, EXE, JAR, Klasse, PHP, ASP)/Verzeichnis\n• Datenbankdateien/Verzeichnis\n• Temporäre Dateien/Verzeichnis\n• Dateien/Verzeichnis hochladen",
-      "010": "Eine erfolgreiche Ausnutzung dieser Art von Schwachstelle ermöglicht es einem Gegner, die Subdomain des Opfers zu beanspruchen und die Kontrolle über sie zu übernehmen.\nDieser Angriff beruht auf Folgendem:\n\n1. Der externe DNS-Server-Subdomain-Eintrag des Opfers ist so konfiguriert, dass er auf eine nicht vorhandene oder nicht aktive Ressource/einen externen Dienst/Endpunkt verweist. Die Verbreitung von XaaS-Produkten (Anything as a Service) und öffentlichen Cloud-Diensten bietet viele potenzielle Ziele, die es zu berücksichtigen gilt.\n\n2. Der Dienstanbieter, der die Ressource/den externen Dienst/den Endpunkt hostet, führt die Überprüfung des Subdomain-Eigentums nicht ordnungsgemäß durch.\n\nWenn die Subdomain-Übernahme erfolgreich ist, sind vielfältige Angriffe möglich (Bereitstellung bösartiger Inhalte, Phishing, Diebstahl von Benutzersitzungscookies, Anmeldeinformationen usw.). Diese Schwachstelle könnte für eine Vielzahl von DNS-Ressourceneinträgen ausgenutzt werden, darunter: A, CNAME, MX, NS, TXT usw. In Bezug auf die Angriffsschwere hat eine NS-Subdomänenübernahme (wenn auch weniger wahrscheinlich) die größte Auswirkung, da ein erfolgreicher Angriff dies könnte Dies führt zu vollständiger Kontrolle über die gesamte DNS-Zone und die Domäne des Opfers.\n\nTestziele:\n• Zählen Sie alle möglichen Domänen auf (vorherige und aktuelle).\n• Identifizieren Sie vergessene oder falsch konfigurierte Domänen",
-      "011": "Cloud-Speicherdienste ermöglichen Webanwendungen und -diensten das Speichern und Zugreifen auf Objekte im Speicherdienst. Eine unsachgemäße Konfiguration der Zugriffskontrolle kann jedoch dazu führen, dass vertrauliche Informationen offengelegt werden, Daten manipuliert werden oder unbefugter Zugriff erfolgt.\n\nEin bekanntes Beispiel ist die Fehlkonfiguration eines Amazon S3-Buckets, obwohl auch die anderen Cloud-Speicherdienste ähnlichen Risiken ausgesetzt sein können. Standardmäßig sind alle S3-Buckets privat und können nur von Benutzern aufgerufen werden, denen explizit Zugriff gewährt wurde. Benutzer können öffentlichen Zugriff sowohl auf den Bucket selbst als auch auf einzelne in diesem Bucket gespeicherte Objekte gewähren. Dies kann dazu führen, dass ein unbefugter Benutzer neue Dateien hochladen, gespeicherte Dateien ändern oder lesen kann.\n\nIdentifizieren Sie zunächst die URL für den Zugriff auf die Daten im Speicherdienst und ziehen Sie dann die folgenden Tests in Betracht:\n• Die nicht autorisierten Daten lesen\n• Laden Sie eine neue beliebige Datei hoch\n\nTestziele:\n• Stellen Sie sicher, dass die Zugriffskontrollkonfiguration für die Speicherdienste ordnungsgemäß vorhanden ist"
-    },
-    "ident": {
-      "001": "Das Ziel besteht darin, die in der Anwendung definierten Systemrollen zu validieren, jedes System und jede Geschäftsrolle ausreichend zu definieren und zu trennen, um den angemessenen Zugriff auf Systemfunktionen und -informationen zu verwalten.\n\nAnwendungen verfügen über verschiedene Arten von Funktionalitäten und Diensten und diese erfordern Zugriffsberechtigungen, die auf den Bedürfnissen des Benutzers basieren. Dieser Benutzer könnte sein:\n• ein Administrator, der die Anwendungsfunktionen verwaltet.\n• ein Wirtschaftsprüfer, der die Antragstransaktionen überprüft und einen detaillierten Bericht erstellt.\n• ein Support-Techniker, der Kunden beim Debuggen und Beheben von Problemen in ihren Konten unterstützt.\n• ein Kunde, der mit der Anwendung interagiert und von deren Diensten profitiert.\n\nIn vertrauenswürdigeren Umgebungen, in denen die Vertraulichkeit keine entscheidende Rolle spielt, können sanftere Kontrollen wie Anwendungsworkflow und Audit-Protokollierung die Anforderungen an die Datenintegrität unterstützen, ohne den Benutzerzugriff auf Funktionen einzuschränken. Entwickeln Sie mit oder ohne Hilfe der Systementwickler oder Administratoren eine Rollen-Berechtigungs-Matrix. Die Matrix sollte alle Rollen auflisten, die bereitgestellt werden können, und die zulässigen Berechtigungen untersuchen.\n\nTestziele:\n• Identifizieren und dokumentieren Sie die von der Anwendung verwendeten Rollen.\n• Versuchen Sie, eine andere Rolle zu wechseln, zu ändern oder darauf zuzugreifen.\n• Überprüfen Sie die Granularität der Rollen und die Anforderungen hinter den erteilten Berechtigungen",
-      "002": "Einige Websites bieten einen Benutzerregistrierungsprozess an, der die Bereitstellung des Systemzugriffs für Benutzer automatisiert (oder halbautomatisiert). Die Identitätsanforderungen für den Zugriff variieren von positiver Identifizierung bis zu überhaupt keiner, abhängig von den Sicherheitsanforderungen des Systems.\n\n Schritt 1:\n Stellen Sie sicher, dass die Identitätsanforderungen für die Benutzerregistrierung mit den Geschäfts- und Sicherheitsanforderungen abgestimmt sind.\n\n Schritt 2:\n Bestätigen Sie den Registrierungsprozess.\n\n Stellen Sie sicher, dass die Identitätsanforderungen für die Benutzerregistrierung mit den Geschäfts- und Sicherheitsanforderungen abgestimmt sind:\n• Kann sich jeder für den Zugang registrieren?\n• Werden Registrierungen von einem Menschen überprüft?\n• Kann sich dieselbe Person oder Identität mehrmals registrieren?\n• Können sich Benutzer für verschiedene Rollen oder Berechtigungen registrieren?\n• Welcher Identitätsnachweis ist für eine Anmeldung erforderlich?\n• Werden registrierte Identitäten verifiziert?\n\n Bestätigen Sie den Registrierungsprozess:\n • Können Identitätsinformationen leicht gefälscht oder gefälscht werden?\n • Kann der Austausch von Identitätsinformationen manipuliert werden?",
-      "003": "Überprüfen Sie, welche Konten andere Konten bereitstellen können und welchen Typs.\n\nDie Bereitstellung von Konten bietet einem Angreifer die Möglichkeit, ein gültiges Konto zu erstellen, ohne den ordnungsgemäßen Identifizierungs- und Autorisierungsprozess anzuwenden.\n\nSo testen Sie\n\nBestimmen Sie, welche Rollen Benutzer bereitstellen können und welche Art von Konten sie bereitstellen können:\n• Gibt es eine Überprüfung, Prüfung und Autorisierung von Bereitstellungsanfragen?\n• Gibt es eine Überprüfung, Prüfung und Autorisierung von De-Provisioning-Anfragen?\n• Kann ein Administrator andere Administratoren oder nur Benutzer bereitstellen?\n• Kann ein Administrator oder ein anderer Benutzer Konten mit Berechtigungen versehen, die über ihre eigenen hinausgehen?\n• Kann ein Administrator oder Benutzer die Bereitstellung selbst aufheben?\n• Wie werden die Dateien oder Ressourcen verwaltet, die dem deprovisionierten Benutzer gehören? Werden sie gelöscht? Wird der Zugriff übertragen?",
-      "004": "Der Zweck dieses Tests besteht darin, zu überprüfen, ob es möglich ist, durch Interaktion mit dem Authentifizierungsmechanismus der Anwendung einen Satz gültiger Benutzernamen zu sammeln. Dieser Test ist für Brute-Force-Tests nützlich, bei denen der Tester überprüft, ob es bei einem gültigen Benutzernamen möglich ist, das entsprechende Passwort zu finden.\n\nIn manchen Fällen wird eine Meldung empfangen, die Aufschluss darüber gibt, ob die angegebenen Anmeldeinformationen falsch sind, weil ein ungültiger Benutzername oder ein ungültiges Passwort verwendet wurde. Manchmal können Tester die vorhandenen Benutzer aufzählen, indem sie einen Benutzernamen und ein leeres Passwort senden. Wenn die Anwendung angreifbar ist, erhält der Tester eine Antwortnachricht, die direkt oder indirekt einige Informationen enthält, die für die Enumeration von Benutzern nützlich sind.\n\nTestziele\n• Überprüfen Sie Prozesse, die sich auf die Benutzeridentifizierung beziehen (z. B. Registrierung, Anmeldung usw.).\n• Erfassen Sie Benutzer nach Möglichkeit mithilfe einer Antwortanalyse",
-      "005": "Das Ziel besteht darin, festzustellen, ob eine konsistente Kontonamenstruktur die Anwendung anfällig für die Kontoaufzählung macht. Stellen Sie fest, ob die Fehlermeldungen der Anwendung eine Kontoaufzählung zulassen.\n\nTestziele\n• Stellen Sie fest, ob eine konsistente Kontonamenstruktur die Anwendung anfällig für die Kontoaufzählung macht.\n• Stellen Sie fest, ob die Fehlermeldungen der Anwendung eine Kontoaufzählung zulassen.\n\nBenutzerkontonamen sind häufig stark strukturiert (z. B. lautet der Kontoname von Joe Bloggs jbloggs und der Kontoname von Fred Nurk lautet fnurks), und gültige Kontonamen können leicht erraten werden.\n\nSo testen Sie\n• Bestimmen Sie die Struktur von Kontonamen.\n• Bewerten Sie die Reaktion der Anwendung auf gültige und ungültige Kontonamen.\n• Verwenden Sie unterschiedliche Antworten auf gültige und ungültige Kontonamen, um gültige Kontonamen aufzulisten.\n• Verwenden Sie Kontonamenwörterbücher, um gültige Kontonamen aufzulisten."
-    },
-    "authn": {
-      "001": "Die Analyse konzentriert sich einfach darauf, zu verstehen, ob die Daten unverschlüsselt vom Webbrowser zum Server übertragen werden oder ob die Webanwendung mithilfe eines Protokolls wie HTTPS die geeigneten Sicherheitsmaßnahmen ergreift.\n\n Das Testen auf den Transport von Anmeldeinformationen bedeutet, dass überprüft wird, ob die des Benutzers\nAuthentifizierungsdaten werden über einen verschlüsselten Kanal übertragen, um zu verhindern, dass sie von böswilligen Benutzern abgefangen werden.\n\n Sie können WebScarab oder einen beliebigen Web-Proxy verwenden, um Paket-Header zu erfassen und zu untersuchen.\n Überprüfen Sie, ob HTTPS in jeder sensiblen Anfrage verwendet wird, wie z. B. in Anmeldeseiten, um zu verhindern, dass unbefugte Benutzer die Daten abfangen.",
-      "002": "Häufig sind Anwendungen nach der Installation nicht ordnungsgemäß konfiguriert, und die für die anfängliche Authentifizierung und Konfiguration bereitgestellten Standardanmeldeinformationen werden nie geändert.\n\n Wenn Sie eine Anwendungsschnittstelle identifiziert haben, beispielsweise eine Cisco-Router-Webschnittstelle oder ein Weblogic-Administratorportal, prüfen Sie, ob die bekannten Benutzernamen und Kennwörter für diese Geräte nicht zu einer erfolgreichen Authentifizierung führen. Dazu können Sie die Dokumentation des Herstellers konsultieren oder, viel einfacher, allgemeine Anmeldeinformationen mithilfe einer Suchmaschine oder einer der im Abschnitt „Referenz“ aufgeführten Websites oder Tools finden.\n\n Wenn wir mit Anwendungen konfrontiert werden, für die wir keine Liste mit Standard- und allgemeinen Benutzerkonten haben, können wir versuchen, gültige Standardanmeldeinformationen zu erraten.\n Viele Anwendungen haben ausführliche Fehlermeldungen, die die Site-Benutzer über die Gültigkeit der eingegebenen Benutzernamen informieren. Diese Informationen sind beim Testen auf standardmäßige oder erratbare Benutzerkonten hilfreich.\n\nDa diese Arten von Standardanmeldeinformationen häufig an Administratorkonten gebunden sind, können Sie zunächst die folgenden Benutzernamen ausprobieren: \n• admin \n• administrator \n• root \n• system \n• guest \n• operator \n• super",
-      "003": "Kontosperrmechanismen werden verwendet, um Brute-Force-Angriffe zum Erraten von Passwörtern abzuschwächen. Konten werden in der Regel nach 3 bis 5 erfolglosen Anmeldeversuchen gesperrt und können erst nach einem festgelegten Zeitraum über einen Self-Service-Entsperrmechanismus oder den Eingriff eines Administrators entsperrt werden.\n\n Um die Stärke von Sperrmechanismen zu testen, benötigen Sie in der Regel Zugriff auf ein Konto, das Sie sperren möchten oder sich leisten können:\n\n Schritt 1:\n Bewerten Sie die Fähigkeit des Kontosperrmechanismus, das Erraten von Brute-Force-Passwörtern zu mindern.\n\n Schritt 2:\nBewerten Sie die Widerstandsfähigkeit des Entsperrmechanismus gegen das unbefugte Entsperren von Konten.\n\n Ohne einen starken Sperrmechanismus ist die Anwendung möglicherweise anfällig für Brute-Force-Angriffe. Nach einem erfolgreichen Brute-Force-Angriff könnte ein böswilliger Benutzer Zugriff auf Folgendes haben:\n• Vertrauliche Informationen oder Daten\n• Administratoroberflächen\n• Möglichkeiten für weitere Angriffe",
-      "004": "Während die meisten Anwendungen eine Authentifizierung erfordern, um Zugriff auf private Informationen zu erhalten oder Aufgaben auszuführen, ist nicht jede Authentifizierungsmethode in der Lage, angemessene Sicherheit zu bieten.\n\n Es gibt mehrere Methoden zum Umgehen des Authentifizierungsschemas, das von einer Webanwendung verwendet wird:\n• Direkter Seitenaufruf (Forced Browsing)\n• Parameteränderung\n• Session-ID-Vorhersage\n• SQL-Injektion",
-      "005": "Browser fragen einen Benutzer manchmal, ob er sich das soeben eingegebene Passwort merken möchte.\n\n Das Speichern von Passwörtern im Browser ist nicht nur für Endbenutzer, sondern auch für Angreifer praktisch. Wenn ein Angreifer Zugriff auf den Browser des Opfers erlangen kann (z. B. XSS-Angriff), kann er die gespeicherten Passwörter abrufen.\n Wenn benutzerdefinierte „Remember Me“-Funktionen eingerichtet werden, können außerdem Schwachstellen bei der Speicherung des Tokens auf dem Client-PC die Passwörter der Benutzer offenlegen.\n\n Stellen Sie sicher, dass keine Zugangsdaten im Klartext gespeichert oder in verschlüsselter oder verschlüsselter Form in Cookies leicht abrufbar sind:\n• Suchen Sie nach Passwörtern, die in Cookies gespeichert sind\n• Untersuchen Sie den Hashing-Mechanismus\n• Stellen Sie sicher, dass Anmeldeinformationen nur während der Anmeldung gesendet werden\n• Berücksichtigen Sie sensible Formularfelder",
-      "006": "Browser können Informationen für Caching- und Verlaufszwecke speichern. Caching dient der Leistungssteigerung, sodass zuvor angezeigte Informationen nicht erneut heruntergeladen werden müssen.\n Wenn dem Benutzer sensible Informationen angezeigt werden, können diese Informationen zu Cache- oder Verlaufszwecken gespeichert und daher durch Überprüfen des Cache des Browsers oder durch einfaches Drücken der Schaltfläche „Zurück“ des Browsers abgerufen werden.\n\n Technisch gesehen ist die Schaltfläche „Zurück“ ein Verlauf und kein Cache. Der Cache und der Verlauf sind zwei verschiedene Entitäten. Sie teilen jedoch die gleiche Schwäche, zuvor angezeigte sensible Informationen zu präsentieren.\n\nDie Schaltfläche „Zurück“ kann daran gehindert werden, sensible Daten anzuzeigen.\nDies kann erfolgen durch:\n• Bereitstellung der Seite über HTTPS.\n• Einstellung Cache-Control: must-re-validate",
-      "007": "Der am weitesten verbreitete und am einfachsten zu verwaltende Authentifizierungsmechanismus ist ein statisches Passwort. Es wird bedauert, dass die gängigsten Passwörter immer noch sind: 123456, Passwort und qwerty.\n\nBestimmen Sie den Widerstand der Anwendung gegen Brute-Force-Passworterraten mithilfe verfügbarer Passwortwörterbücher, indem Sie die Anforderungen an Länge, Komplexität, Wiederverwendung und Alterung von Passwörtern bewerten.\n\n Schritt 1:\n Welche Zeichen sind in einem Passwort erlaubt und welche verboten?\nMuss der Benutzer Zeichen aus unterschiedlichen Zeichensätzen wie Klein- und Großbuchstaben, Ziffern und Sonderzeichen verwenden?\n\n Schritt 2:\n Wie oft kann ein Benutzer sein Passwort ändern?\nWie schnell kann ein Benutzer sein Passwort nach einer vorherigen Änderung ändern?\n Benutzer können die Anforderungen des Passwortverlaufs umgehen, indem sie ihr Passwort fünfmal hintereinander ändern.\n\n Schritt 3:\n Wann muss ein Benutzer sein Passwort ändern?\nNach 90 Tagen?\nNach Kontosperrung wegen übermäßiger Anmeldeversuche?\n\n Schritt 4:\n Wie oft kann ein Benutzer ein Passwort wiederverwenden?\n Verwaltet die Anwendung einen Verlauf der zuvor verwendeten 8 Passwörter des Benutzers?\n\n Schritt 5:\n Wie unterschiedlich muss das nächste Passwort vom letzten Passwort sein?\n\n Schritt 6:\nWird der Benutzer daran gehindert, seinen Benutzernamen oder andere Kontoinformationen (z. B. Vor- oder Nachname) im Passwort zu verwenden?",
-      "008": "Oft als „geheime“ Fragen und Antworten bezeichnet, werden Sicherheitsfragen und -antworten oft verwendet, um vergessene Passwörter wiederherzustellen, oder als zusätzliche Sicherheit zusätzlich zum Passwort.\n\n Sie werden normalerweise bei der Kontoerstellung generiert und erfordern, dass der Benutzer aus einigen vorgenerierten Fragen eine Auswahl trifft und eine entsprechende Antwort liefert. Sie können dem Benutzer ermöglichen, seine eigenen Frage-Antwort-Paare zu generieren.\n Beide Methoden sind anfällig für Unsicherheiten. Im Idealfall sollten Sicherheitsfragen Antworten generieren, die nur dem Benutzer bekannt und nicht erratbar oder auffindbar sind.\n\n Der Schlüssel zum erfolgreichen Ausnutzen und Umgehen eines schwachen Sicherheitsfrageschemas besteht darin, eine Frage oder eine Reihe von Fragen zu finden, die die Möglichkeit bieten, die Antworten leicht zu finden. \n\n Schritt 1:\nVersuchen Sie, eine Liste mit Sicherheitsfragen zu erhalten, indem Sie ein neues Konto erstellen oder dem „Ich erinnere mich nicht an mein Passwort“-Prozess folgen.\n\n Schritt 2:\n Versuchen Sie, Sicherheitsfragen zu erstellen, indem Sie ein neues Konto erstellen oder die Kennwortwiederherstellungseigenschaften Ihres vorhandenen Kontos konfigurieren.\nWenn das System dem Benutzer erlaubt, seine eigenen Sicherheitsfragen zu generieren, ist es anfällig dafür, dass unsichere Fragen erstellt werden.\n\n Schritt 3:\n Stellen Sie fest, ob eine Reihe falsch eingegebener Sicherheitsantworten einen Sperrmechanismus auslösen.",
-      "009": "Die Funktion zum Ändern und Zurücksetzen von Kennwörtern einer Anwendung ist ein Self-Service-Mechanismus zum Ändern oder Zurücksetzen von Kennwörtern für Benutzer.\n Dieser Self-Service-Mechanismus ermöglicht es Benutzern, ihr Passwort schnell zu ändern oder zurückzusetzen, ohne dass ein Administrator eingreifen muss.\n\n Schritt 1:\n Bestimmen Sie den Widerstand der Anwendung gegen die Subversion des Kontoänderungsprozesses, der es jemandem ermöglicht, das Kennwort eines Kontos zu ändern.\n\n Schritt 2:\nBestimmen Sie die Widerstandsfähigkeit der Funktion zum Zurücksetzen von Passwörtern gegen Erraten oder Umgehen.\n\n Sowohl für die Passwortänderung als auch für das Zurücksetzen des Passworts ist es wichtig, dies zu überprüfen.\n\n.. wenn andere Benutzer als Administratoren Kennwörter für andere Konten als ihre eigenen ändern oder zurücksetzen können.\n.. wenn Benutzer den Prozess zum Ändern oder Zurücksetzen von Passwörtern manipulieren oder untergraben können.\n.. wenn der Prozess zum Ändern oder Zurücksetzen des Passworts anfällig für CSRF ist.",
-      "010": "Auch wenn die primären Authentifizierungsmechanismen keine Schwachstellen enthalten, kann es sein, dass Schwachstellen in alternativen legitimen Benutzerkanälen für die Authentifizierung für dieselben Benutzerkonten vorhanden sind.\n\n Es sollten Tests durchgeführt werden, um alternative Kanäle zu identifizieren und, vorbehaltlich des Testumfangs, Schwachstellen zu identifizieren.\n Einige dieser Kanäle können selbst separate Webanwendungen sein, die unterschiedliche Hostnamen oder Pfade verwenden. Zum Beispiel:\n• Standard-Website\n• Mobile Website\n• Zugänglichkeitsoptimierte Website\n• Parallele Websites, die dieselben Benutzerkonten verwenden\n• Entwicklung, UAT und Versionen der Standard-Website\n\n Es könnten aber auch andere Arten von Anwendungen oder Geschäftsprozessen sein:\n• App für mobile Geräte\n• Desktopanwendung\n• Call-Center-Betreiber\n• Interaktive Sprachantwort oder Telefonbaumsysteme"
-    },
-    "authz": {
-      "001": "Viele Webanwendungen verwenden und verwalten Dateien im Rahmen ihres täglichen Betriebs. Durch die Verwendung von Eingabevalidierungsmethoden, die nicht gut entwickelt oder eingesetzt wurden, könnte ein Angreifer das System ausnutzen, um Dateien zu lesen oder zu schreiben, auf die nicht zugegriffen werden soll. In bestimmten Situationen kann es möglich sein, beliebigen Code oder Systembefehle auszuführen.\n\n Bei Webservern und Webanwendungen tritt diese Art von Problem bei Path Traversal/File Include-Angriffen auf. Während einer Bewertung müssen Tester zwei verschiedene Phasen durchführen, um Path Traversal und File Include-Fehler zu entdecken:\n\n Stufe 1:\n Input Vectors Enumeration (eine systematische Auswertung jedes Input-Vektors)\n\n Stufe 2:\n Testtechniken (eine methodische Bewertung jeder Angriffstechnik, die von einem Angreifer verwendet wird, um die Schwachstelle auszunutzen)\n\n Die nächste Testphase besteht in der Analyse der in der Webanwendung vorhandenen Eingabevalidierungsfunktionen. Unter Verwendung des vorherigen Beispiels lädt die dynamische Seite namens getUserProfile.jsp statische Informationen aus einer Datei und zeigt Benutzern den Inhalt an. Ein Angreifer könnte die böswillige Zeichenfolge „../../../../etc/passwd“ einfügen, um die Passwort-Hash-Datei einzufügen.\n Es ist ein häufiger Fehler von Entwicklern, nicht jede Form der Codierung zu erwarten und daher nur grundlegende codierte Inhalte zu validieren. Wenn die Testzeichenfolge zunächst nicht erfolgreich ist, versuchen Sie es mit einem anderen Codierungsschema.",
-      "002": "Diese Art von Test konzentriert sich darauf, zu überprüfen, wie das Autorisierungsschema für jede Rolle oder jedes Privileg implementiert wurde, um Zugriff auf reservierte Funktionen und Ressourcen zu erhalten.\n\nFür jede spezifische Rolle, die der Tester während der Bewertung innehat, für jede Funktion und Anforderung, die die Anwendung während der Phase nach der Authentifizierung ausführt, muss Folgendes überprüft werden:\n • Ist es möglich, auf diese Ressource zuzugreifen, selbst wenn der Benutzer nicht authentifiziert ist?\n • Kann nach dem Abmelden auf diese Ressource zugegriffen werden?\n • Ist es möglich, auf Funktionen und Ressourcen zuzugreifen, die einem Benutzer mit einer anderen Rolle oder Berechtigung zugänglich sein sollten?\n\n Versuchen Sie, als Administrator auf die Anwendung zuzugreifen, und verfolgen Sie alle Verwaltungsfunktionen:\n • Ist der Zugriff auf Verwaltungsfunktionen auch dann möglich, wenn der Tester als Benutzer mit Standardrechten angemeldet ist?\n• Ist es möglich, diese Verwaltungsfunktionen als Benutzer mit einer anderen Rolle zu verwenden, und wem sollte diese Aktion verweigert werden?",
-      "003": "Eine Rechteausweitung tritt auf, wenn ein Benutzer Zugriff auf mehr Ressourcen oder Funktionen erhält, als ihm normalerweise gestattet sind.\n\n Während dieser Phase sollte der Tester sicherstellen, dass es einem Benutzer nicht möglich ist, seine Berechtigungen oder Rollen innerhalb der Anwendung auf eine Weise zu ändern, die Angriffe zur Rechteausweitung ermöglichen könnte.\n Der Grad der Eskalation hängt davon ab, welche Privilegien der Angreifer besitzen darf und welche Privilegien bei einem erfolgreichen Exploit erworben werden können.\n\n In jedem Teil der Anwendung, in dem ein Benutzer Informationen in der Datenbank erstellen (z. B. eine Zahlung vornehmen oder eine Nachricht senden), Informationen empfangen (Kontoauszug, Bestelldetails usw.) oder Informationen löschen (Benutzer löschen, Nachrichten usw.), ist es notwendig, diese Funktionalität aufzuzeichnen.\n Versuchen Sie, als anderer Benutzer auf solche Funktionen zuzugreifen, um zu überprüfen, ob es möglich ist, auf eine Funktion zuzugreifen, die aufgrund der Rolle/Berechtigung des Benutzers nicht zulässig sein sollte.",
-      "004": "Unsichere direkte Objektverweise treten auf, wenn eine Anwendung basierend auf Benutzereingaben direkten Zugriff auf Objekte bereitstellt.\n Durch diese Schwachstelle können Angreifer die Autorisierung umgehen und direkt auf Ressourcen im System zugreifen, beispielsweise Datenbankeinträge oder Dateien.\n\n Unsichere direkte Objektreferenzen ermöglichen es Angreifern, die Autorisierung zu umgehen und direkt auf Ressourcen zuzugreifen, indem sie den Wert eines Parameters ändern, der verwendet wird, um direkt auf ein Objekt zu verweisen.\n\n Um diese Schwachstelle zu testen, muss der Tester zunächst alle Stellen in der Anwendung abbilden, an denen Benutzereingaben verwendet werden, um direkt auf Objekte zu verweisen.\n Der beste Weg, um auf direkte Objektreferenzen zu testen, wäre, mindestens zwei (häufig mehr) Benutzer zu haben, um verschiedene Objekte und Funktionen im Besitz abzudecken.\n Indem er mehrere Benutzer hat, spart der Tester wertvolle Testzeit beim Erraten unterschiedlicher Objektnamen, da er versuchen kann, auf Objekte zuzugreifen, die dem anderen Benutzer gehören."
-    },
-    "sess": {
-      "001": "Um eine kontinuierliche Authentifizierung für jede Seite einer Website oder eines Dienstes zu vermeiden, implementieren Webanwendungen verschiedene Mechanismen, um Anmeldeinformationen für einen festgelegten Zeitraum zu speichern und zu validieren.\n Diese Mechanismen werden als Sitzungsverwaltung bezeichnet.\n\n In diesem Test möchte der Tester überprüfen, ob Cookies und andere Sitzungstoken auf sichere und unvorhersehbare Weise erstellt werden. Ein Angreifer, der in der Lage ist, ein schwaches Cookie vorherzusagen und zu fälschen, kann leicht die Sitzungen legitimer Benutzer kapern.\n Aufgrund der Bedeutung der von ihnen gespeicherten Daten sind Cookies daher für die Gesamtsicherheit der Anwendung von entscheidender Bedeutung. Bei diesem Test muss der Tester überprüfen, ob die an Clients ausgegebenen Cookies einer Vielzahl von Angriffen widerstehen können, die darauf abzielen, die Sitzungen legitimer Benutzer und die Anwendung selbst zu stören.\n\n Normalerweise sind die Hauptschritte des Angriffsmusters die folgenden:\n• Cookie-Sammlung\n• Cookie-Reverse-Engineering\n• Cookie-Manipulation\n\n Ein weiteres Angriffsmuster besteht darin, einen Cookie zum Überlaufen zu bringen. Genau genommen hat dieser Angriff einen anderen Charakter, da Tester hier nicht versuchen, ein vollkommen gültiges Cookie nachzubilden. Stattdessen besteht das Ziel darin, einen Speicherbereich zum Überlaufen zu bringen und dadurch das korrekte Verhalten der Anwendung zu stören.",
-      "002": "Cookies sind oft ein wichtiger Angriffsvektor für böswillige Benutzer, und die Anwendung sollte immer die gebotene Sorgfalt walten lassen, um Cookies zu schützen. In diesem Abschnitt wird erläutert, wie eine Anwendung beim Zuweisen von Cookies die erforderlichen Vorkehrungen treffen und testen kann, ob diese Attribute korrekt konfiguriert wurden.\n\n Aufgrund der sensiblen Natur von Informationen in Cookies werden diese typischerweise kodiert oder verschlüsselt, um die darin enthaltenen Informationen zu schützen.\n Sobald der Tester verstanden hat, wie Cookies gesetzt werden, wann sie gesetzt werden, wofür sie verwendet werden, warum sie verwendet werden und welche Bedeutung sie haben, sollten sie sich ansehen, welche Attribute für ein Cookie gesetzt werden können und wie sie getestet werden wenn sie sicher sind.\n\nDurch die Verwendung eines abfangenden Proxys oder eines Browser-Plug-ins zum Abfangen von Datenverkehr fangen Sie alle Antworten ab, bei denen ein Cookie von der Anwendung gesetzt wird (unter Verwendung der Set-cookie-Anweisung), und untersuchen Sie das Cookie auf Folgendes:\n• Secure-Attribut\n• HttpOnly-Attribut\n• Domain-Attribut\n• Path-Attribut\n• Expires-Attribut",
-      "003": "Wenn eine Anwendung ihre Sitzungscookies nach einer erfolgreichen Benutzerauthentifizierung nicht erneuert, könnte es möglich sein, eine Schwachstelle bei der Sitzungsfixierung zu finden und einen Benutzer zu zwingen, ein dem Angreifer bekanntes Cookie zu verwenden. In diesem Fall könnte ein Angreifer die Benutzersitzung stehlen (Session-Hijacking).\n\n Sicherheitslücken bei der Sitzungsfixierung treten auf, wenn..\n ... eine Webanwendung einen Benutzer authentifiziert, ohne zuerst die vorhandene Sitzungs-ID ungültig zu machen, wodurch die bereits mit dem Benutzer verknüpfte Sitzungs-ID weiterhin verwendet wird\n.. ein Angreifer in der Lage ist, einem Benutzer eine bekannte Sitzungs-ID aufzuzwingen, sodass der Angreifer nach der Authentifizierung des Benutzers Zugriff auf die authentifizierte Sitzung hat.\n\n Beim generischen Exploit von Sicherheitslücken zur Sitzungsfixierung erstellt ein Angreifer eine neue Sitzung in einer Webanwendung und zeichnet die zugehörige Sitzungskennung auf. Der Angreifer veranlasst dann das Opfer, sich mit derselben Sitzungskennung beim Server zu authentifizieren, wodurch der Angreifer während der aktiven Sitzung Zugriff auf das Konto des Benutzers erhält.",
-      "004": "Die Sitzungstoken (Cookie, Sitzungs-ID, verborgenes Feld) ermöglichen es einem Angreifer normalerweise, sich als Opfer auszugeben und unrechtmäßig auf die Anwendung zuzugreifen, wenn sie offengelegt werden. Es ist wichtig, dass sie jederzeit vor Abhören geschützt sind, insbesondere während der Übertragung zwischen dem Client-Browser und den Anwendungsservern.\n\n Über einen persönlichen Proxy kann zu jeder Anfrage und Antwort Folgendes festgestellt werden:\n • Verwendetes Protokoll (z. B. HTTP vs. HTTPS)\n • HTTP-Header\n • Nachrichtentext (z. B. POST oder Seiteninhalt)\n\n Schutz vor Lauschangriffen wird oft durch SSL-Verschlüsselung bereitgestellt, kann aber auch andere Tunnel oder Verschlüsselung beinhalten. Wenn die Sitzungs-ID von einem Angreifer der Anwendung präsentiert werden könnte, um sich Zugriff zu verschaffen, muss sie während der Übertragung geschützt werden, um dieses Risiko zu mindern. Daher sollte sichergestellt werden, dass die Verschlüsselung für alle Anfragen oder Antworten, bei denen die Sitzungs-ID übergeben wird, sowohl standardmäßig als auch durchgesetzt wird, unabhängig vom verwendeten Mechanismus.\n\n Jedes Mal, wenn die Authentifizierung erfolgreich ist, sollte der Benutzer Folgendes erwarten:\n• Ein anderes Sitzungstoken\n• Ein Token, das für jede HTTP-Anforderung über einen verschlüsselten Kanal gesendet wird",
-      "005": "CSRF ist ein Angriff, der einen Endbenutzer dazu zwingt, unerwünschte Aktionen auf einer Webanwendung auszuführen, in der er/sie gerade authentifiziert ist.\nEin erfolgreicher CSRF-Exploit kann die Daten und den Betrieb von Endbenutzern gefährden, wenn er auf einen normalen Benutzer abzielt. Wenn der Zielbenutzer das Administratorkonto ist, kann ein CSRF-Angriff die gesamte Webanwendung gefährden.\n CSRF stützt sich auf Folgendes:\n\n Punkt 1:\n Verhalten des Webbrowsers in Bezug auf den Umgang mit sitzungsbezogenen Informationen wie Cookies und HTTP-Authentifizierungsinformationen;\n\n Punkt 2:\n Kenntnis des Angreifers von gültigen Webanwendungs-URLs;\n\n Punkt 3:\n Anwendungssitzungsverwaltung, die sich nur auf Informationen stützt, die dem Browser bekannt sind;\n\n Punkt 4:\n Vorhandensein von HTML-Tags, deren Vorhandensein einen sofortigen Zugriff auf eine http[s]-Ressource bewirkt; zum Beispiel das Image-Tag img\n\n Der Tester muss URLs im eingeschränkten (authentifizierten) Bereich kennen. Wenn sie über gültige Anmeldeinformationen verfügen, können sie beide Rollen einnehmen – Angreifer und Opfer. In diesem Fall kennen Tester die zu testenden URLs, indem sie sich einfach umsehen.\n\n  Wenn sich die Sitzungsverwaltung nur auf clientseitige Werte stützt (Informationen, die dem Browser zur Verfügung stehen), ist die Anwendung anfällig.\n Damit eine Anwendung nicht anfällig ist, muss sie sitzungsbezogene Informationen in der URL enthalten, und zwar in einer Form, die für den Benutzer nicht identifizierbar oder unvorhersehbar ist.",
-      "006": "Die Sitzungsbeendigung ist ein wichtiger Teil des Sitzungslebenszyklus. Das Verkürzen der Lebensdauer der Sitzungstoken auf ein Minimum verringert die Wahrscheinlichkeit eines erfolgreichen Sitzungs-Hijacking-Angriffs. Dies kann als Kontrolle gegen andere Angriffe wie Cross Site Scripting und Cross Site Request Forgery angesehen werden. Es ist bekannt, dass solche Angriffe darauf beruhen, dass ein Benutzer eine authentifizierte Sitzung hat.\n\n Eine sichere Sitzungsbeendigung erfordert mindestens die folgenden Komponenten:\n • Verfügbarkeit von Steuerelementen der Benutzeroberfläche, mit denen sich der Benutzer manuell abmelden kann\n • Sitzungsbeendigung nach einer bestimmten Zeit ohne Aktivität (Session-Timeout)\n • Ordnungsgemäße Invalidierung des serverseitigen Sitzungsstatus\n\n Der richtige Wert für das Sitzungs-Timeout hängt vom Zweck der Anwendung ab und sollte ein Gleichgewicht zwischen Sicherheit und Benutzerfreundlichkeit darstellen.",
-      "007": "In dieser Phase überprüfen Tester, ob die Anwendung einen Benutzer automatisch abmeldet, wenn dieser Benutzer eine bestimmte Zeit lang inaktiv war, um sicherzustellen, dass dieselbe Sitzung nicht „wiederverwendet“ werden kann und dass keine sensiblen Daten im Browser-Cache gespeichert bleiben .\n\n Das Leerlaufzeitlimit schränkt die Wahrscheinlichkeit ein, dass ein Angreifer eine gültige Sitzungs-ID eines anderen Benutzers erraten und verwenden muss, und könnte unter bestimmten Umständen öffentliche Computer vor der Wiederverwendung von Sitzungen schützen. Verwaltung und Ablauf von Sitzungszeitüberschreitungen müssen serverseitig erzwungen werden. Wenn einige Daten unter der Kontrolle des Clients verwendet werden, um das Sitzungs-Timeout zu erzwingen, könnte ein Angreifer diese manipulieren, um die Sitzungsdauer zu verlängern.\n\n Schritt 1:\nTester müssen prüfen, ob ein Timeout vorliegt, indem sie sich beispielsweise anmelden und auf das Auslösen des Timeout-Logouts warten. Wie bei der Abmeldefunktion sollten nach Ablauf des Timeouts alle Sitzungstoken zerstört oder unbrauchbar sein.\n\n Schritt 2:\n Wenn das Timeout konfiguriert ist, müssen Tester verstehen, ob das Timeout vom Client oder vom Server erzwungen wird.\n\n Generell sollte serverseitig alles überprüft werden und es sollte nicht möglich sein, durch Zurücksetzen der Session-Cookies auf vorherige Werte wieder auf die Anwendung zuzugreifen.",
-      "008": "Das Überladen von Sitzungsvariablen (Session Puzzling) ist eine Schwachstelle auf Anwendungsebene, die es einem Angreifer ermöglichen kann, eine Vielzahl von böswilligen Aktionen auszuführen, einschließlich, aber nicht beschränkt auf ...\n.. effiziente Mechanismen zur Durchsetzung der Authentifizierung umgehen und sich als legitime Benutzer ausgeben.\n.. erhöhen der Rechte eines böswilligen Benutzerkontos in einer Umgebung, die ansonsten als narrensicher gelten würde.\n.. Qualifizierungsphasen in mehrphasigen Prozessen überspringen, selbst wenn der Prozess Einschränkungen auf Codeebene enthält.\n.. serverseitige Werte mit indirekten Methoden manipulieren, die nicht vorhergesagt oder erkannt werden können.\n.. herkömmliche Angriffe an Orten ausführen, die zuvor unerreichbar waren oder sogar als sicher galten.\n\n Diese Schwachstelle tritt auf, wenn eine Anwendung dieselbe Sitzungsvariable für mehr als einen Zweck verwendet. Es kann erkannt und ausgenutzt werden, indem alle Sitzungsvariablen, die von der Anwendung verwendet werden, und in welchem \u200B\u200BKontext sie gültig sind, aufgelistet werden. Dies ist insbesondere möglich, indem auf eine Folge von Einstiegspunkten zugegriffen und dann Ausstiegspunkte untersucht werden.",
-      "009": "Ein Angreifer, der Zugriff auf Benutzersitzungscookies erhält, kann sich durch die Bereitstellung solcher Cookies als diese ausgeben. Dieser Angriff wird als Session-Hijacking bezeichnet. Betrachtet man Netzwerkangreifer, d. h. Angreifer, die das vom Opfer verwendete Netzwerk kontrollieren, können Sitzungscookies dem Angreifer über HTTP unangemessen zugänglich gemacht werden. Um dies zu verhindern, sollten Sitzungscookies mit dem Attribut „Sicher“ gekennzeichnet werden, sodass sie nur über HTTPS kommuniziert werden.\n\nTestziele\n• Identifizieren Sie anfällige Sitzungscookies.\n• Kapern Sie anfällige Cookies und bewerten Sie das Risikoniveau.\n\nSo testen Sie\nHier sind die Schritte zur Durchführung dieses Tests:\n1. Melden Sie sich als Opfer auf der Website an und gelangen Sie zu einer beliebigen Seite, die eine sichere Funktion bietet, die eine Authentifizierung erfordert.\n2. Löschen Sie alle Cookies aus der Keksdose, die eine der folgenden Bedingungen erfüllen.\n• Falls keine HSTS-Übernahme erfolgt: Das Secure-Attribut ist gesetzt.\n• bei teilweiser HSTS-Einführung: Das Secure-Attribut ist gesetzt oder das Domain-Attribut ist nicht gesetzt.\n3. Speichern Sie einen Schnappschuss der Keksdose.\n4. Lösen Sie die in Schritt 1 identifizierte sichere Funktion aus.\n5. Beobachten Sie, ob der Vorgang in Schritt 4 erfolgreich durchgeführt wurde. Wenn ja, war der Angriff erfolgreich.\n6. Leeren Sie die Keksdose, melden Sie sich als Angreifer an und gelangen Sie zur Seite bei Schritt 1.\n7. Schreiben Sie die in Schritt 3 gespeicherten Kekse nacheinander in die Keksdose.\n8. Lösen Sie die in Schritt 1 identifizierte Sicherheitsfunktion erneut aus.\n9. Leeren Sie die Keksdose und melden Sie sich erneut als Opfer an.\n10. Beobachten Sie, ob der Vorgang in Schritt 8 im Konto des Opfers erfolgreich durchgeführt wurde. Wenn ja, war der Angriff erfolgreich; andernfalls ist die Site vor Session-Hijacking geschützt.\n\nBeachten Sie, dass das Secure-Attribut auch verwendet werden sollte, wenn die Webanwendung vollständig über HTTPS bereitgestellt wird, da sonst der folgende Cookie-Diebstahl-Angriff möglich ist. Gehen Sie davon aus, dass example.com vollständig über HTTPS bereitgestellt wird, seine Sitzungscookies jedoch nicht als „sicher“ markiert.\n\nFolgende Angriffsschritte sind möglich:\n1. Das Opfer sendet eine Anfrage an http://another-site.com.\n2. Der Angreifer manipuliert die entsprechende Antwort, sodass eine Anfrage an http://example.com ausgelöst wird.\n3. Der Browser versucht nun, auf http://example.com zuzugreifen.\n4. Obwohl die Anfrage fehlschlägt, werden die Sitzungscookies im Klartext über HTTP weitergegeben.\n\nWenn das Domänenattribut festgelegt ist, können Sitzungscookies über Subdomänen hinweg gemeinsam genutzt werden. Die Verwendung von HTTP mit Subdomains sollte vermieden werden, um die Offenlegung unverschlüsselter, über HTTP gesendeter Cookies zu verhindern. Um diese Sicherheitslücke zu veranschaulichen, gehen wir davon aus, dass die Website example.com HSTS ohne die Option includeSubDomains aktiviert. Die Website gibt Sitzungscookies aus, wobei das Domain-Attribut auf example.com festgelegt ist.\n\nFolgender Angriff ist möglich:\n1. Das Opfer sendet eine Anfrage an http://another-site.com.\n2. Der Angreifer manipuliert die entsprechende Antwort, sodass eine Anfrage an http://fake.example.com ausgelöst wird.\n3. Der Browser versucht nun, auf http://fake.example.com zuzugreifen, was die HSTS-Konfiguration zulässt.\n4. Da die Anfrage an eine Unterdomäne von example.com mit festgelegtem Domänenattribut gesendet wird, enthält sie die Sitzungscookies, die im Klartext über HTTP durchgesickert sind."
-    },
-    "inpval": {
-      "001": "Reflected Cross-Site Scripting (XSS) tritt auf, wenn ein Angreifer ausführbaren Browsercode in eine einzelne HTTP-Antwort einfügt.\nDer eingeschleuste Angriff wird nicht in der Anwendung selbst gespeichert; Es ist nicht dauerhaft und wirkt sich nur auf Benutzer aus, die einen in böser Absicht erstellten Link oder eine Webseite eines Drittanbieters öffnen.\nDie Angriffszeichenfolge ist Teil der präparierten URI- oder HTTP-Parameter, wird von der Anwendung nicht ordnungsgemäß verarbeitet und an das Opfer zurückgegeben. Eine der Hauptschwierigkeiten beim Verhindern von XSS-Schwachstellen ist die richtige Zeichencodierung.\n In einigen Fällen filtert der Webserver oder die Webanwendung möglicherweise einige Zeichencodierungen nicht, sodass die Webanwendung beispielsweise „<script>“ herausfiltert, aber nicht %3cscript%3e filtert, das einfach eine andere Codierung enthält von Tags. Ein Test umfasst mindestens drei Phasen:\n\n Phase 1:\nEingabevektoren erkennen. Für jede Webseite muss der Tester alle benutzerdefinierten Variablen der Webanwendung und deren Eingabe bestimmen. Dazu gehören versteckte oder nicht offensichtliche Eingaben wie HTTP-Parameter, POST-Daten, versteckte Formularfeldwerte und vordefinierte Radio- oder Auswahlwerte. In der Regel werden HTML-Editoren im Browser oder Web-Proxys verwendet, um diese versteckten Variablen anzuzeigen.\n\n Phase 2:\n Analysieren Sie jeden Eingabevektor, um potenzielle Schwachstellen zu erkennen. dUm eine XSS-Schwachstelle zu erkennen, verwendet der Tester normalerweise speziell gestaltete Eingabedaten mit jedem Eingabevektor. Solche Eingabedaten sind in der Regel harmlos, lösen jedoch Reaktionen des Webbrowsers aus, der die Schwachstelle manifestiert. Testdaten können mithilfe eines Webanwendungs-Fuzzers, einer automatisierten vordefinierten Liste bekannter Angriffszeichenfolgen oder manuell generiert werden.\n\n Phase 3:\n Für jede Testeingabe, die in der vorherigen Phase versucht wurde, analysiert der Tester das Ergebnis und bestimmt, ob es sich um eine Schwachstelle handelt, die realistische Auswirkungen auf die Sicherheit der Webanwendung hat. Dazu muss der HTML-Code der resultierenden Webseite untersucht und nach der Testeingabe gesucht werden. Einmal gefunden, identifiziert der Tester alle Sonderzeichen, die nicht richtig codiert, ersetzt oder herausgefiltert wurden.",
-      "002": "Stored Cross Site Scripting (XSS) ist die gefährlichste Art von Cross Site Scripting.\n\n Gespeichertes XSS tritt auf, wenn eine Webanwendung Eingaben von einem Benutzer sammelt, die möglicherweise böswillig sind, und diese Eingaben dann zur späteren Verwendung in einem Datenspeicher speichert. Die gespeicherte Eingabe wird nicht korrekt gefiltert. Infolgedessen scheinen die schädlichen Daten Teil der Website zu sein und werden im Browser des Benutzers unter den Rechten der Webanwendung ausgeführt.\n\n Eine erfolgreiche Ausnutzung liegt vor, wenn ein Benutzer eine Seite mit einem gespeicherten XSS besucht.\nDie folgenden Phasen beziehen sich auf ein typisches Szenario eines gespeicherten XSS-Angriffs:\n • Der Angreifer speichert schädlichen Code auf der anfälligen Seite\n • Der Benutzer authentifiziert sich in der Anwendung\n • Benutzer besucht anfällige Seite\n • Schädlicher Code wird vom Browser des Benutzers ausgeführt\n\n Diese Schwachstelle kann verwendet werden, um eine Reihe von browserbasierten Angriffen durchzuführen, darunter:\n • Hijacking des Browsers eines anderen Benutzers\n • Erfassen vertraulicher Informationen, die von Benutzern angezeigt werden\n • Pseudo-Verunstaltung der Anwendung\n • Port-Scanning interner Hosts\n • Gezielte Bereitstellung browserbasierter Exploits\n • Andere böswillige Aktivitäten",
-      "003": "Die HTTP-Spezifikation enthält andere Anforderungsmethoden als die standardmäßigen GET- und POST-Anforderungen. Ein standardkonformer Webserver kann auf diese alternativen Methoden auf eine Weise reagieren, die von Entwicklern nicht erwartet wurde.\n\n Da der HTML-Standard keine anderen Anfragemethoden als GET oder POST unterstützt, müssen wir benutzerdefinierte HTTP-Anfragen erstellen, um die anderen Methoden zu testen.\n\n Die vollständige HTTP 1.1-Spezifikation definiert die folgenden gültigen HTTP-Anforderungsmethoden oder Verben: \n • OPTIONS \n • GET \n • HEAD \n • POST \n • PUT \n • DELETE \n • TRACE \n • CONNECT \n\n Wenn diese Option aktiviert ist, lassen die Erweiterungen Web Distributed Authoring and Version (WebDAV) mehrere weitere HTTP-Methoden zu: \n • PROPFIND \n • PROPPATCH \n • MKCOL \n • COPY \n • MOVE \n • LOCK \n • UNLOCK",
-      "004": "Das Bereitstellen mehrerer HTTP-Parameter mit demselben Namen kann dazu führen, dass eine Anwendung Werte auf unerwartete Weise interpretiert. Durch Ausnutzen dieser Effekte kann ein Angreifer möglicherweise die Eingabevalidierung umgehen, Anwendungsfehler auslösen oder interne Variablenwerte ändern. Da HTTP Parameter Pollution (kurz HPP) einen Baustein aller Webtechnologien betrifft, existieren server- und clientseitige Angriffe.\n\n Da die Zuweisung von HTTP-Parametern in der Regel über den Webanwendungsserver und nicht über den Anwendungscode selbst erfolgt, sollte das Testen der Reaktion auf Parameterverschmutzung zum Glück Standard für alle Seiten und Aktionen sein.\n Da jedoch fundierte Kenntnisse der Geschäftslogik erforderlich sind, erfordert das Testen von HPP manuelles Testen.\n Automatische Tools können Prüfer nur teilweise unterstützen, da sie dazu neigen, zu viele Fehlalarme zu generieren. Darüber hinaus kann sich HPP in clientseitigen und serverseitigen Komponenten manifestieren.",
-      "005": "SQL-Injection-Angriffe sind eine Art von Injection-Angriffen, bei denen SQL-Befehle in Eingaben auf Datenebene eingeschleust werden, um die Ausführung vordefinierter SQL-Befehle zu beeinflussen.\n\n Der Tester kann präparierte Eingaben liefern, die versuchen, die ursprüngliche SQL-Anweisung dazu zu bringen, weitere Aktionen nach Wahl des Testers auszuführen. \n Beispielsweise könnte der Tester eine Anweisung in „$password = 1“ oder „1“ = „1“ ändern, die Logik der SQL-Anweisung ändern und die WHERE-Klausel ändern, indem er eine Bedingung hinzufügt „oder „1“ = „1“.\n\n SQL-Injection-Angriffe können in die folgenden drei Klassen eingeteilt werden: \n • Inband \n • Out-of-band \n • Inferential or Blind \n\n Bei den Techniken zum Ausnutzen von SQL-Injection-Fehlern gibt es fünf gängige Techniken. Diese Techniken können manchmal auch kombiniert verwendet werden:\n • Union Operator \n • Boolean \n • Error based \n • Out-of-band \n • Time delay",
-      "005_1": "Webbasierte PL/SQL-Anwendungen werden durch das PL/SQL-Gateway ermöglicht, das die Komponente ist, die Webanforderungen in Datenbankabfragen übersetzt. Oracle hat eine Reihe von Softwareimplementierungen entwickelt.\n Zu den Produkten, die das PL/SQL-Gateway verwenden, gehören unter anderem Oracle HTTP Server, eBusiness Suite, Portal, HTMLDB, WebDB und Oracle Application Server.\n\n Im Wesentlichen fungiert das PL/SQL-Gateway einfach als Proxy-Server, der die Webanfrage des Benutzers entgegennimmt und an den Datenbankserver weiterleitet, wo sie ausgeführt wird.\n\n Schritt 1:\n Der Webserver akzeptiert eine Anfrage von einem Webclient und bestimmt, ob sie vom PL/SQL-Gateway verarbeitet werden soll.\n\n Schritt 2:\n Das PL/SQL-Gateway verarbeitet die Anfrage, indem es den angeforderten Paketnamen, die Prozedur und die Variablen extrahiert.\n\n Schritt 3:\n Das angeforderte Paket und die Prozedur werden in einen anonymen PL/SQL-Block verpackt und an den Datenbankserver gesendet.\n\n Schritt 4:\n Der Datenbankserver führt die Prozedur aus und sendet die Ergebnisse als HTML an das Gateway zurück\n\n Schritt 5:\n Das Gateway sendet die Antwort über den Webserver zurück an den Client.\n\n Es ist wichtig, diesen Punkt zu verstehen – der PL/SQL-Code existiert nicht auf dem Webserver, sondern auf dem Datenbankserver.\n Das bedeutet, dass jede Schwachstelle im PL/SQL-Gateway oder jede Schwachstelle in der PL/SQL-Anwendung, wenn sie ausgenutzt wird, einem Angreifer direkten Zugriff auf den Datenbankserver verschafft.",
-      "005_2": "SQL-Injection-Schwachstellen treten immer dann auf, wenn Eingaben beim Erstellen einer SQL-Abfrage verwendet werden, ohne dass sie angemessen eingeschränkt oder bereinigt wurden.\n Der MySQL-Server weist einige Besonderheiten auf, sodass einige Exploits speziell für diese Anwendung angepasst werden müssen.\n\n Wenn eine SQL-Injection-Schwachstelle in einer Anwendung gefunden wird, die von einer MySQL-Datenbank unterstützt wird, gibt es eine Reihe von Angriffen, die je nach MySQL-Version und Benutzerberechtigungen auf DBMS durchgeführt werden können.\n\n MySQL wird mit mindestens vier Versionen geliefert, die weltweit in der Produktion verwendet werden. Jede Version hat eine Reihe von Funktionen, die proportional zur Versionsnummer sind:\n • Ab Version 4.0: UNION\n • Ab Version 4.1: Subqueries\n • Ab Version 5.0: Stored Procedures, Stored Functions und die View mit dem Namen INFORMATION_SCHEMA\n • Ab Version 5.0.2: Trigger\n\n Es ist zu beachten, dass für MySQL-Versionen vor 4.0.x nur Boolean- oder zeitbasierte Blind-Injection-Angriffe verwendet werden konnten, da die Subquery-Funktionalität oder UNION-Anweisungen nicht implementiert waren.",
-      "005_3": "SQL-Injection ermöglicht einem Angreifer den Zugriff auf die SQL-Server und die Ausführung von SQL-Code unter den Rechten des Benutzers, der für die Verbindung zur Datenbank verwendet wird. SQL-Injection-Techniken für Microsoft SQL Server verwenden spezifische Features.\n\n Wie in SQL-Injection erläutert, erfordert ein SQL-Injection-Exploit zwei Dinge: einen Einstiegspunkt und einen Exploit zum Eintreten.\n Jeder benutzergesteuerte Parameter, der von der Anwendung verarbeitet wird, kann eine Schwachstelle verbergen. Das beinhaltet:\n • Anwendungsparameter in Abfragezeichenfolgen (z. B. GET-Anfragen)\n • Anwendungsparameter, die Teil des Hauptteils einer POST-Anfrage sind\n • Browserbezogene Informationen (z. B. User-Agent, Referrer)\n • Hostbezogene Informationen (z. B. Hostname, IP)\n • Sitzungsbezogene Informationen (z. B. Benutzer-ID, Cookies)\n\n  Einige Microsoft SQL Server-Operatoren und -Befehle sind:\n • Kommentaroperator --\n • Abfragetrennzeichen ;\n\n Zu den nützlichen gespeicherten Prozeduren gehören:\n • xp_cmdshell\n • xp_regread\n • xp_regwrite\n • sp_configure\n • sp_ makewebtask\n • sp_sendmail",
-      "005_4": "Wenn eine SQL-Injection gefunden wurde, müssen Sie die Backend-Datenbank-Engine sorgfältig mit einem Fingerabdruck versehen. Sie können feststellen, dass die Back-End-Datenbank-Engine PostgreSQL ist, indem Sie den :: cast-Operator verwenden.\n Außerdem kann die Funktion version() verwendet werden, um das PostgreSQL-Banner abzurufen. Dies zeigt auch den Typ und die Version des zugrunde liegenden Betriebssystems an.\n\n SQL-Injection-Techniken für PostgreSQL haben die folgenden Merkmale:\n • PHP Connector ermöglicht die Ausführung mehrerer Anweisungen mit ; als Anweisungstrenner\n • SQL-Anweisungen können durch Anhängen des Kommentarzeichens abgeschnitten werden: --\n • LIMIT und OFFSET können in einer SELECT-Anweisung verwendet werden, um einen Teil der von der Abfrage generierten Ergebnismenge abzurufen\n\n Bei blinden SQL-Injection-Angriffen sollten Sie die folgenden integrierten Funktionen berücksichtigen:\n • Zeichenfolgenlänge - LENGTH(str)\n • Einen Teilstring aus einem gegebenen String extrahieren – SUBSTR(str,index,offset)\n • Zeichenfolgendarstellung ohne einfache Anführungszeichen – CHR(101)||CHR(108)||CHR(111)",
-      "005_5": "Microsoft Access kann bestimmte Features für SQL-Injection-Techniken nutzen.\n Leider unterstützt MS Access keine typischen Operatoren, die traditionell bei SQL-Injection-Tests verwendet werden, einschließlich:\n• Keine Kommentarzeichen\n• Keine gestapelten Abfragen\n• Kein LIMIT-Operator\n• Keine SLEEP- oder BENCHMARK-ähnlichen Operatoren\n• und viele andere\n\n Es gibt jedoch auch viele andere Funktionen, die beim Testen der SQL-Injection verwendet werden können, einschließlich, aber nicht beschränkt auf:\n • ASC: Ruft den ASCII-Wert eines als Eingabe übergebenen Zeichens ab\n • CHR: Ruft das Zeichen des als Eingabe übergebenen ASCII-Werts ab\n • LEN: Gibt die Länge des als Parameter übergebenen Strings zurück\n • IIF: Ist das IF-Konstrukt, z. IIF(1=1, 'a', 'b') gibt 'a' zurück\n • MID: Mit dieser Funktion können Sie Teilstrings extrahieren\n • TOP: Mit dieser Funktion können Sie die max. Anzahl der Ergebnisse\n • LAST: Diese Funktion wird verwendet, um nur die letzte Zeile eines Satzes auszuwählen\n\n In MS Access sind standardmäßig verschiedene Systemtabellen vorhanden, die möglicherweise zum Abrufen von Tabellennamen und Spalten verwendet werden können.\n Leider sind diese Tabellen in der Standardkonfiguration neuerer Versionen von MS Access-Datenbanken nicht zugänglich. Trotzdem ist es immer einen Versuch wert:\n • MSysObjects\n • MSysACEs\n • MSysAccessXML",
-      "005_6": "NoSQL-Datenbanken bieten lockerere Konsistenzbeschränkungen als herkömmliche SQL-Datenbanken. Da weniger relationale Einschränkungen und Konsistenzprüfungen erforderlich sind, bieten NoSQL-Datenbanken häufig Leistungs- und Skalierungsvorteile.\n Da diese NoSQL-Injection-Angriffe jedoch in einer prozeduralen Sprache und nicht in der deklarativen SQL-Sprache ausgeführt werden können, sind die potenziellen Auswirkungen größer als bei herkömmlicher SQL-Injection.\n\n NoSQL-Datenbankaufrufe werden in der Programmiersprache der Anwendung, einem benutzerdefinierten API-Aufruf oder gemäß einer gängigen Konvention (z. B. XML, JSON, LINQ usw.) formatiert.\n\n Typischerweise werden NoSQL-Injection-Angriffe ausgeführt, bei denen die Angriffszeichenfolge analysiert, ausgewertet oder zu einem NoSQL-API-Aufruf verkettet wird.\n Zusätzliche Timing-Angriffe können für das Fehlen von Parallelitätsprüfungen innerhalb einer NoSQL-Datenbank relevant sein. Diese werden nicht von Injektionstests abgedeckt.\n\n Mittlerweile sind über 150 NoSQL-Datenbanken verfügbar, aber zum Zeitpunkt der Erstellung dieses Artikels ist MongoDB die am weitesten verbreitete NoSQL-Datenbank.\n\n Die MongoDB-API erwartet BSON-Aufrufe (Binary JSON) und enthält ein sicheres Tool zum Zusammenstellen von BSON-Abfragen. Laut MongoDB-Dokumentation sind jedoch deserialisierte JSON- und JavaScript-Ausdrücke in mehreren alternativen Abfrageparametern zulässig.\n Wenn ein Angreifer beispielsweise in der Lage wäre, die an den $where-Operator übergebenen Daten zu manipulieren, könnte dieser Angreifer willkürliches JavaScript einbinden, das als Teil der MongoDB-Abfrage ausgewertet wird.",
-      "005_7": "ORM Injection ist ein Angriff mit SQL Injection gegen ein ORM-generiertes Datenzugriffsobjektmodell. Aus Sicht eines Testers ist dieser Angriff praktisch identisch mit einem SQL-Injection-Angriff.\nDie Injection-Schwachstelle existiert jedoch in Code, der vom ORM-Tool generiert wird.\n\n Ein ORM ist ein objektrelationales Mapping-Tool.\nEs wird verwendet, um die objektorientierte Entwicklung innerhalb der Datenzugriffsschicht von Softwareanwendungen, einschließlich Webanwendungen, zu beschleunigen. Zu den Vorteilen der Verwendung eines ORM-Tools gehören die schnelle Generierung einer Objektschicht zur Kommunikation mit einer relationalen Datenbank, standardisierte Codevorlagen für diese Objekte und normalerweise eine Reihe sicherer Funktionen zum Schutz vor SQL-Injection-Angriffen. Von ORM generierte Objekte können SQL oder in einigen Fällen eine Variante von SQL verwenden, um CRUD-Operationen auf einer Datenbank auszuführen.\n\n Zu den ORM-Tools gehören Hibernate für Java, NHibernate für .NET, ActiveRecord für Ruby on Rails, EZPDO für PHP und viele andere.\n\n ORM-Injection-Schwachstellen sind identisch mit SQL-Injection-Tests. In den meisten Fällen ist die Schwachstelle in der ORM-Schicht das Ergebnis von benutzerdefiniertem Code, der Eingabeparameter nicht ordnungsgemäß validiert.\n Die meisten ORM-Tools bieten sichere Funktionen, um Benutzereingaben zu umgehen.\nWenn diese Funktionen jedoch nicht verwendet werden und der Entwickler benutzerdefinierte Funktionen verwendet, die Benutzereingaben akzeptieren, kann es möglich sein, einen SQL-Injection-Angriff auszuführen.\n\n Zu den Mustern, nach denen im Code gesucht werden muss, gehören:\n • Mit SQL-Strings verkettete Eingabeparameter",
-      "005_8": "Clientseitige SQL-Injection tritt auf, wenn eine Anwendung die Web-SQL-Datenbanktechnologie implementiert und die Eingabe nicht ordnungsgemäß validiert oder ihre Abfragevariablen nicht parametrisiert. Diese Datenbank wird mithilfe von JavaScript (JS)-API-Aufrufen manipuliert, z. B. openDatabase() , wodurch eine vorhandene Datenbank erstellt oder geöffnet wird.\n\nDas folgende Testszenario überprüft, ob eine ordnungsgemäße Eingabevalidierung durchgeführt wird. Wenn die Implementierung angreifbar ist, kann der Angreifer in der Datenbank gespeicherte Informationen lesen, ändern oder löschen.\n\nWenn die getestete Anwendung die Web SQL DB implementiert, werden im clientseitigen Kern die folgenden drei Aufrufe verwendet:\n• openDatabase()\n• transaction()\n• executeSQL()",
-      "006": "Das Lightweight Directory Access Protocol (LDAP) wird verwendet, um Informationen über Benutzer, Hosts und viele andere Objekte zu speichern. Die LDAP-Injection ist ein serverseitiger Angriff, bei dem sensible Informationen über Benutzer und Hosts, die in einer LDAP-Struktur dargestellt sind, offengelegt, geändert oder eingefügt werden können. Dies erfolgt durch Manipulieren von Eingabeparametern, die anschließend an interne Such-, Hinzufügungs- und Änderungsfunktionen übergeben werden.\n Eine Webanwendung könnte LDAP verwenden, damit sich Benutzer innerhalb einer Unternehmensstruktur authentifizieren oder die Informationen anderer Benutzer durchsuchen können.\n\n Das Ziel von LDAP-Injection-Angriffen besteht darin, Metazeichen von LDAP-Suchfiltern in eine Abfrage einzufügen, die von der Anwendung ausgeführt wird.\n [Rfc2254] definiert eine Grammatik zum Aufbau eines Suchfilters auf LDAPv3 und erweitert [Rfc1960] (LDAPv2).\nEin LDAP-Suchfilter wird in polnischer Schreibweise erstellt, die auch als [Präfixschreibweise] bekannt ist.\n\n Eine erfolgreiche Ausnutzung einer LDAP-Injection-Schwachstelle könnte dem Tester Folgendes ermöglichen:\n • Greifen Sie auf nicht autorisierte Inhalte zu\n • Anwendungseinschränkungen umgehen\n • Sammeln Sie nicht autorisierte Informationen\n • Hinzufügen oder Ändern von Objekten innerhalb der LDAP-Baumstruktur",
-      "007": "Beim XML-Injektionstest versucht ein Tester, ein XML-Dokument in die Anwendung einzufügen. Wenn der XML-Parser die Daten nicht kontextbezogen validieren kann, ergibt der Test ein positives Ergebnis.\n\n Schritt 1:\n Um eine Anwendung auf das Vorhandensein einer XML-Injection-Schwachstelle zu testen, besteht der Versuch, XML-Metazeichen einzufügen.\n\n XML-Metazeichen sind:\n • Einfaches Anführungszeichen: ‘ \n • Doppeltes Anführungszeichen: “ \n • Spitze Klammern: > und <\n • Kommentar-Tag: <!--/-->\n • Et-Zeichen: &\n • Trennzeichen für CDATA-Abschnitte: <![CDATA[ / ]]>\n\n Ein weiterer Test bezieht sich auf das CDATA-Tag. Angenommen, das XML-Dokument wird verarbeitet, um eine HTML-Seite zu generieren. In diesem Fall können die CDATA-Abschnittsbegrenzer einfach eliminiert werden, ohne ihren Inhalt weiter zu prüfen. Dann ist es möglich, HTML-Tags einzufügen, die in die generierte Seite eingefügt werden, wobei vorhandene Bereinigungsroutinen vollständig umgangen werden.\n\n Schritt 2:\n Sobald der erste Schritt abgeschlossen ist, verfügt der Tester über einige Informationen über die Struktur des XML-Dokuments. Anschließend kann versucht werden, XML-Daten und -Tags einzufügen (Tag Injection).",
-      "008": "Webserver geben Entwicklern normalerweise die Möglichkeit, kleine Teile dynamischen Codes in statische HTML-Seiten einzufügen. Diese Funktion wird durch die Server-Side Includes (SSI) verkörpert.\nBeim SSI-Injection-Test testen wir, ob es möglich ist, Daten in die Anwendung einzuspeisen, die von SSI-Mechanismen interpretiert werden. Eine erfolgreiche Ausnutzung dieser Schwachstelle ermöglicht es einem Angreifer, Code in HTML-Seiten einzuschleusen oder sogar eine Remotecodeausführung durchzuführen.\n\n In Bezug auf die SSI-Injektion könnte der Angreifer Eingaben bereitstellen, die, wenn sie von der Anwendung (oder vielleicht direkt vom Server) in eine dynamisch generierte Seite eingefügt würden, als eine oder mehrere SSI-Anweisungen geparst würden.\n\n Schritt 1:\n Was wir herausfinden müssen, ist, ob der Webserver tatsächlich SSI-Anweisungen unterstützt. Um das herauszufinden, müssen wir nur herausfinden, welche Art von Webserver auf unserem Ziel läuft.\n Hinweis: Wenn die Site .shtml-Dateien enthält, werden wahrscheinlich SSI unterstützt, da diese Erweiterung verwendet wird, um Seiten zu identifizieren, die diese Anweisungen enthalten.\n\n Schritt 2:\n Der nächste Schritt besteht darin, festzustellen, ob ein SSI-Injection-Angriff tatsächlich möglich ist und wenn ja, über welche Eingabepunkte können wir unseren Schadcode einschleusen.\n Wir müssen jede Seite finden, auf der der Benutzer Eingaben vornehmen darf, und überprüfen, ob die Anwendung die übermittelten Eingaben korrekt validiert.\n Wenn die Bereinigung unzureichend ist, müssen wir testen, ob wir Daten bereitstellen können, die unverändert angezeigt werden.\n Neben den üblichen vom Benutzer bereitgestellten Daten sind HTTP-Anforderungsheader und Cookie-Inhalte Eingabevektoren, die immer berücksichtigt werden sollten.\n\n Schritt 3:\n Sobald wir eine Liste möglicher Injektionspunkte haben, können wir überprüfen, wie die Eingabe behandelt wird, welche Art von Filterung durchgeführt wird, welche Zeichen die Anwendung nicht durchlässt und wie viele Codierungsarten berücksichtigt werden.",
-      "009": "Webanwendungen verwenden Datenbanken stark zum Speichern und Zugreifen auf die Daten, die sie für ihren Betrieb benötigen.\n So wie auf relationale Datenbanken über die SQL-Sprache zugegriffen wird, verwenden XML-Datenbanken XPath als Standardabfragesprache.\n\n XPath ist eine Sprache, die hauptsächlich entworfen und entwickelt wurde, um Teile eines XML-Dokuments zu adressieren. Beim XPath-Injection-Test testen wir, ob es möglich ist, XPath-Syntax in eine von der Anwendung interpretierte Anfrage einzufügen, sodass ein Angreifer benutzergesteuerte XPath-Abfragen ausführen kann.\n XPath ist sogar noch leistungsfähiger als Standard-SQL, da seine gesamte Leistungsfähigkeit bereits in seinen Spezifikationen vorhanden ist, während eine große Anzahl der Techniken, die bei einem SQL-Injection-Angriff verwendet werden können, von den Eigenschaften des SQL-Dialekts abhängen, der von der Zieldatenbank verwendet wird.\n\n Das XPath-Angriffsmuster ist der üblichen SQL-Injektion sehr ähnlich, und wie bei einem gewöhnlichen SQL-Injection-Angriff besteht der erste Schritt bei der XPath-Injektion darin, ein einfaches Anführungszeichen (') in das zu testende Feld einzufügen, wodurch ein Syntaxfehler in das Feld eingeführt wird abzufragen und zu prüfen, ob die Anwendung eine Fehlermeldung zurückgibt.",
-      "010": "Diese Bedrohung betrifft alle Anwendungen, die mit Mailservern (IMAP/SMTP) kommunizieren, im Allgemeinen Webmail-Anwendungen. Das Ziel dieses Tests besteht darin, die Fähigkeit zu überprüfen, beliebige IMAP/SMTP-Befehle in die Mailserver einzufügen, da Eingabedaten nicht ordnungsgemäß bereinigt werden.\n\n Eine IMAP/SMTP-Injection ermöglicht den Zugriff auf einen Mailserver, der sonst nicht direkt aus dem Internet erreichbar wäre. In einigen Fällen verfügen diese internen Systeme nicht über das gleiche Maß an Infrastruktursicherheit und Härtung, das auf die Front-End-Webserver angewendet wird. Daher sind Mailserver-Ergebnisse möglicherweise anfälliger für Angriffe durch Endbenutzer.\n\n Die Standardangriffsmuster sind:\n • Identifizieren anfälliger Parameter\n • Verstehen des Datenflusses und der Bereitstellungsstruktur des Clients\n • IMAP/SMTP-Befehlsinjektion\n\n Diese letzte Phase hat zwei mögliche Ergebnisse:\n\n Ergebnis 1:\n Die Injektion ist in einem nicht authentifizierten Zustand möglich: Die betroffene Funktionalität erfordert keine Authentifizierung des Benutzers.\n Die verfügbaren injizierten (IMAP)-Befehle sind beschränkt auf: \nCAPABILITY, NOOP, AUTHENTICATE, LOGIN und LOGOUT.\n\n Ergebnis 2:\n Die Injektion ist nur in einem authentifizierten Zustand möglich: Die erfolgreiche Ausnutzung erfordert, dass der Benutzer vollständig authentifiziert ist, bevor der Test fortgesetzt werden kann.\n\n In jedem Fall sieht der typische Aufbau einer IMAP/SMTP-Injection wie folgt aus:\n • Header: Ende des erwarteten Befehls;\n • Body: Injektion des neuen Befehls;\n • Footer: Anfang des erwarteten Befehls.",
-      "011": "Beim Code-Injection-Test übermittelt ein Tester Eingaben, die vom Webserver als dynamischer Code oder als eingebundene Datei verarbeitet werden. Diese Tests können auf verschiedene serverseitige Scripting-Engines abzielen, z. B. ASP oder PHP. Zum Schutz vor diesen Angriffen müssen eine ordnungsgemäße Eingabevalidierung und sichere Codierungspraktiken angewendet werden.\n\n Testen auf PHP-Injection-Schwachstellen\n Unter Verwendung der Abfragezeichenfolge kann der Tester Code einfügen, der als Teil der enthaltenen Datei verarbeitet werden soll. Die schädliche URL wird als Parameter für die PHP-Seite akzeptiert, die später den Wert in einer eingebundenen Datei verwendet.\n\n Testen auf ASP-Code-Injection-Schwachstellen\n Untersuchen Sie den ASP-Code auf Benutzereingaben, die in Ausführungsfunktionen verwendet werden.\nKann der Benutzer Befehle in das Dateneingabefeld eingeben?",
-      "011_1": "Die Schwachstelle „File Inclusion“ ermöglicht es einem Angreifer, eine Datei einzufügen, wobei er normalerweise einen „dynamischen Dateieinschluss“-Mechanismus ausnutzt, der in der Zielanwendung implementiert ist. Die Sicherheitsanfälligkeit tritt aufgrund der Verwendung von Benutzereingaben ohne ordnungsgemäße Überprüfung auf.\n\n Dies kann dazu führen, dass der Inhalt der Datei ausgegeben wird, aber je nach Schweregrad kann es auch zu Folgendem führen:\n • Codeausführung auf dem Webserver\n • Code-Ausführung auf der Client-Seite wie JavaScript, was zu anderen Angriffen wie Cross-Site-Scripting (XSS) führen kann.\n • Dienstverweigerung (DoS)\n • Offenlegung sensibler Informationen\n\n Local File Inclusion (auch bekannt als LFI) ist der Prozess des Einschließens von Dateien, die bereits lokal auf dem Server vorhanden sind, durch Ausnutzung von angreifbaren Einschlussverfahren.\n Da LFI auftritt, wenn Pfade, die an „include“-Anweisungen übergeben werden, nicht ordnungsgemäß bereinigt werden, sollten wir in einem Blackbox-Testansatz nach Skripten suchen, die Dateinamen als Parameter verwenden.",
-      "011_2": "Die Schwachstelle „File Inclusion“ ermöglicht es einem Angreifer, eine Datei einzufügen, wobei er normalerweise einen „dynamischen Dateieinschluss“-Mechanismus ausnutzt, der in der Zielanwendung implementiert ist. Die Sicherheitsanfälligkeit tritt aufgrund der Verwendung von Benutzereingaben ohne ordnungsgemäße Überprüfung auf.\n\n Dies kann dazu führen, dass der Inhalt der Datei ausgegeben wird, aber je nach Schweregrad kann es auch zu Folgendem führen:\n • Codeausführung auf dem Webserver\n • Code-Ausführung auf der Client-Seite wie JavaScript, was zu anderen Angriffen wie Cross-Site-Scripting (XSS) führen kann.\n • Dienstverweigerung (DoS)\n • Offenlegung sensibler Informationen\n\n Remote File Inclusion (auch bekannt als RFI) ist der Prozess des Einschließens von Remote-Dateien durch die Ausnutzung von anfälligen Einschlussverfahren.\n\n Da RFI auftritt, wenn Pfade, die an „include“-Anweisungen übergeben werden, nicht ordnungsgemäß bereinigt werden, sollten wir in einem Blackbox-Testansatz nach Skripten suchen, die Dateinamen als Parameter verwenden.",
-      "012": "OS Command Injection ist eine Technik, die über eine Webschnittstelle verwendet wird, um OS-Befehle auf einem Webserver auszuführen. Der Benutzer liefert Betriebssystembefehle über eine Webschnittstelle, um OS-Befehle auszuführen. Jede nicht ordnungsgemäß bereinigte Weboberfläche ist von diesem Exploit betroffen.\n\n Beim Anzeigen einer Datei in einer Webanwendung wird der Dateiname häufig in der URL angezeigt. Perl ermöglicht die Weiterleitung von Daten aus einem Prozess in eine offene Anweisung. Der Benutzer kann einfach das Pipe-Symbol „|“ anhängen. am Ende des Dateinamens.\n Das Anhängen eines Semikolons an das Ende einer URL für eine .PHP-Seite, gefolgt von einem Betriebssystembefehl, führt den Befehl aus. %3B ist URL-kodiert und wird in Semikolon dekodiert.",
-      "013": "Eine Format String ist eine mit Null endende Zeichenfolge, die auch Konvertierungsspezifizierer enthält, die zur Laufzeit interpretiert oder konvertiert werden. Wenn serverseitiger Code die Eingabe eines Benutzers mit einer Formatzeichenfolge verkettet, kann ein Angreifer zusätzliche Konvertierungsspezifizierer anhängen, um einen Laufzeitfehler, die Offenlegung von Informationen oder einen Pufferüberlauf zu verursachen.\n\nBewerten Sie, ob das Einfügen von Konvertierungsspezifizierern für Formatzeichenfolgen in benutzergesteuerte Felder zu unerwünschtem Verhalten der Anwendung führt.\n\nDer schlimmste Fall von Sicherheitslücken bei Formatzeichenfolgen tritt in Sprachen auf, die keine Argumente prüfen und außerdem einen %n-Spezifizierer enthalten, der in den Speicher schreibt. Wenn diese Funktionen von einem Angreifer ausgenutzt werden, der eine Formatzeichenfolge ändert, kann dies zur Offenlegung von Informationen und zur Codeausführung führen:\n• C und C++ printf und ähnliche Methoden fprintf, sprintf, snprintf\n• Perl printf und sprintf\n\nDiese Formatzeichenfolgenfunktionen können nicht in den Speicher schreiben, Angreifer können jedoch dennoch die Offenlegung von Informationen verursachen, indem sie Formatzeichenfolgen so ändern, dass sie Werte ausgeben, die die Entwickler nicht senden wollten.\nDie folgenden Format String Funktionen können Laufzeitfehler verursachen, wenn der Angreifer Konvertierungsspezifizierer hinzufügt:\n• Java String.format und PrintStream.format\n• PHP printf\n\nZu den Tests gehören die Analyse des Codes und das Einfügen von Konvertierungsspezifizierern als Benutzereingabe in die zu testende Anwendung.",
-      "014": "Inkubationstests werden auch oft als dauerhafte Angriffe bezeichnet und sind eine komplexe Testmethode, die mehr als eine Schwachstelle zur Datenvalidierung benötigt, um zu funktionieren.\n Inkubierte Schwachstellen werden normalerweise verwendet, um „Watering Hole“-Angriffe gegen Benutzer legitimer Webanwendungen durchzuführen.\n\n Inkubierte Schwachstellen haben die folgenden Merkmale:\n\n Zuerst:\n Der Angriffsvektor muss in erster Linie persistiert werden, er muss in der Persistenzschicht gespeichert werden, und dies würde nur auftreten, wenn eine schwache Datenvalidierung vorhanden wäre oder die Daten über einen anderen Kanal wie eine Verwaltungskonsole oder direkt in das System gelangen über einen Backend-Batch-Prozess.\n\n Zweitens:\n  Sobald der Angriffsvektor „zurückgerufen“ wurde, musste der Vektor erfolgreich ausgeführt werden. Beispielsweise würde ein inkubierter XSS-Angriff eine schwache Ausgabevalidierung erfordern, damit das Skript in seiner ausführbaren Form an den Client geliefert wird.\n\n Die Ausnutzung einiger Schwachstellen oder sogar Funktionsmerkmale einer Webanwendung ermöglicht es einem Angreifer, Daten einzuschleusen, die später abgerufen werden.\n In einem Penetrationstest können inkubierte Angriffe verwendet werden, um die Kritikalität bestimmter Fehler zu bewerten, die normalerweise verwendet werden, um eine große Anzahl von Opfern gleichzeitig anzugreifen.\n\n Diese Art von asynchronen Angriffen deckt ein großes Spektrum an Angriffsvektoren ab, darunter die folgenden:\n • Datei-Upload-Komponenten in einer Webanwendung\n • Cross-Site-Scripting-Probleme in öffentlichen Forenbeiträgen\n • SQL/XPATH-Injection, die es dem Angreifer ermöglicht, Inhalte in eine Datenbank hochzuladen\n • Falsch konfigurierte Server, die die Installation von Paketen oder Komponenten ermöglichen\n\n Schritt 1:\n Überprüfen Sie den Inhaltstyp, der zum Hochladen in die Webanwendung zugelassen ist, und die resultierende URL für die hochgeladene Datei.\n\n Schritt 2:\n Laden Sie eine Datei hoch, die eine Komponente auf der lokalen Benutzerarbeitsstation ausnutzt, wenn sie vom Benutzer angezeigt oder heruntergeladen wird.\n\n Schritt 3:\n Senden Sie Ihrem Opfer eine E-Mail oder eine andere Art von Benachrichtigung, um ihn/sie dazu zu bringen, die Seite zu durchsuchen.\n\n Das erwartete Ergebnis ist, dass der Exploit ausgelöst wird, wenn der Benutzer die resultierende Seite durchsucht oder die Datei von der vertrauenswürdigen Site herunterlädt und ausführt.",
-      "015": "Es gibt zwei verschiedene Angriffe, die auf bestimmte HTTP-Header abzielen:\n• HTTP-Splitting\n• HTTP-Smuggling\n\n Der erste Angriff nutzt einen Mangel an Eingabebereinigung aus, wodurch ein Eindringling CR- und LF-Zeichen in die Header der Anwendungsantwort einfügen und diese Antwort in zwei verschiedene HTTP-Nachrichten „aufteilen“ kann.\n Das Ziel des Angriffs kann von Cache-Poisoning bis hin zu Cross-Site-Scripting reichen.\n\n Beim zweiten Angriff nutzt der Angreifer die Tatsache aus, dass einige speziell gestaltete HTTP-Nachrichten je nach Agent, der sie empfängt, auf unterschiedliche Weise analysiert und interpretiert werden können.\nHTTP-Schmuggel erfordert ein gewisses Maß an Wissen über die verschiedenen Agenten, die die HTTP-Nachrichten verarbeiten (Webserver, Proxy, Firewall).\n\n HTTP-Splitting\n Einige Webanwendungen verwenden einen Teil der Benutzereingaben, um die Werte einiger Header ihrer Antworten zu generieren. Das einfachste Beispiel sind Umleitungen, bei denen die Ziel-URL von einem vom Benutzer übermittelten Wert abhängt.\n Die Header, die die wahrscheinlichsten Kandidaten für diesen Angriff sind, sind:\n• Location\n• Set-Cookie\n\n  HTTP-Smuggling\n Dies nutzt die verschiedenen Möglichkeiten, wie eine speziell gestaltete HTTP-Nachricht von verschiedenen Agenten (Browsern, Webcaches, Anwendungsfirewalls) analysiert und interpretiert werden kann.",
-      "016": "In diesem Abschnitt wird beschrieben, wie Sie alle eingehenden/ausgehenden HTTP-Anfragen sowohl auf der Client- als auch auf der Serverseite überwachen. Der Zweck dieser Tests besteht darin, zu überprüfen, ob im Hintergrund unnötige oder verdächtige HTTP-Anfragen gesendet werden.\n\nDie meisten Web-Sicherheitstesttools (z. B. AppScan, BurpSuite, ZAP) fungieren als HTTP-Proxy. Dies erfordert Änderungen des Proxys in der clientseitigen Anwendung oder im Browser. Die unten aufgeführten Testtechniken konzentrieren sich in erster Linie darauf, wie wir HTTP-Anfragen ohne Änderungen auf der Clientseite überwachen können, was eher dem Produktionsszenario entspricht.\n\nTestziele\n• Überwachen Sie alle eingehenden und ausgehenden HTTP-Anfragen an den Webserver, um verdächtige Anfragen zu untersuchen.\n• Überwachen Sie den HTTP-Verkehr ohne Änderungen am Browser-Proxy des Endbenutzers oder an der clientseitigen Anwendung.\n\nSo testen Sie\nEs gibt eine Situation, in der wir alle eingehenden HTTP-Anfragen auf dem Webserver überwachen möchten, aber die Konfiguration auf der Browser- oder Anwendungsclientseite nicht ändern können. In diesem Szenario können wir auf der Webserverseite einen Reverse-Proxy einrichten, um alle eingehenden/ausgehenden Anfragen auf dem Webserver zu überwachen:\n• Für die Windows-Plattform wird Fiddler empfohlen.\n• Für die Linux-Plattform kann Charles Web Debugging Proxy verwendet werden.\n\nDie Testschritte:\n1. Installieren Sie Fiddler oder Charles auf dem Webserver\n2. Konfigurieren Sie den Fiddler oder Charles als Reverse Proxy\n3. Erfassen Sie den HTTP-Verkehr\n4. Untersuchen Sie den HTTP-Verkehr\n5. Ändern Sie HTTP-Anforderungen und spielen Sie die geänderten Anforderungen zum Testen erneut ab",
-      "017": "Ein Webserver hostet üblicherweise mehrere Webanwendungen unter derselben IP-Adresse und verweist über den virtuellen Host auf jede Anwendung. Bei einer eingehenden HTTP-Anfrage leiten Webserver die Anfrage häufig basierend auf dem im Host-Header bereitgestellten Wert an den virtuellen Zielhost weiter. Ohne ordnungsgemäße Validierung des Header-Werts kann der Angreifer ungültige Eingaben liefern, die den Webserver dazu veranlassen:\n• Senden Sie Anfragen an den ersten virtuellen Host in der Liste\n• eine Weiterleitung zu einer vom Angreifer kontrollierten Domäne verursachen\n• Web-Cache-Poisoning durchführen\n• die Funktionalität zum Zurücksetzen des Passworts manipulieren\n\nTestziele\n• Bewerten Sie, ob der Host-Header in der Anwendung dynamisch analysiert wird.\n• Umgehen Sie Sicherheitskontrollen, die auf dem Header basieren\n\nSo testen Sie\nDer erste Test ist so einfach wie die Angabe einer anderen Domain (z. B. attacker.com ) im Host-Header-Feld. Die Art und Weise, wie der Webserver den Header-Wert verarbeitet, bestimmt die Auswirkung. Der Angriff ist gültig, wenn der Webserver die Eingabe verarbeitet, um die Anforderung an einen vom Angreifer kontrollierten Host zu senden, der sich in der angegebenen Domäne befindet, und nicht an einen internen virtuellen Host, der sich auf dem Webserver befindet.\n\nWeitere Angriffe\n• X-Forwarded-Host-Header-Bypass\n• Web-Cache-Poisoning\n• Passwort-Reset-Poisoning",
-      "018": "Webanwendungen nutzen üblicherweise serverseitige Template-Technologien (Jinja2, Twig, FreeMaker usw.), um dynamische HTML-Antworten zu generieren. Serverseitige Template-Injection-Schwachstellen (SSTI) treten auf, wenn Benutzereingaben auf unsichere Weise in eine Vorlage eingebettet werden und zur Remote-Codeausführung auf dem Server führen.\n\nAlle Funktionen, die erweitertes, vom Benutzer bereitgestelltes Markup unterstützen, können für SSTI anfällig sein, einschließlich Wiki-Seiten, Rezensionen, Marketinganwendungen, CMS-Systeme usw. Einige Template-Engines verwenden verschiedene Mechanismen (z. B. Sandbox, Zulassungsliste usw.), um vor SSTI zu schützen.\n\nTestziele\n• Erkennen Sie Schwachstellen bei der Template-Injection.\n• Identifizieren Sie die Template-Engine.\n• Erstellen Sie den Exploit.\n\nSo testen Sie\n• Identifizieren Sie die Schwachstelle durch Template-Injection\n• Identifizieren Sie die Templating Engine\n• Erstellen Sie den RCE-Exploit",
-      "019": "Webanwendungen interagieren häufig mit internen oder externen Ressourcen. Während Sie davon ausgehen können, dass nur die vorgesehene Ressource die von Ihnen gesendeten Daten verarbeitet, kann eine unsachgemäße Verarbeitung der Daten dazu führen, dass Injektionsangriffe möglich sind. Eine Art von Injektionsangriff wird als Server-side Request Forgery (SSRF) bezeichnet.\n\nEin erfolgreicher SSRF-Angriff kann dem Angreifer Zugriff auf eingeschränkte Aktionen, interne Dienste oder interne Dateien innerhalb der Anwendung oder der Organisation gewähren. In einigen Fällen kann es sogar zu Remote Code Execution (RCE) kommen.\n\nTestziele\n• Identifizieren Sie SSRF-Injektionspunkte.\n• Testen Sie, ob die Einspritzpunkte ausnutzbar sind.\n• Bewertet den Schweregrad der Schwachstelle.\n\nSo testen Sie\n• Laden Sie den Inhalt einer Datei\n• Greifen Sie auf eine eingeschränkte Seite zu\n• Holen Sie sich eine lokale Datei\n\nÜbliche Filterumgehung\nManchmal lässt die Anwendung Eingaben zu, die einem bestimmten Ausdruck entsprechen, z. B. einer Domäne. Dies kann umgangen werden, wenn der URL-Schema-Parser nicht ordnungsgemäß implementiert ist, was zu Angriffen führt, die semantischen Angriffen ähneln.\n• Verwenden des @-Zeichens zur Trennung zwischen Benutzerinformationen und Host: https://expected-domain@attackerdomain\n• URL-Fragmentierung mit dem #-Zeichen: https://attacker-domain#expected-domain\n• URL-Kodierung\n• Fuzzing\n• Kombinationen aus allen oben genannten"
-    },
-    "err": {
-      "001": "Während eines Penetrationstests für Webanwendungen stoßen wir häufig auf viele Fehlercodes, die von Anwendungen oder Webservern generiert werden.\n Es ist möglich, dass diese Fehler angezeigt werden, indem bestimmte Anfragen verwendet werden, die entweder speziell mit Tools erstellt oder manuell erstellt wurden. Diese Codes sind für Penetrationstester bei ihren Aktivitäten sehr nützlich, da sie viele Informationen über Datenbanken, Fehler und andere technologische Komponenten preisgeben, die direkt mit Webanwendungen verknüpft sind.\n\n  Eine gute Sammlung von Fehlerinformationen kann die Bewertungseffizienz verbessern, indem die Gesamtzeit für die Durchführung des Penetrationstests verkürzt wird.\n Angreifer verwenden manchmal Suchmaschinen, um Fehler zu finden, die Informationen preisgeben. Es können Suchvorgänge durchgeführt werden, um fehlerhafte Websites als zufällige Opfer zu finden, oder es ist möglich, mit den Filterwerkzeugen der Suchmaschine nach Fehlern auf einer bestimmten Website zu suchen.\n\n Nachfolgend sind einige Bereiche aufgeführt, die dem Benutzer detaillierte Fehlermeldungen zurückgeben könnten. Jeder der Bereiche enthält spezifische Informationen über das Betriebssystem, die Anwendungsversion usw.\n • Webserverfehler (HTTP-Antworten)\n • Anwendungsserverfehler (Framework-Meldungen)\n • Datenbankfehler (Datenbanksystemmeldungen)",
-      "002": "Stack-Traces sind an sich keine Schwachstellen, aber sie offenbaren oft Informationen, die für einen Angreifer interessant sind. Angreifer versuchen, diese Stack-Traces zu generieren, indem sie die Eingabe in die Webanwendung mit fehlerhaften HTTP-Anforderungen und anderen Eingabedaten manipulieren.\n\n Wenn die Anwendung mit nicht verwalteten Stack-Traces antwortet, können für Angreifer nützliche Informationen preisgegeben werden. Diese Informationen könnten dann für weitere Angriffe verwendet werden.\n\n Es gibt eine Vielzahl von Techniken, die dazu führen, dass Ausnahmemeldungen in einer HTTP-Antwort gesendet werden. Beachten Sie, dass dies in den meisten Fällen eine HTML-Seite ist, aber Ausnahmen können auch als Teil von SOAP- oder REST-Antworten gesendet werden.\nEinige Tests zum Ausprobieren umfassen:\n • Ungültige Eingabe\n • Eingaben, die nicht alphanumerische Zeichen oder Abfragesyntax enthalten\n • leere Eingänge\n • zu lange Eingaben\n • Zugriff auf interne Seiten ohne Authentifizierung\n • Umgehung des Anwendungsflusses\n\n Alle oben genannten Tests können zu Anwendungsfehlern führen, die Stack-Traces enthalten können. Es wird empfohlen, zusätzlich zu manuellen Tests einen Fuzzer zu verwenden.\n\n Wenn der SSL/TLS-Dienst vorhanden ist, ist er gut, aber er erhöht die Angriffsfläche und die folgenden Schwachstellen bestehen:\n • SSL/TLS-Protokolle, Chiffren, Schlüssel und Neuverhandlung müssen ordnungsgemäß konfiguriert sein\n • Zertifikatsgültigkeit muss gewährleistet sein"
-    },
-    "crypst": {
-      "001": "Sensible Daten müssen geschützt werden, wenn sie durch das Netzwerk übertragen werden. \nAls Faustregel gilt: Wenn Daten bei der Speicherung geschützt werden müssen, müssen sie auch während der Übertragung geschützt werden.\n\n Verschiedene Arten von zu schützenden Informationen können auch im Klartext übertragen werden. Es kann überprüft werden, ob diese Informationen über HTTP statt HTTPS übertragen werden.\n\n HTTP ist ein Klartextprotokoll und wird normalerweise über einen SSL/TLS-Tunnel gesichert, was zu HTTPS-Datenverkehr führt. Server werden mit digitalen Zertifikaten authentifiziert, und es ist auch möglich, Client-Zertifikate für die gegenseitige Authentifizierung zu verwenden.\n Selbst wenn heute hochwertige Chiffren unterstützt und normalerweise verwendet werden, kann eine Fehlkonfiguration im Server dazu verwendet werden, die Verwendung einer schwachen Chiffre – oder schlimmstenfalls gar keine Verschlüsselung – zu erzwingen, die es einem Angreifer ermöglicht, Zugang zu dem vermeintlich sicheren Kommunikationskanal zu erhalten.\n\n Häufige Probleme:\n Wenn der SSL/TLS-Dienst vorhanden ist, ist er gut, aber er erhöht die Angriffsfläche und die folgenden Schwachstellen bestehen:\n • SSL/TLS-Protokolle, Chiffren, Schlüssel und Neuverhandlung müssen ordnungsgemäß konfiguriert sein\n • Zertifikatsgültigkeit muss gewährleistet sein\n • Offengelegte Software muss aufgrund möglicher bekannter Schwachstellen aktualisiert werden\n • Verwendung des Secure-Flags für Sitzungscookies\n • Verwendung von HTTP Strict Transport Security (HSTS)\n • Das Vorhandensein von HTTP und HTTPS, die zum Abfangen von Datenverkehr verwendet werden können\n • Das Vorhandensein gemischter HTTPS- und HTTP-Inhalte auf derselben Seite, die zum Leaking von Informationen verwendet werden können \n\n Prüfung auf sensible Daten, die im Klartext übertragen werden\n Ein typisches Beispiel ist die Verwendung der Basisauthentifizierung über HTTP, da bei der Basisauthentifizierung die Anmeldeinformationen nach der Anmeldung in HTTP-Header codiert – und nicht verschlüsselt – werden.\n\n Testen auf schwache SSL/TLS-Chiffren/Protokolle/Schlüssel-Schwachstellen\n Die große Anzahl verfügbarer Cipher Suites und der schnelle Fortschritt in der Kryptoanalyse machen das Testen eines SSL-Servers zu einer nicht trivialen Aufgabe. Zum Zeitpunkt des Schreibens sind diese Kriterien eine allgemein anerkannte Checkliste:\n • Schwache Chiffren dürfen nicht verwendet werden (z. B. weniger als 128 Bit)\n • Keine NULL-Ciphers-Suite, da keine Verschlüsselung verwendet wird\n • Schwache Protokolle müssen deaktiviert werden (z. B. muss SSLv2 deaktiviert werden)\n • Die Neuverhandlung muss ordnungsgemäß konfiguriert sein (z. B. muss die unsichere Neuverhandlung deaktiviert sein).\n • Keine Verschlüsselungssammlungen auf Exportebene (EXP), da diese leicht geknackt werden können\n • Die Schlüssellänge von X.509-Zertifikaten muss stark sein\n • X.509-Zertifikate dürfen nur mit sicheren Hash-Algorithmen signiert werden\n • Schlüssel müssen mit der richtigen Entropie generiert werden\n • Sichere Neuverhandlung sollte aktiviert sein.\n • MD5 sollte aufgrund bekannter Kollisionsangriffe nicht verwendet werden\n • RC4 sollte wegen kryptoanalytischer Angriffe nicht verwendet werden\n • Der Server sollte vor BEAST-Angriffen geschützt werden\n • Der Server sollte vor CRIME-Angriffen geschützt werden, die TLS-Komprimierung muss deaktiviert werden\n • Der Server sollte Forward Secrecy unterstützen",
-      "002": "Ein Padding-Oracle ist eine Funktion einer Anwendung, die vom Client bereitgestellte verschlüsselte Daten entschlüsselt, z. interner Sitzungsstatus, der auf dem Client gespeichert ist, und gibt den Status der Gültigkeit der Auffüllung nach der Entschlüsselung preis.\n\n Die Existenz eines Padding-Oracles ermöglicht es einem Angreifer, verschlüsselte Daten zu entschlüsseln und willkürliche Daten zu verschlüsseln, ohne den Schlüssel zu kennen, der für diese kryptografischen Operationen verwendet wird.\n\n Blockchiffren verschlüsseln Daten nur in Blöcken bestimmter Größe. Die von gängigen Chiffren verwendeten Blockgrößen sind 8 und 16 Bytes. Daten, deren Größe nicht mit einem Vielfachen der Blockgröße der verwendeten Chiffre übereinstimmt, müssen auf bestimmte Weise aufgefüllt werden, damit der Entschlüsseler die Auffüllung entfernen kann.\n\n Der Padding-Oracle-Angriff ermöglicht es einem Angreifer, verschlüsselte Daten ohne Kenntnis des Verschlüsselungsschlüssels und der verwendeten Chiffre zu entschlüsseln, indem er geschickt manipulierte Chiffriertexte an das Padding-Oracle sendet und die von ihm zurückgegebenen Ergebnisse beobachtet. Dies führt zu einem Verlust der Vertraulichkeit der verschlüsselten Daten.\n Ein Padding-Oracle-Angriff ermöglicht es einem Angreifer auch, beliebige Klartexte ohne Kenntnis des verwendeten Schlüssels und der Chiffre zu verschlüsseln.\n\n Zunächst müssen die möglichen Eingabepunkte für ein Padding-Oracle identifiziert werden. Generell müssen folgende Bedingungen erfüllt sein:\n\n Bedingung 1:\n Die Daten sind verschlüsselt. Gute Kandidaten sind Werte, die zufällig erscheinen.\n\n Bedingung 2:\n Es wird eine Blockchiffre verwendet. Die Länge des decodierten (z. B. Base64) Chiffriertextes ist ein Vielfaches der üblichen Chiffrierblockgrößen wie 8 oder 16 Bytes. Verschiedene Chiffriertexte haben einen gemeinsamen Teiler in der Länge.\n\n Wenn ein solcher Eingabewertkandidat identifiziert wird, sollte das Verhalten der Anwendung gegenüber einer bitweisen Manipulation des verschlüsselten Werts überprüft werden.\n Die Tests und der Basiswert sollten mindestens drei verschiedene Zustände während und nach der Entschlüsselung bewirken:\n • Geheimtext wird entschlüsselt, Ergebnisdaten sind korrekt\n • Chiffrierter Text wird entschlüsselt, resultierende Daten werden verstümmelt und verursachen eine Ausnahme- oder Fehlerbehandlung in der Anwendungslogik\n • Die Chiffretext-Entschlüsselung schlägt aufgrund von Padding-Fehlern fehl\n\n Suchen Sie insbesondere nach Ausnahmen und Meldungen, die besagen, dass etwas mit dem Padding nicht stimmt. Wenn die drei oben beschriebenen unterschiedlichen Zustände implizit beobachtbar sind (unterschiedliche Fehlermeldungen, Timing-Seitenkanäle), liegt mit hoher Wahrscheinlichkeit an dieser Stelle ein Padding-Oracle vor. Beispiele:\n • ASP.NET löst „System.Security.Cryptography.Cryptographic Exception: Padding is invalid and can not be remove“ aus.\n • In Java wird in diesem Fall eine javax.crypto.BadPaddingException geworfen\n • Entschlüsselungsfehler oder ähnliches können mögliche padding oracles sein",
-      "003": "Sensible Daten müssen geschützt werden, wenn sie durch das Netzwerk übertragen werden. Wenn Daten über HTTPS übertragen oder auf andere Weise verschlüsselt werden, darf der Schutzmechanismus keine Einschränkungen oder Schwachstellen aufweisen.\n\n Als Faustregel gilt: Wenn Daten bei der Speicherung geschützt werden müssen, müssen diese Daten auch bei der Übertragung geschützt werden. \n Einige Beispiele für sensible Daten sind:\n • Bei der Authentifizierung verwendete Informationen (z. B. Anmeldeinformationen, PINs, Tokens, Cookies …)\n • Informationen, die durch Gesetze, Vorschriften oder spezifische Unternehmensrichtlinien geschützt sind (z. B. Kreditkarten, Kundendaten)\n\n Verschiedene Arten von Informationen, die geschützt werden müssen, könnten von der Anwendung im Klartext übertragen werden. Es kann überprüft werden, ob diese Informationen über HTTP statt HTTPS übertragen werden oder ob schwache Chiffren verwendet werden.\n\n 1. Basisauthentifizierung über HTTP\n Ein typisches Beispiel ist die Verwendung von Basic Authentication über HTTP. Bei Verwendung der Standardauthentifizierung werden Benutzeranmeldeinformationen codiert und nicht verschlüsselt und als HTTP-Header gesendet.\n\n 2. Formularbasierte Authentifizierung über HTTP durchgeführt\n Ein weiteres typisches Beispiel sind Authentifizierungsformulare, die Anmeldeinformationen zur Benutzerauthentifizierung über HTTP übertragen. Es ist möglich, dieses Problem zu sehen, indem Sie den HTTP-Datenverkehr mit einem Interception-Proxy untersuchen.\n\n 3. Cookie mit Sitzungs-ID, das über HTTP gesendet wird\n Das Session-ID-Cookie muss über geschützte Kanäle übertragen werden. Wenn für das Cookie kein sicheres Flag gesetzt ist, ist es der Anwendung gestattet, es unverschlüsselt zu übertragen.",
-      "004": "Die falsche Verwendung von Verschlüsselungsalgorithmen kann zur Offenlegung vertraulicher Daten, zum Verlust von Schlüsseln, zur fehlerhaften Authentifizierung, zu unsicheren Sitzungen und zu Spoofing-Angriffen führen. Es gibt einige Verschlüsselungs- oder Hash-Algorithmen, von denen bekannt ist, dass sie schwach sind und deren Verwendung nicht empfohlen wird, beispielsweise MD5 und RC4.\n\nNeben der richtigen Auswahl sicherer Verschlüsselungs- oder Hash-Algorithmen ist auch die richtige Verwendung von Parametern für das Sicherheitsniveau von Bedeutung. Beispielsweise wird der ECB-Modus (Electronic Code Book) nicht für die Verwendung bei der asymmetrischen Verschlüsselung empfohlen.\n\nTestziele\n• Bereitstellung einer Richtlinie zur Identifizierung schwacher Verschlüsselungs- oder Hashing-Anwendungen und -Implementierungen.\n\nGrundlegende Sicherheitscheckliste\n• Bei Verwendung von AES128 oder AES256 muss der IV (Initialisierungsvektor) zufällig und unvorhersehbar sein.\n• Für asymmetrische Verschlüsselung verwenden Sie vorzugsweise Elliptic Curve Cryptography (ECC) mit einer sicheren Kurve wie Curve25519.\n• Bei Verwendung von RSA in der Signatur wird PSS-Padding empfohlen.\n• Schwache Hash-/Verschlüsselungsalgorithmen wie MD5, RC4, DES, Blowfish, SHA1 sollten nicht verwendet werden.\n• Passwort-Hashing: PBKDF2, Scrypt, Bcrypt\n• Verwendungen von SSH, CBC-Modus sollten nicht verwendet werden.\n• Wenn ein symmetrischer Verschlüsselungsalgorithmus verwendet wird, sollte der ECB-Modus (Electronic Code Book) nicht verwendet werden.\n• Wenn PBKDF2 zum Hashen von Passwörtern verwendet wird, wird empfohlen, dass der Iterationsparameter über 10.000 liegt."
-    },
-    "buslogic": {
-      "001": "Die Anwendung muss sicherstellen, dass nur logisch gültige Daten sowohl am Frontend als auch direkt auf der Serverseite eines Anwendungssystems eingegeben werden können. Daten nur lokal zu verifizieren, kann Anwendungen anfällig für Serverinjektionen durch Proxys oder bei Übergaben an andere Systeme machen. Dies unterscheidet sich von der einfachen Durchführung einer Boundary Value Analysis (Grenzwertanalyse) dadurch, dass sie schwieriger ist und in den meisten Fällen nicht einfach am Eingangspunkt überprüft werden kann, sondern normalerweise die Überprüfung eines anderen Systems erfordert.\n\n Schwachstellen im Zusammenhang mit der Geschäftsdatenvalidierung sind insofern einzigartig, als sie anwendungsspezifisch sind und sich von den Schwachstellen im Zusammenhang mit gefälschten Anforderungen darin unterscheiden, dass sie sich mehr um logische Daten kümmern, anstatt einfach den Arbeitsablauf der Geschäftslogik zu unterbrechen.\n\n Das Front-End und das Back-End der Anwendung sollten überprüfen und validieren, dass die Daten, die sie hat, verwendet und weitergibt, logisch gültig sind. Selbst wenn der Benutzer einer Anwendung gültige Daten bereitstellt, kann die Geschäftslogik dazu führen, dass sich die Anwendung je nach Daten oder Umständen anders verhält.\n\n Generische Testmethode\n • Überprüfen Sie die Projektdokumentation und verwenden Sie explorative Tests, um nach Dateneingangspunkten oder Übergabepunkten zwischen Systemen oder Software zu suchen\n • Versuchen Sie, einmal gefundene logisch ungültige Daten in die Anwendung/das System einzufügen\n\n Spezifische Testmethode\n • Führen Sie funktional gültige Front-End-GUI-Tests für die Anwendung durch, um sicherzustellen, dass nur „gültige“ Werte akzeptiert werden.\n • Beobachten Sie bei Verwendung eines abfangenden Proxys HTTP POST/GET und suchen Sie nach Stellen, an denen Variablen wie Kosten und Qualität übergeben werden. Suchen Sie insbesondere nach „Übergaben“ zwischen Anwendungen/Systemen, bei denen möglicherweise Manipulationspunkte injiziert werden.\n • Sobald Variablen gefunden wurden, beginnen Sie damit, das Feld mit logisch „ungültigen“ Daten abzufragen, wie z. B. Sozialversicherungsnummern oder eindeutige Kennungen, die nicht existieren oder die nicht zur Geschäftslogik passen.\n Dieser Test überprüft, ob der Server ordnungsgemäß funktioniert und keine logisch ungültigen Daten akzeptiert.",
-      "002": "Das Fälschen von Anfragen ist eine Methode, mit der Angreifer die Front-End-GUI-Anwendung umgehen, um Informationen direkt für die Back-End-Verarbeitung zu übermitteln. Das Ziel des Angreifers besteht darin, HTTP-POST/GET-Anforderungen über einen abfangenden Proxy mit Datenwerten zu senden, die von der Geschäftslogik der Anwendung nicht unterstützt, geschützt oder erwartet werden.\n\n Schwachstellen im Zusammenhang mit der Fähigkeit, Anforderungen zu fälschen, sind für jede Anwendung einzigartig und unterscheiden sich von der Datenvalidierung der Geschäftslogik dadurch, dass der Schwerpunkt darauf liegt, den Geschäftslogik-Workflow zu unterbrechen.\n\n Die Anwendung muss intelligent genug sein und mit einer Geschäftslogik entworfen werden, die Angreifer daran hindert, Parameter vorherzusagen und zu manipulieren, um den Programm- oder Geschäftslogikfluss zu untergraben oder versteckte/undokumentierte Funktionen wie Debugging auszunutzen.\n\n Generische Testmethode\n • Überprüfen Sie die Projektdokumentation und verwenden Sie explorative Tests, um nach erratenden, vorhersagbaren oder verborgenen Funktionen von Feldern zu suchen.\n • Versuchen Sie, einmal gefundene logisch gültige Daten in die Anwendung/das System einzufügen, damit der Benutzer die Anwendung/das System gegen den normalen Arbeitsablauf der Geschäftslogik durchlaufen kann.\n\n Spezifische Testmethode 1\n • Beobachten Sie bei Verwendung eines abfangenden Proxys HTTP POST/GET und suchen Sie nach Hinweisen darauf, dass Werte in regelmäßigen Abständen inkrementiert werden oder leicht zu erraten sind.\n • Wenn sich herausstellt, dass ein Wert erraten werden kann, kann dieser Wert erraten werden\ngeändert und man kann unerwartete Sichtbarkeit erlangen.\n\n Spezifische Testmethode 2\n • Beobachten Sie bei Verwendung eines abfangenden Proxys HTTP POST/GET und suchen Sie nach Hinweisen auf versteckte Funktionen wie Debug, die ein- oder aktiviert werden können.\n • Wenn welche gefunden werden, versuchen Sie, diese Werte zu erraten und zu ändern, um eine andere Antwort oder ein anderes Verhalten der Anwendung zu erhalten.",
-      "003": "Viele Anwendungen sind so konzipiert, dass sie je nach Situation des Benutzers unterschiedliche Felder anzeigen, indem einige Eingaben ausgeblendet bleiben.\nIn vielen Fällen ist es jedoch möglich, versteckte Feldwerte mithilfe eines Proxys an den Server zu senden. In diesen Fällen müssen die serverseitigen Steuerelemente intelligent genug sein, um relationale oder serverseitige Bearbeitungen durchzuführen, um sicherzustellen, dass die richtigen Daten auf der Grundlage der benutzer- und anwendungsspezifischen Geschäftslogik für den Server zugelassen werden.\n\n Darüber hinaus darf die Anwendung nicht von nicht bearbeitbaren Steuerelementen, Dropdown-Menüs oder verborgenen Feldern für die Verarbeitung der Geschäftslogik abhängen, da diese Felder nur im Kontext der Browser nicht bearbeitbar bleiben. Benutzer können ihre Werte möglicherweise mit Proxy-Editor-Tools bearbeiten und versuchen, die Geschäftslogik zu manipulieren.\n\nSchwachstellen bei der Integritätsprüfung der Geschäftslogik sind insofern einzigartig, als diese Missbrauchsfälle anwendungsspezifisch sind und wenn Benutzer in der Lage sind, Änderungen vorzunehmen, sollten sie nur in der Lage sein, bestimmte Artefakte zu bestimmten Zeiten gemäß der Geschäftsprozesslogik zu schreiben oder zu aktualisieren/bearbeiten.\nDie Anwendung muss intelligent genug sein, um auf relationale Bearbeitungen zu prüfen, und Benutzern nicht erlauben, Informationen direkt an den Server zu senden, die ungültig sind, vertrauenswürdig sind, weil sie von nicht bearbeitbaren Steuerelementen stammen oder der Benutzer nicht berechtigt ist, sie über das Front-End zu senden.\n\n Generische Testmethode\n • Überprüfen Sie die Projektdokumentation und führen Sie explorative Tests durch, um nach Teilen der Anwendung/des Systems (z. B. Eingabefelder, Datenbanken oder Protokolle) zu suchen, die Daten/Informationen verschieben, speichern oder verarbeiten.\n • Bestimmen Sie für jede identifizierte Komponente, welche Art von Daten/Informationen logisch akzeptabel ist und vor welchen Arten die Anwendung/das System schützen sollte. Überlegen Sie auch, wer gemäß der Geschäftslogik in jeder Komponente Daten/Informationen einfügen, aktualisieren und löschen darf.\n • Versuchen Sie, die Daten-/Informationswerte mit ungültigen Daten/Informationen in jede Komponente (d. h. Eingabe, Datenbank oder Protokoll) von Benutzern einzufügen, zu aktualisieren oder zu bearbeiten, die gemäß dem Geschäftslogik-Workflow nicht zulässig sein sollten. \n\n Spezifische Testmethode 1\n • Verwenden einer Proxy-Erfassung und von HTTP-Verkehr, die nach verborgenen Feldern suchen.\n • Wenn ein verborgenes Feld gefunden wird, sehen Sie, wie sich diese Felder mit der GUI-Anwendung vergleichen, und beginnen Sie, diesen Wert über den Proxy abzufragen, indem Sie verschiedene Datenwerte senden, um den Geschäftsprozess zu umgehen und Werte zu manipulieren, auf die Sie keinen Zugriff haben sollten.\n\n Spezifische Testmethode 2\n • Verwenden einer Proxy-Erfassung und von HTTP-Verkehr, um einen Ort zu suchen, an dem Informationen in Bereiche der Anwendung eingefügt werden können, die nicht bearbeitet werden können.\n • Wenn es gefunden wird, vergleichen Sie diese Felder mit der GUI-Anwendung und beginnen Sie, diesen Wert über den Proxy abzufragen, indem Sie verschiedene Datenwerte senden, um den Geschäftsprozess zu umgehen und Werte zu manipulieren, auf die Sie keinen Zugriff haben sollten.\n\n Spezifische Testmethode 3\n • Komponenten der Anwendung oder des Systems auflisten, die bearbeitet werden könnten, z. B. Protokolle oder Datenbanken.\n • Versuchen Sie für jede identifizierte Komponente, ihre Informationen zu lesen, zu bearbeiten oder zu entfernen. Beispielsweise sollten Protokolldateien identifiziert werden und Tester sollten versuchen, die gesammelten Daten/Informationen zu manipulieren.",
-      "004": "Es ist möglich, dass Angreifer Informationen über eine Anwendung sammeln, indem sie die Zeit überwachen, die zum Ausführen einer Aufgabe oder zum Geben einer Antwort benötigt wird.\n Darüber hinaus können Angreifer möglicherweise entworfene Geschäftsprozessabläufe manipulieren und unterbrechen, indem sie einfach aktive Sitzungen offen halten und ihre Transaktionen nicht im „erwarteten“ Zeitrahmen übermitteln.\n\n Schwachstellen in der Prozesstiming-Logik sind insofern einzigartig, als diese manuellen Missbrauchsfälle unter Berücksichtigung des anwendungs-/systemspezifischen Ausführungs- und Transaktionstimings erstellt werden sollten.\nDas Verarbeitungstiming kann Informationen darüber geben/durchsickern lassen, was in den Hintergrundprozessen der Anwendung/des Systems getan wird. Wenn eine Anwendung es Benutzern ermöglicht, durch die Verarbeitung von Zeitvariationen zu erraten, was das nächste Ergebnis sein wird, können Benutzer sich entsprechend anpassen und das Verhalten ändern.\n\n So testen Sie #1 \n Überprüfen Sie die Projektdokumentation und verwenden Sie explorative Tests, um nach Anwendungs-/Systemfunktionen zu suchen, die sich mit der Zeit auswirken könnten. Beispielsweise die Ausführungszeit oder Aktionen, die Benutzern helfen, ein zukünftiges Ergebnis vorherzusagen, oder die es einem ermöglichen, einen Teil der Geschäftslogik oder des Workflows zu umgehen.\n Zum Beispiel Transaktionen nicht in einer erwarteten Zeit abschließen.\n\n So testen Sie #2 \n Entwickeln Sie Missbrauchsfälle und führen Sie sie aus, um sicherzustellen, dass Angreifer keinen Vorteil basierend auf einem beliebigen Timing erlangen können.",
-      "005": "Viele der Probleme, die Anwendungen lösen, erfordern Begrenzungen der Häufigkeit, mit der eine Funktion verwendet oder eine Aktion ausgeführt werden kann. Anwendungen müssen „intelligent genug“ sein, um es dem Benutzer nicht zu erlauben, sein Limit für die Nutzung dieser Funktionen zu überschreiten, da der Benutzer in vielen Fällen bei jeder Verwendung der Funktion einen Vorteil erlangen kann, der berücksichtigt werden muss, um den Eigentümer angemessen zu entschädigen .\n\n Schwachstellen im Zusammenhang mit dem Testen der Funktionsgrenzen sind anwendungsspezifisch und es müssen Missbrauchsfälle erstellt werden, die darauf abzielen, Teile der Anwendung/Funktionen/oder Aktionen mehr als die zulässige Anzahl von Malen auszuführen.\nAngreifer können möglicherweise die Geschäftslogik umgehen und eine Funktion häufiger als „zulässig“ ausführen, indem sie die Anwendung zum persönlichen Vorteil ausnutzen.\n\n So testen Sie #1\n Überprüfen Sie die Projektdokumentation und verwenden Sie explorative Tests, um nach Funktionen oder Merkmalen in der Anwendung oder dem System zu suchen, die während des Geschäftslogik-Workflows nicht mehr als einmal oder eine bestimmte Anzahl von Malen ausgeführt werden sollten.\n\n So testen Sie #2\n Entwickeln Sie für jede der gefundenen Funktionen und Merkmale, die während des Geschäftslogik-Workflows nur einmal oder eine bestimmte Anzahl von Malen ausgeführt werden sollten, Missbrauchs-/Missbrauchsfälle, die es einem Benutzer ermöglichen können, mehr als die zulässige Anzahl von Malen auszuführen.\n Kann ein Benutzer zum Beispiel mehrmals durch die Seiten vor und zurück navigieren und eine Funktion ausführen, die nur einmal ausgeführt werden sollte, oder kann ein Benutzer Einkaufswagen laden und entladen, was zusätzliche Rabatte ermöglicht.",
-      "006": "Workflow-Schwachstellen umfassen jede Art von Schwachstelle, die es dem Angreifer ermöglicht, eine Anwendung/ein System so zu missbrauchen, dass er den entworfenen/beabsichtigten Workflow umgehen (nicht befolgen) kann.\n\n „Ein Workflow besteht aus einer Abfolge verbundener Schritte, wobei jeder Schritt ohne Verzögerung oder Lücke folgt und endet, kurz bevor der nächste Schritt beginnen kann. Workflow kann als jede Abstraktion von echter Arbeit angesehen werden.“\n\n Die Geschäftslogik der Anwendung muss erfordern, dass der Benutzer bestimmte Schritte in der richtigen/bestimmten Reihenfolge ausführt, und wenn der Workflow ohne korrekten Abschluss beendet wird, werden alle Aktionen und hervorgebrachten Aktionen „zurückgesetzt“ oder abgebrochen.\n\n Generische Testmethode\n • Überprüfen Sie die Projektdokumentation und verwenden Sie explorative Tests, um nach Methoden zu suchen, um Schritte im Anwendungsprozess in einer anderen Reihenfolge als dem entworfenen/beabsichtigten Ablauf der Geschäftslogik zu überspringen oder fortzusetzen.\n • Entwickeln Sie für jede Methode einen Missbrauchsfall und versuchen Sie, eine Aktion zu umgehen oder auszuführen, die gemäß dem Geschäftslogik-Workflow „nicht akzeptabel“ ist.\n\n Testmethode 1\n • Starten Sie eine Transaktion, die die Anwendung hinter den Punkten durchläuft, die Gutschriften/Punkte auf dem Benutzerkonto auslöst.\n • Stornieren Sie die Transaktion oder reduzieren Sie das endgültige Angebot, sodass die Punktewerte verringert werden sollten, und überprüfen Sie das Punkte-/Credit-System, um sicherzustellen, dass die richtigen Punkte/Credits erfasst wurden.\n\n Testmethode 2\n • Auf einem Content-Management- oder Bulletin-Board-System gültige Anfangstexte oder -werte eingeben und speichern.\n • Versuchen Sie dann, Daten anzuhängen, zu bearbeiten und zu entfernen, die die vorhandenen Daten in einem ungültigen Zustand oder mit ungültigen Werten belassen würden, um sicherzustellen, dass der Benutzer nicht berechtigt ist, die falschen Informationen zu speichern.\n Bei einigen „ungültigen“ Daten oder Informationen kann es sich um bestimmte Wörter (Obszönitäten) oder bestimmte Themen (z. B. politische Themen) handeln.",
-      "007": "Der Missbrauch und die ungültige Verwendung einer gültigen Funktionalität kann Angriffe identifizieren, die versuchen, die Webanwendung aufzulisten, Schwachstellen zu identifizieren und Schwachstellen auszunutzen. Es sollten Tests durchgeführt werden, um festzustellen, ob Abwehrmechanismen auf Anwendungsebene vorhanden sind, um die Anwendung zu schützen.\n\n Der Mangel an aktiver Abwehr ermöglicht es einem Angreifer, ohne Rückgriff nach Schwachstellen zu suchen. Der Eigentümer der Anwendung weiß daher nicht, dass seine Anwendung angegriffen wird.\n\n Dieser Test ist insofern ungewöhnlich, als das Ergebnis aus allen anderen Tests gezogen werden kann, die gegen die Webanwendung durchgeführt wurden.\n Beachten Sie bei der Durchführung aller anderen Tests Maßnahmen, die darauf hindeuten könnten, dass die Anwendung über einen integrierten Selbstschutz verfügt:\n • Geänderte Antworten\n • Blockierte Anfragen\n • Aktionen, die einen Benutzer abmelden oder sein Konto sperren\n\n Diese dürfen nur lokalisiert werden. Übliche lokalisierte (pro Funktion) Abwehrmaßnahmen sind:\n • Ablehnen von Eingaben, die bestimmte Zeichen enthalten\n • Vorübergehendes Sperren eines Kontos nach einer Reihe von Authentifizierungsfehlern\n\n Lokale Sicherheitskontrollen sind nicht ausreichend. Gegen allgemeinen Missbrauch wie z. B.:\n • Erzwungenes Browsen\n • Umgehen der Eingabeüberprüfung der Präsentationsschicht\n • Mehrfachzugriffskontrollfehler\n • Zusätzliche, doppelte oder fehlende Parameternamen\n • Mehrere Fehler bei der Eingabeüberprüfung oder Überprüfung der Geschäftslogik\n • Es werden strukturierte Daten (z. B. JSPN, XML) in einem ungültigen Format empfangen\n • Eklatante Cross-Site-Scripting- oder SQL-Injection-Payloads werden empfangen\n • Nutzung der Anwendung schneller als möglich\n • Änderung des kontinentalen Standorts eines Benutzers\n • Änderung des Benutzeragenten\n • Zugriff auf einen mehrstufigen Geschäftsprozess in der falschen Reihenfolge\n • Große Anzahl oder hohe Nutzungsrate anwendungsspezifischer Funktionalität\n\n Nicht alle oben genannten müssen von der Anwendung überwacht werden, aber es gibt ein Problem, wenn dies nicht der Fall ist. Wurde durch das Testen der Webanwendung durch Ausführen der oben genannten Aktionen eine Reaktion gegen den Tester vorgenommen?\n Ist dies nicht der Fall, sollte der Tester melden, dass die Anwendung offenbar keine anwendungsweite aktive Abwehr gegen Missbrauch zu haben scheint.",
-      "008": "Die Geschäftsprozesse vieler Anwendungen ermöglichen das Hochladen und Bearbeiten von Daten, die über Dateien übermittelt werden.\n Das Risiko besteht darin, dass Angreifer, indem sie Benutzern erlauben, Dateien hochzuladen, einen unerwarteten Dateityp übermitteln, der ausgeführt werden und die Anwendung oder das System durch Angriffe beeinträchtigen könnte, die die Website verunstalten, Remote-Befehle ausführen, die Systemdateien durchsuchen, die lokale Ressourcen, greifen andere Server an oder nutzen die lokalen Schwachstellen aus, um nur einige zu nennen.\n\n Schwachstellen im Zusammenhang mit dem Hochladen unerwarteter Dateitypen sind insofern einzigartig, als der Upload eine Datei schnell zurückweisen sollte, wenn sie keine bestimmte Erweiterung hat. Außerdem unterscheidet sich dies vom Hochladen bösartiger Dateien darin, dass in den meisten Fällen eine falsche Datei die gespeicherten Daten schädigen kann.\n\n Generische Testmethode\n • Überprüfen Sie die Projektdokumentation und führen Sie einige explorative Tests durch, um nach Dateitypen zu suchen, die von der Anwendung/dem System „nicht unterstützt“ werden sollten.\n • Versuchen Sie, diese „nicht unterstützten“ Dateien hochzuladen, und vergewissern Sie sich, dass sie ordnungsgemäß abgelehnt werden.\n • Wenn mehrere Dateien gleichzeitig hochgeladen werden können, müssen Tests durchgeführt werden, um sicherzustellen, dass jede Datei ordnungsgemäß bewertet wird.\n\n Spezifische Testmethode\n • Studieren Sie die logischen Anforderungen der Anwendung\n • Bereiten Sie eine Bibliothek mit Dateien vor, die zum Hochladen „nicht genehmigt“ wurden und möglicherweise Dateien wie jsp-, exe- oder html-Dateien enthalten, die Skripte enthalten.\n • Navigieren Sie in der Anwendung zum Dateiübermittlungs- oder Upload-Mechanismus.\n • Reichen Sie die „nicht genehmigte“ Datei zum Hochladen ein und vergewissern Sie sich, dass sie ordnungsgemäß am Hochladen gehindert werden.",
-      "009": "Die Geschäftsprozesse vieler Anwendungen ermöglichen das Hochladen von Daten/Informationen.\n Um das Risiko zu verringern, akzeptieren wir möglicherweise nur bestimmte Dateierweiterungen, aber Angreifer sind in der Lage, bösartigen Code in inaktive Dateitypen einzukapseln.\n\n Schwachstellen im Zusammenhang mit dem Hochladen bösartiger Dateien sind insofern einzigartig, als diese „bösartigen“ Dateien leicht zurückgewiesen werden können, indem eine Geschäftslogik integriert wird, die Dateien während des Hochladevorgangs scannt und die als bösartig wahrgenommenen zurückweist.\nDarüber hinaus unterscheidet sich dies vom Hochladen unerwarteter Dateien darin, dass der Dateityp zwar akzeptiert werden kann, die Datei aber dennoch für das System schädlich sein kann.\n\n Allgemeine Testmethode\n • Überprüfen Sie die Projektdokumentation und verwenden Sie explorative Tests, die die Anwendung/das System untersuchen, um festzustellen, was eine „bösartige“ Datei in Ihrer Umgebung darstellt.\n • Entwickeln oder erwerben Sie eine bekannte „bösartige“ Datei.\n • Versuchen Sie, die bösartige Datei in die Anwendung/das System hochzuladen, und vergewissern Sie sich, dass sie korrekt abgelehnt wird.\n • Wenn mehrere Dateien gleichzeitig hochgeladen werden können, müssen Tests durchgeführt werden, um sicherzustellen, dass jede Datei ordnungsgemäß bewertet wird.\n\n Spezifische Testmethode 1\n • Die Verwendung der Metasploit-Nutzlastgenerierungsfunktion generiert einen Shellcode als ausführbare Windows-Datei mit dem Metasploit-Befehl „msfpayload“.\n • Senden Sie die ausführbare Datei über die Upload-Funktion der Anwendung und prüfen Sie, ob sie akzeptiert oder ordnungsgemäß abgelehnt wird.\n\n Spezifische Testmethode 2\n • Entwickeln oder erstellen Sie eine Datei, die den Malware-Erkennungsprozess der Anwendung nicht bestehen sollte.\n (es gibt viele im Internet verfügbar wie ducklin.htm oder ducklin-html.htm)\n • Senden Sie die ausführbare Datei über die Upload-Funktion der Anwendung und prüfen Sie, ob sie akzeptiert oder ordnungsgemäß abgelehnt wird.\n\n Spezifische Testmethode 3\n • Richten Sie den abfangenden Proxy ein, um die „gültige“ Anfrage für eine akzeptierte Datei zu erfassen.\n • Senden Sie eine „ungültige“ Anfrage mit einer gültigen/akzeptablen Dateierweiterung durch und prüfen Sie, ob die Anfrage angenommen oder ordnungsgemäß abgelehnt wird."
-    },
-    "client": {
-      "001": "DOM-based Cross-Site Scripting ist der De-facto-Name für XSS-Bugs, die das Ergebnis aktiver browserseitiger Inhalte auf einer Seite sind, typischerweise JavaScript, die Benutzereingaben erhalten und dann etwas Unsicheres damit machen, was zur Ausführung von eingeschleusten Codes führt .\n\nDas DOM oder Document Object Model ist das Strukturformat, das zur Darstellung von Dokumenten in einem Browser verwendet wird. Das DOM ermöglicht es dynamischen Skripten wie JavaScript, auf Komponenten des Dokuments wie ein Formularfeld oder ein Sitzungscookie zu verweisen.\n Eine DOM-basierte XSS-Schwachstelle kann auftreten, wenn aktiver Inhalt, z. B. eine JavaScript-Funktion, durch eine speziell gestaltete Anforderung so geändert wird, dass ein DOM-Element von einem Angreifer gesteuert werden kann.\n\n Nicht alle XSS-Fehler erfordern, dass der Angreifer den vom Server zurückgegebenen Inhalt kontrolliert, sondern können stattdessen schlechte JavaScript-Codierungspraktiken missbrauchen. Im Vergleich zu anderen Cross-Site-Scripting-Schwachstellen, bei denen ein nicht bereinigter Parameter vom Server übergeben, an den Benutzer zurückgegeben und im Kontext des Browsers des Benutzers ausgeführt wird, steuert eine DOM-basierte XSS-Schwachstelle den Fluss des Codes mithilfe von Elementen der Document Object Model (DOM) zusammen mit Code, der vom Angreifer erstellt wurde, um den Fluss zu ändern.\n Aufgrund ihrer Natur können DOM-basierte XSS-Schwachstellen in vielen Fällen ausgeführt werden, ohne dass der Server feststellen kann, was tatsächlich ausgeführt wird.\n\n Ein Angreifer kann #<script>alert(‘xss’)</script> an die betroffene Seiten-URL anhängen, was bei Ausführung das Warnfeld anzeigen würde. In diesem Fall würde der angehängte Code nicht an den Server gesendet, da alles nach dem #-Zeichen vom Browser nicht als Teil der Abfrage, sondern als Fragment behandelt wird.\n\n Testen auf DOM-basierte XSS-Schwachstellen:\n Blackbox-Tests für DOM-basiertes XSS werden normalerweise nicht durchgeführt, da der Zugriff auf den Quellcode immer verfügbar ist, da er zur Ausführung an den Client gesendet werden muss.\n Viele Websites verlassen sich auf große Funktionsbibliotheken, die sich oft über Hunderttausende von Codezeilen erstrecken und nicht selbst entwickelt wurden. In diesen Fällen wird das Top-Down-Testen oft zur einzig wirklich praktikablen Option.\n Dasselbe gilt auch für Top-Down-Tests, wenn die Eingaben oder deren Fehlen nicht von vornherein identifiziert werden. Benutzereingaben erfolgen in zwei Hauptformen:\n • Eingaben, die vom Server auf eine Weise auf die Seite geschrieben werden, die kein direktes XSS zulässt\n • Von clientseitigen JavaScript-Objekten erhaltene Eingaben\n\n Automatisiertes Testen hat nur sehr begrenzten Erfolg beim Identifizieren und Validieren von DOM-basiertem XSS, da es XSS normalerweise identifiziert, indem es eine bestimmte Nutzlast sendet und versucht, es in der Serverantwort zu beobachten.\n Daher sollten manuelle Tests durchgeführt werden, die durch Untersuchen von Bereichen im Code durchgeführt werden können, in denen auf Parameter verwiesen wird, die für einen Angreifer nützlich sein können.",
-      "002": "Eine JavaScript-Injection-Schwachstelle ist eine Unterart von Cross Site Scripting (XSS), bei der beliebiger JavaScript-Code injiziert werden kann, der von der Anwendung im Browser des Opfers ausgeführt wird.\n Diese Sicherheitsanfälligkeit kann viele Konsequenzen haben, wie die Offenlegung von Sitzungscookies eines Benutzers, die verwendet werden könnten, um sich als das Opfer auszugeben, oder allgemeiner kann es dem Angreifer ermöglichen, den von den Opfern gesehenen Seiteninhalt oder das Anwendungsverhalten zu ändern.\n\n Eine solche Schwachstelle tritt auf, wenn der Anwendung eine ordnungsgemäße vom Benutzer bereitgestellte Eingabe- und Ausgabevalidierung fehlt. JavaScript wird verwendet, um Webseiten dynamisch zu füllen, diese Injektion erfolgt während dieser Inhaltsverarbeitungsphase und wirkt sich folglich auf das Opfer aus.\n Wenn Sie versuchen, diese Art von Problemen auszunutzen, bedenken Sie, dass einige Zeichen von verschiedenen Browsern unterschiedlich behandelt werden.",
-      "003": "HTML-Injektion ist eine Art von Injektionsproblem, das auftritt, wenn a\nDer Benutzer kann einen Eingabepunkt steuern und beliebigen HTML-Code in eine anfällige Webseite einfügen.\nDiese Schwachstelle kann viele Konsequenzen haben, wie z. B. die Offenlegung\nvon Sitzungscookies eines Benutzers, die verwendet werden könnten, um sich als das auszugeben\nOpfer, oder allgemeiner kann es dem Angreifer ermöglichen, die zu ändern\nSeiteninhalte, die von den Opfern gesehen wurden.\n\n Diese Sicherheitsanfälligkeit tritt auf, wenn die Benutzereingabe nicht ordnungsgemäß bereinigt und die Ausgabe nicht codiert ist. Eine Injektion ermöglicht es dem Angreifer, eine bösartige HTML-Seite an ein Opfer zu senden. Der angegriffene Browser ist nicht in der Lage, die legitimen von den bösartigen Teilen zu unterscheiden (zu vertrauen) und wird folglich alle im Opferkontext als legitim analysieren und ausführen.\n\n Es gibt eine breite Palette von Methoden und Attributen, die zum Rendern von HTML-Inhalten verwendet werden können. Wenn diese Methoden mit einer nicht vertrauenswürdigen Eingabe versehen sind, besteht ein hohes XSS-Risiko.\n Bösartiger HTML-Code könnte beispielsweise über innerHTML eingeschleust werden, das verwendet wird, um vom Benutzer eingefügten HTML-Code wiederzugeben. Eine unsachgemäße Verwendung dieser Eigenschaft bedeutet mangelnde Bereinigung durch nicht vertrauenswürdige Eingaben und fehlende Ausgabecodierung.\n Wenn Zeichenfolgen nicht korrekt bereinigt werden, kann das Problem zu einer XSS-basierten HTML-Injektion führen.\n Eine andere Methode könnte document.write() sein.\n\nWenn Sie versuchen, diese Art von Problemen auszunutzen, bedenken Sie, dass einige Zeichen von verschiedenen Browsern unterschiedlich behandelt werden.",
-      "004": "Die clientseitige URL-Umleitung, auch bekannt als offene Umleitung, ist ein Eingabevalidierungsfehler, der auftritt, wenn eine Anwendung eine benutzergesteuerte Eingabe akzeptiert, die einen Link angibt, der zu einer externen URL führt, die bösartig sein könnte.\nDiese Art von Schwachstelle könnte verwendet werden, um einen Phishing-Angriff durchzuführen oder ein Opfer auf eine infizierte Seite umzuleiten.\n\nDiese Schwachstelle tritt auf, wenn eine Anwendung nicht vertrauenswürdige Eingaben akzeptiert, die einen URL-Wert enthalten, ohne sie zu bereinigen. Dieser URL-Wert könnte dazu führen, dass die Webanwendung den Benutzer auf eine andere Seite umleitet, beispielsweise eine bösartige Seite, die vom Angreifer kontrolliert wird.\n\n Durch das Ändern einer nicht vertrauenswürdigen URL-Eingabe zu einer bösartigen Website kann ein Angreifer erfolgreich einen Phishing-Betrug starten und Benutzeranmeldeinformationen stehlen.\n Darüber hinaus könnten offene Umleitungen auch verwendet werden, um böswillig eine URL zu erstellen, die die Zugriffskontrollprüfungen der Anwendung umgeht und den Angreifer dann zu privilegierten Funktionen weiterleitet, auf die er normalerweise keinen Zugriff hätte.\n\n Testen auf Sicherheitslücken bei der Client-seitigen URL-Umleitung:\nWenn Tester manuell nach dieser Art von Schwachstelle suchen müssen, müssen sie feststellen, ob clientseitige Umleitungen im clientseitigen Code implementiert sind.\n Diese Umleitungen könnten beispielsweise in JavaScript über das Objekt „window.location“ implementiert werden, mit dem der Browser durch einfaches Zuweisen eines Strings auf eine andere Seite geleitet werden kann. Wenn das Skript keine Validierung der Variablen „redir“ durchführt, wird diese nicht validierte Eingabe an das windows.location-Objekt weitergeleitet, wodurch eine URL-Umleitungs-Schwachstelle entsteht.",
-      "005": "Eine CSS-Injection-Schwachstelle beinhaltet die Möglichkeit, beliebigen CSS-Code im Kontext einer vertrauenswürdigen Website einzufügen, und dieser wird im Browser des Opfers gerendert.\nDie Auswirkungen einer solchen Schwachstelle können je nach bereitgestellter CSS-Payload variieren: Sie könnte unter Umständen zu Cross-Site Scripting, zu Datenexfiltration im Sinne des Extrahierens sensibler Daten oder zu UI-Modifikationen führen.\n\n Eine solche Schwachstelle tritt auf, wenn die Anwendung die Bereitstellung von benutzergeneriertem CSS zulässt oder es möglich ist, irgendwie in die legitimen Stylesheets einzugreifen.\n Das Einfügen von Code in den CSS-Kontext gibt dem Angreifer die Möglichkeit, JavaScript unter bestimmten Bedingungen auszuführen sowie sensible Werte durch CSS-Selektoren und Funktionen zu extrahieren, die HTTP-Anforderungen generieren können.\n\n Insbesondere könnte der Angreifer das Opfer angreifen, indem er es auffordert, die folgenden URLs zu besuchen:\n • www.victim.com/#red;-o-link:’javascript:alert(1)’;-o-linksource:current; (Oper [8,12])\n • www.victim.com/#red;-:expression(alert(URL=1)); (IE 7/8)\n\n Viel interessantere Angriffsszenarien beinhalten die Möglichkeit, Daten durch die Übernahme reiner CSS-Regeln zu extrahieren.\nSolche Angriffe können über CSS-Selektoren durchgeführt werden und zum Beispiel dazu führen, Anti-CSRF-Token zu stehlen.\n\n Testen auf CSS-Injection-Schwachstellen:\n Es müssen manuelle Tests durchgeführt und der JavaScript-Code analysiert werden, um zu verstehen, ob die Angreifer eigene Inhalte im CSS-Kontext einfügen können. Insbesondere sollte uns interessieren, wie die Website CSS-Regeln auf Basis der Eingaben zurückgibt.",
-      "006": "Eine ClientSide Resource Manipulation-Schwachstelle ist ein Fehler bei der Eingabevalidierung, der auftritt, wenn eine Anwendung eine benutzergesteuerte Eingabe akzeptiert, die den Pfad einer Ressource angibt (d. h. die Quelle eines Iframes, js, Applets).\nEine solche Schwachstelle besteht insbesondere in der Möglichkeit, die URLs zu kontrollieren, die auf einige auf einer Webseite vorhandene Ressourcen verweisen.\n Die Auswirkungen können je nach Art des Elements variieren, dessen URL vom Angreifer kontrolliert wird, und es wird normalerweise verwendet, um Cross-Site-Scripting-Angriffe durchzuführen.\n\n Eine solche Schwachstelle tritt auf, wenn die Anwendung Benutzer verwendet\nkontrollierte URLs zum Verweisen auf externe/interne Ressourcen.\n Unter diesen Umständen ist es möglich, das Verhalten der erwarteten Anwendung zu beeinträchtigen, indem schädliche Objekte geladen und wiedergegeben werden.\n\n Testen auf Sicherheitslücken in Bezug auf clientseitige Ressourcenmanipulation:\nUm manuell nach dieser Art von Schwachstelle zu suchen, müssen wir feststellen, ob die Anwendung Eingaben verwendet, ohne sie korrekt zu validieren. Diese stehen unter der Kontrolle des Benutzers, der möglicherweise die URL einiger Ressourcen angeben kann.\n Da es viele Ressourcen gibt, die in die Anwendung aufgenommen werden könnten, sollten clientseitige Skripts, die die zugehörigen URLs verarbeiten, auf mögliche Probleme untersucht werden. \n\n Nachfolgend sind die möglichen Injektionsstellen (Sink) aufgeführt, die überprüft werden sollten: \n • Ressource: Frame \n • Tag/Methode: iframe \n • Sink: src \n\n • Ressource: Link \n • Tag/Methode: a \n • Sink: href\n\n • Ressource: AJAX Request \n • Tag/Methode: xhr.open(method, [url], true); \n • Sink: URL  href\n\n • Ressource: CSS \n • Tag/Methode: link \n\n • Ressource: Image \n • Tag/Methode: img \n\n • Ressource: Object \n • Tag/Methode: object \n • Sink: src\n\n • Ressource: Script \n • Tag/Methode: script \n • Sink: data  src",
-      "007": "Cross Origin Resource Sharing oder CORS ist ein Mechanismus, der es einem Webbrowser ermöglicht, „domänenübergreifende“ Anforderungen mithilfe der XMLHttpRequest L2-API auf kontrollierte Weise auszuführen.\n In der Vergangenheit erlaubte die XMLHttpRequest L1-API nur das Senden von Anforderungen innerhalb desselben Ursprungs, da sie durch dieselbe Ursprungsrichtlinie eingeschränkt war.\n\n Cross-Origin-Anfragen haben einen Origin-Header, der die Domäne identifiziert, die die Anfrage initiiert, und immer an den Server gesendet wird. CORS definiert das Protokoll, das zwischen einem Webbrowser und einem Server verwendet werden soll, um festzustellen, ob eine Cross-Origin-Anforderung zulässig ist.\n Um dieses Ziel zu erreichen, sind an diesem Prozess einige HTTP-Header beteiligt, die von allen gängigen Browsern unterstützt werden, darunter:\n • Origin \n • Access-Control-Request-Method \n • Access-Control-Request-Headers \n • Access-Control-Allow-Origin \n • Access-Control-Allow-Credentials \n • Access-Control-Allow-Methods \n • Access-Control-Allow-Headers\n\n Die CORS-Spezifikation schreibt vor, dass für nicht einfache Anforderungen, wie z. B. andere Anforderungen als GET oder POST oder Anforderungen, die Anmeldeinformationen verwenden, im Voraus eine OPTIONS-Anforderung vor dem Flug gesendet werden muss, um zu prüfen, ob sich der Anforderungstyp negativ auf die Daten auswirkt .\n Die Preflight-Anforderung prüft die vom Server zugelassenen Methoden und Header, und wenn Anmeldeinformationen zulässig sind, entscheidet der Browser basierend auf dem Ergebnis der OPTIONS-Anforderung, ob die Anforderung zugelassen wird oder nicht.\n\n Überprüfen Sie die HTTP-Header, um zu verstehen, wie CORS verwendet wird, insbesondere sollten wir uns sehr für den Origin-Header interessieren, um zu erfahren, welche Domänen zulässig sind.\n Außerdem ist eine manuelle Überprüfung des JavaScripts erforderlich, um festzustellen, ob der Code aufgrund einer unsachgemäßen Handhabung von Benutzereingaben anfällig für Code-Injection ist.",
-      "008": "ActionScript ist die auf ECMAScript basierende Sprache, die von Flash-Anwendungen verwendet wird, wenn es um interaktive Anforderungen geht.\n Dort sind drei\nVersionen der ActionScript-Sprache. ActionScript 1.0 und ActionScript 2.0 sind sich sehr ähnlich, wobei ActionScript 2.0 eine Erweiterung von ActionScript 1.0 ist. ActionScript 3.0, eingeführt mit Flash Player 9, ist eine Neufassung der Sprache, um objektorientiertes Design zu unterstützen.\n\n ActionScript hat wie jede andere Sprache einige Implementierungsmuster, die zu Sicherheitsproblemen führen können.\n Da Flash-Anwendungen oft in Browser eingebettet sind, können Schwachstellen wie DOM-basiertes Cross-Site Scripting (XSS) in fehlerhaften Flash-Anwendungen vorhanden sein.\n\n Dekompilierung\n Da SWF-Dateien von einer im Player selbst eingebetteten virtuellen Maschine interpretiert werden, können sie möglicherweise dekompiliert und analysiert werden. Der bekannteste und kostenlosste ActionScript 2.0-Decompiler ist Flare.\n Die Dekompilierung hilft Testern, da sie ein quellcodegestütztes oder White-Box-Testen der Flash-Anwendungen ermöglicht. Das kostenlose Tool SWFScan von HP kann sowohl ActionScript 2.0 als auch ActionScript 3.0 dekompilieren.\n\n Angriffe und Flash-Player-Version Seit Mai 2007 wurden drei neue Versionen des Flash-Players von Adobe veröffentlicht. Jede neue Version schränkt einige der Angriffe ein.\n\n Player-Version: v9.0 r47/48\n • asfunction: Ja\n • Externe Schnittstelle: Ja\n • GetURL: Ja\n • HTML-Injektion: Ja\n\n Player-Version: v9.0 r115\n • asfunction: Nein\n • Externe Schnittstelle: Ja\n • GetURL: Ja\n • HTML-Injektion: Ja\n\n Player-Version: v9.0 r124\n • asfunction: Nein\n • Externe Schnittstelle: Ja\n • GetURL: Ja\n • HTML-Injection: Teilweise",
-      "009": "„Clickjacking“ (das eine Teilmenge des „UI-Redressing“ ist) ist eine bösartige Technik, die darin besteht, einen Webbenutzer dazu zu verleiten, mit etwas zu interagieren, das anders ist als das, womit der Benutzer glaubt, dass er interagiert.\n Diese Art von Angriff, der allein oder in Kombination mit anderen Angriffen verwendet werden kann, könnte möglicherweise nicht autorisierte Befehle senden oder vertrauliche Informationen preisgeben, während das Opfer auf scheinbar harmlosen Webseiten interagiert.\n\n Ein Clickjacking-Angriff verwendet scheinbar harmlose Funktionen von HTML und Javascript, um das Opfer zu unerwünschten Aktionen zu zwingen, wie z. B. das Klicken auf eine Schaltfläche, die scheinbar eine andere Operation ausführt.\n\n Um diese Art von Technik auszuführen, muss der Angreifer eine scheinbar harmlose Webseite erstellen, die die Zielanwendung durch die Verwendung eines Iframes lädt.\n Sobald dies geschehen ist, könnte der Angreifer das Opfer dazu bringen, mit seiner fiktiven Webseite zu interagieren.\nSobald das Opfer auf der fiktiven Webseite surft, denkt es, dass es mit der sichtbaren Benutzeroberfläche interagiert, tatsächlich führt es jedoch Aktionen auf der versteckten Seite aus.\n\nDiese Art von Angriff ist häufig darauf ausgelegt, einer angreifenden Website zu ermöglichen, Benutzeraktionen auf der Ziel-Website zu veranlassen, selbst wenn Anti-CSRF-Token verwendet werden. . Daher ist es wichtig, wie beim CSRF-Angriff, Webseiten der Zielseite so zu kennzeichnen, dass sie Eingaben des Benutzers entgegennehmen.\n\nWir müssen herausfinden, ob die Website, die wir testen, keinen Schutz vor Clickjacking-Angriffen hat oder, ob die Entwickler Schutzmaßnahmen implementiert haben, ob diese Techniken umgangen werden können.\nMethoden zum Schutz einer Webseite vor Clickjacking können in zwei Makrokategorien unterteilt werden:\n • Clientseitiger Schutz: Frame Busting\n • Serverseitiger Schutz: X-Frame-Optionen\n\n Einige Frame-Busting-Techniken versuchen, Frames zu unterbrechen, indem sie dem Attribut „parent.location“ in der „counter-action“-Anweisung einen Wert zuweisen. Solche Aktionen sind zum Beispiel:\n • self.parent.location = document.location\n • parent.location.href = self.location\n • parent.location = self.location",
-      "010": "Traditionell erlaubt das HTTP-Protokoll nur eine Anfrage/Antwort pro TCP-Verbindung. Asynchronous JavaScript and XML (AJAX) ermöglicht es Clients, Daten asynchron an den Server zu senden und zu empfangen, AJAX erfordert jedoch, dass der Client die Anforderungen initiiert und auf die Serverantworten wartet (Halbduplex).\n\n HTML5-WebSockets ermöglichen es dem Client/Server, „Vollduplex“-Kommunikationskanäle (zwei Wege) zu erstellen, sodass Client und Server wirklich asynchron kommunizieren können. WebSockets führen ihren anfänglichen „Upgrade“-Handshake über HTTP durch und von da an wird die gesamte Kommunikation über TCP-Kanäle unter Verwendung von Frames ausgeführt.\n\n 1: Identifizieren Sie, dass die Anwendung WebSockets verwendet\n • Untersuchen Sie den clientseitigen Quellcode auf das URI-Schema ws:// oder wss://\n • Verwenden Sie Browser Developer Tools, um die Netzwerk-WebSocket-Kommunikation anzuzeigen\n • Verwenden Sie die WebSocket-Registerkarte von OWASP Zed Attack Proxy (ZAP).\n\n 2: Ursprung\n • Versuchen Sie mithilfe eines WebSocket-Clients, eine Verbindung zum Remote-WebSocket-Server herzustellen\n • Wenn eine Verbindung hergestellt wird, überprüft der Server möglicherweise nicht den Ursprungsheader des WebSocket-Handshakes\n\n 3: Vertraulichkeit und Integrität\n • Überprüfen Sie, ob die WebSocket-Verbindung SSL verwendet, um vertrauliche Informationen zu übertragen (wss://)\n • Überprüfen Sie die SSL-Implementierung auf Sicherheitsprobleme (gültiges Zertifikat, BEAST, CRIME, RC4 usw.).\n\n 4: Authentifizierung\n • WebSockets führen keine Authentifizierung durch, es sollten normale Blackbox-Authentifizierungstests durchgeführt werden\n\n 5: Autorisierung\n • WebSockets behandeln keine Autorisierung, es sollten normale Blackbox-Autorisierungstests durchgeführt werden\n\n 6: Eingangsbereinigung\n • Verwenden Sie die WebSocket-Registerkarte von OWASP Zed Attack Proxy (ZAP), um WebSocket-Anforderungen und -Antworten wiederzugeben und zu fuzzen",
-      "011": "Web Messaging (auch bekannt als Cross Document Messaging) ermöglicht Anwendungen, die auf verschiedenen Domänen ausgeführt werden, auf sichere Weise zu kommunizieren.\n Diese Einschränkung im Browser dient dazu, eine böswillige Website daran zu hindern, vertrauliche Daten von anderen iFrames, Registerkarten usw. zu lesen. Es gibt jedoch einige legitime Fälle, in denen zwei vertrauenswürdige Websites Daten untereinander austauschen müssen. Um diesem Bedarf gerecht zu werden, wurde Cross Document Messaging innerhalb der WHATWG-HTML5-Entwurfsspezifikation eingeführt und in allen gängigen Browsern implementiert.\n Es ermöglicht eine sichere Kommunikation zwischen mehreren Ursprüngen über iFrames, Registerkarten und Fenster hinweg.\n\n Die Messaging-API führte die Methode postMessage() ein, mit der Klartext-Nachrichten ursprungsübergreifend versendet werden können. Es besteht aus zwei Parametern, Nachricht und Domäne.\n\n Es gibt einige Sicherheitsbedenken bei der Verwendung von „*“ als Domain, die wir unten besprechen. Um dann Nachrichten zu empfangen, muss die empfangende Website einen neuen Event-Handler hinzufügen und hat die folgenden Attribute:\n • data: Der Inhalt der eingehenden Nachricht\n • Herkunft: Die Herkunft des Absenderdokuments\n • Quelle: Quellfenster\n\nEs müssen manuelle Tests durchgeführt und der JavaScript-Code analysiert werden, um herauszufinden, wie Web Messaging implementiert ist.\nInsbesondere sollte uns interessieren, wie die Website Nachrichten von nicht vertrauenswürdigen Domänen einschränkt und wie die Daten selbst für vertrauenswürdige Domänen gehandhabt werden.",
-      "012": "Lokaler Speicher, auch als Webspeicher oder Offlinespeicher bekannt, ist ein Mechanismus zum Speichern von Daten als Schlüssel/Wert-Paare, die an eine Domäne gebunden sind und durch dieselbe Ursprungsrichtlinie (SOP) erzwungen werden.\n Es gibt zwei Objekte, localStorage, das persistent ist und Neustarts des Browsers/Systems überstehen soll, und sessionStorage, das temporär ist und nur existiert, bis das Fenster oder die Registerkarte geschlossen wird.\n Im Durchschnitt erlauben Browser in diesem Speicher etwa 5 MB pro Domain zu speichern, was im Vergleich zu den 4 KB Cookies ein großer Unterschied ist, aber der Hauptunterschied aus Sicherheitsperspektive besteht darin, dass die in diesen beiden Objekten gespeicherten Daten im Client und niemals gespeichert werden an den Server gesendet.\n\n Zunächst müssen wir prüfen, ob der Local Storage verwendet wird. Dies kann überprüft werden, wenn Sie das Browser-Tool verwenden, und dann unter Ressourcen zu „Lokaler Speicher“ und „Webspeicher“ gehen.\n\n Als nächstes müssen manuelle Tests durchgeführt werden, um festzustellen, ob die Website sensible Daten im Speicher speichert, die ein Risiko darstellen und die Auswirkungen eines Informationslecks dramatisch erhöhen werden.\n Überprüfen Sie auch den Code, der den Speicher verarbeitet, um festzustellen, ob er anfällig für Injektionsangriffe ist, ein häufiges Problem, wenn der Code der Eingabe oder Ausgabe nicht entkommt.",
-      "013": "Die XSSI-Schwachstelle (Cross Site Script Inclusion) ermöglicht den Verlust vertraulicher Daten über Ursprungs- oder Domänengrenzen hinweg. Zu den sensiblen Daten können authentifizierungsbezogene Daten (Anmeldestatus, Cookies, Authentifizierungstoken, Sitzungs-IDs usw.) oder persönliche oder sensible personenbezogene Daten des Benutzers (E-Mail-Adressen, Telefonnummern, Kreditkartendaten, Sozialversicherungsnummern usw.) gehören. XSSI ist ein clientseitiger Angriff, der Cross Site Request Forgery (CSRF) ähnelt, jedoch einen anderen Zweck verfolgt.\n\nWährend CSRF den authentifizierten Benutzerkontext verwendet, um bestimmte zustandsverändernde Aktionen innerhalb der Seite eines Opfers auszuführen (z. B. Geld auf das Konto des Angreifers überweisen, Berechtigungen ändern, Passwort zurücksetzen usw.), verwendet XSSI stattdessen JavaScript auf der Clientseite, um vertrauliche Daten preiszugeben aus authentifizierten Sitzungen.\n\nTestziele\n• Lokalisieren Sie vertrauliche Daten im gesamten System.\n• Bewerten Sie den Verlust sensibler Daten mithilfe verschiedener Techniken.\n\nSo testen Sie\n• Sammeln Sie Daten mithilfe authentifizierter und nicht authentifizierter Benutzersitzungen\n• Stellen Sie fest, ob die sensiblen Daten mithilfe von JavaScript verloren gehen können\n• Überprüfen Sie, ob über globale Variablen vertrauliche Daten verloren gehen\n• Überprüfen Sie mithilfe globaler Funktionsparameter, ob vertrauliche Daten verloren gehen\n• Suchen Sie nach Lecks sensibler Daten durch JavaScript-Laufzeitfehler\n• Prüfen Sie mithilfe von „this“ auf sensible Datenlecks durch Prototypenverkettung."
-    },
-    "api": {
-      "001": "GraphQL ist in modernen APIs sehr beliebt geworden. Es bietet Einfachheit und verschachtelte Objekte, die eine schnellere Entwicklung ermöglichen. Obwohl jede Technologie Vorteile bietet, kann sie die Anwendung auch neuen Angriffsflächen aussetzen. Der Zweck dieses Szenarios besteht darin, einige häufige Fehlkonfigurationen und Angriffsvektoren für Anwendungen bereitzustellen, die GraphQL verwenden.\n\nTestziele:\n• Beurteilen Sie, dass eine sichere und produktionsbereite Konfiguration bereitgestellt wird.\n• Beurteilen Sie, dass eine sichere und produktionsbereite Konfiguration bereitgestellt wird.\n• Stellen Sie sicher, dass ordnungsgemäße Zugangskontrollen angewendet werden.\n\nDas Testen von GraphQL-Knoten unterscheidet sich nicht wesentlich vom Testen anderer API-Technologien.\nIntrospektionsabfragen sind die Methode, mit der GraphQL Sie fragen lässt, welche Abfragen unterstützt werden, welche Datentypen verfügbar sind und viele weitere Details, die Sie benötigen, wenn Sie sich einem Test einer GraphQL-Bereitstellung nähern.\nEin Tool wie GraphQL Voyager kann verwendet werden, um ein besseres Verständnis des GraphQL-Endpunkts zu erhalten. Dieses Tool erstellt eine ERD-Darstellung (Entity Relationship Diagram) des GraphQL-Schemas, sodass Sie einen besseren Einblick in die beweglichen Teile des Systems erhalten, das Sie testen.\n\nDie Introspektion ist der erste Ort, um nach Autorisierungsproblemen zu suchen. Wie bereits erwähnt, sollte der Zugang zur Introspektion eingeschränkt werden, da sie die Datenextraktion und Datenerfassung ermöglicht. Sobald ein Tester Zugriff auf das Schema und Kenntnisse über die zu extrahierenden vertraulichen Informationen hat, sollte er Abfragen senden, die nicht aufgrund unzureichender Berechtigungen blockiert werden. GraphQL erzwingt standardmäßig keine Berechtigungen, daher liegt es an der Anwendung, die Autorisierungsdurchsetzung durchzuführen.\nDas Testen der Autorisierungsimplementierung variiert von Bereitstellung zu Bereitstellung, da jedes Schema unterschiedliche vertrauliche Informationen und daher unterschiedliche Ziele aufweist, auf die es sich konzentrieren muss.\n\nGraphQL ist die Implementierung der API-Schicht einer Anwendung und leitet als solche die Anforderungen normalerweise direkt an eine Back-End-API oder die Datenbank weiter. Dadurch können Sie jede zugrunde liegende Schwachstelle wie SQL-Injection, Command-Injection, Cross-Site-Scripting usw. ausnutzen. Die Verwendung von GraphQL ändert lediglich den Eintrittspunkt der bösartigen Nutzlast.\n\nGraphQL kann zur Laufzeit auf unerwartete Fehler stoßen. Wenn ein solcher Fehler auftritt, sendet der Server möglicherweise eine Fehlerantwort, die interne Fehlerdetails oder Anwendungskonfigurationen oder -daten offenlegen kann. Dadurch kann ein böswilliger Benutzer an weitere Informationen über die Anwendung gelangen. Im Rahmen des Tests sollten Fehlermeldungen durch das Senden unerwarteter Daten überprüft werden, ein Vorgang, der als Fuzzing bezeichnet wird. Die Antworten sollten nach potenziell sensiblen Informationen durchsucht werden, die mit dieser Technik offengelegt werden könnten."
-    },
-    "no_info": "Kein Informationen für die gegebene Referenznummer gefunden."
+  "categories": {
+    "INFORMATION_GATHERING": "Informationsbeschaffung",
+    "CONFIGURATION_AND_DEPLOY_MANAGEMENT_TESTING": "Konfig- & Einsatzmanagement-Testing",
+    "IDENTITY_MANAGEMENT_TESTING": "Identitätsmanagement-Testing",
+    "AUTHENTICATION_TESTING": "Authentifizierungs-Testing",
+    "AUTHORIZATION_TESTING": "Autorisations-Testing",
+    "SESSION_MANAGEMENT_TESTING": "Sitzungsmanagement-Testing",
+    "INPUT_VALIDATION_TESTING": "Eingabevalidierungs-Testing",
+    "ERROR_HANDLING": "Fehlerbehandlung",
+    "CRYPTOGRAPHY": "Kryptographie",
+    "BUSINESS_LOGIC_TESTING": "Business-Logik-Testing",
+    "CLIENT_SIDE_TESTING": "Clientseitiges-Testing"
   }
 }