# SEC 11. Wie beziehen Sie die Sicherheitseigenschaften von Anwendungen während des gesamten Entwurfs-, Entwicklungs- und Bereitstellungslebenszyklus ein und validieren sie?
Das Schulen von Personen, das Testen mithilfe von Automatisierung, ein Verständnis der Abhängigkeiten und die Validierung der Sicherheitseigenschaften von Tools und Anwendungen helfen dabei, die Wahrscheinlichkeit eines Sicherheitsproblems bei Produktions-Workloads zu verringern.
**Topics**
+ [
# SEC11-BP01 Für Anwendungssicherheit schulen
](sec_appsec_train_for_application_security.md)
+ [
# SEC11-BP02 Das Testen während des Entwicklungs- und Veröffentlichungslebenszyklus automatisieren
](sec_appsec_automate_testing_throughout_lifecycle.md)
+ [
# SEC11-BP03 Regelmäßig Penetrationstests durchführen
](sec_appsec_perform_regular_penetration_testing.md)
+ [
# SEC11-BP04 Manuelle Codeüberprüfungen
](sec_appsec_manual_code_reviews.md)
+ [
# SEC11-BP05 Services für Pakete und Abhängigkeiten zentralisieren
](sec_appsec_centralize_services_for_packages_and_dependencies.md)
+ [
# SEC11-BP06 Software programmgesteuert bereitstellen
](sec_appsec_deploy_software_programmatically.md)
+ [
# SEC11-BP07 Die Sicherheitseigenschaften der Pipelines regelmäßig bewerten
](sec_appsec_regularly_assess_security_properties_of_pipelines.md)
+ [
# SEC11-BP08 Ein Programm entwickeln, das den Workload-Teams die Verantwortung für die Sicherheit überträgt
](sec_appsec_build_program_that_embeds_security_ownership_in_teams.md)
# SEC11-BP01 Für Anwendungssicherheit schulen
Bieten Sie den Entwicklern in Ihrer Organisation Schulungsmöglichkeiten zu allgemeinen Praktiken für die sichere Entwicklung und den sicheren Betrieb von Anwendungen. Die Einführung sicherheitsbezogener Entwicklungsmethoden hilft, die Wahrscheinlichkeit von Problemen zu verringern, die nur während der Phase der Sicherheitsüberprüfung erkannt werden.
**Gewünschtes Ergebnis:** Beim Entwerfen und Entwickeln von Software sollte Sicherheit berücksichtigt werden. Wenn Entwickler in einer Organisation hinsichtlich sicherer Entwicklungspraktiken, die mit einem Bedrohungsmodell beginnen, geschult sind, wird die gesamte Qualität und Sicherheit der entwickelten Software verbessert. Mithilfe dieses Ansatzes kann die Zeit bis zum Ausliefern von Software oder Funktionen verringert werden, da der Überarbeitungsaufwand nach Sicherheitsüberprüfungen kleiner ist.
Für den Zweck dieser bewährten Methode bezieht sich *sichere Entwicklung* auf die Software, die geschrieben wird, und die Tools oder Systeme, die den Softwareentwicklungs-Lebenszyklus (SDLC) unterstützen.
**Typische Anti-Muster:**
+ Auf eine Sicherheitsüberprüfung warten und dann die Sicherheitseigenschaften eines Systems berücksichtigen.
+ Alle sicherheitsbezogenen Entscheidungen dem Sicherheitsteam überlassen.
+ Nicht kommunizieren, wie sich die im Softwareentwicklungs-Lebenszyklus getroffenen Entscheidungen auf die allgemeinen Sicherheitserwartungen- oder -richtlinien der Organisation beziehen.
+ Den Sicherheitsüberprüfungsprozess zu spät einsetzen.
**Vorteile der Nutzung dieser bewährten Methode:**
+ Bessere Kenntnis der Unternehmensanforderungen hinsichtlich Sicherheit früh im Entwicklungszyklus.
+ Raschere Lieferung von Funktionen durch das schnelle Identifizieren und Lösen potenzieller Sicherheitsproblemen.
+ Verbesserte Qualität von Software und Systemen.
**Risikostufe, wenn diese bewährte Methode nicht eingeführt wird:** mittel
## Implementierungsleitfaden
Bieten Sie den Entwicklern in Ihrem Unternehmen Schulungen. Ein Kurs über [Bedrohungsmodellierung](https://catalog.workshops.aws/threatmodel/en-US) ist ein guter Start, um einen Grundstein für Sicherheitsschulungen zu legen. Idealerweise sollten Entwickler selbständig auf die Informationen zugreifen können, die für ihre Workloads relevant sind. Dieser Zugriff hilft ihnen dabei, informierte Entscheidungen zu den Sicherheitseigenschaften der Systeme zu treffen, die sie entwickelt haben, ohne ein anderes Team kontaktieren zu müssen. Der Vorgang zum Einbinden von Sicherheitsteams in Überprüfungen sollte klar definiert und einfach zu befolgen sein. Die Schritte des Überprüfungsprozesses sollten Inhalt der Sicherheitsschulung sein. Dort, wo bekannte Implementierungsmuster oder -vorlagen verfügbar sind, sollten sie einfach zu finden und mit den allgemeinen Sicherheitsanforderungen verknüpft sein. Erwägen Sie, [AWS CloudFormation,](https://aws.amazon.com/cloudformation/) [AWS Cloud Development Kit (AWS CDK)-Konstrukte](https://docs.aws.amazon.com/cdk/v2/guide/constructs.html), [Service Catalog](https://aws.amazon.com/servicecatalog/) oder andere Vorlagen-Tools zu verwenden, um den Bedarf nach einer benutzerspezifischen Konfiguration zu verringern.
### Implementierungsschritte
+ Ein Kurs über [Bedrohungsmodellierung](https://catalog.workshops.aws/threatmodel/en-US) ist für Ihre Entwickler ein guter Start, um einen Grundstein für Sicherheitsüberlegungen zu legen.
+ Bieten Sie Zugriff auf [AWS Training and Certification](https://www.aws.training/LearningLibrary?query=&filters=Language%3A1%20Domain%3A27&from=0&size=15&sort=_score&trk=el_a134p000007C9OtAAK&trkCampaign=GLBL-FY21-TRAINCERT-800-Security&sc_channel=el&sc_campaign=GLBL-FY21-TRAINCERT-800-Security-Blog&sc_outcome=Training_and_Certification&sc_geo=mult) und Branchen- oder AWS-Partner-Schulungen.
+ Bieten Sie Schulungen zum Sicherheitsüberprüfungsprozess Ihres Unternehmens an, die die Aufteilung von Verantwortlichkeiten zwischen Sicherheitsteams, Workload-Teams und anderen Beteiligten klären.
+ Veröffentlichen Sie Self-Service-Anweisungen zum Erfüllen von Sicherheitsanforderungen, einschließlich Codebeispielen und Vorlagen, wenn verfügbar.
+ Erhalten Sie regelmäßig Feedback von Entwicklerteams zu ihrer Erfahrung mit dem Sicherheitsüberprüfungsprozess und -schulungen und verwenden Sie dieses Feedback, um Verbesserungen zu implementieren.
+ Führen Sie Ernstfallübungen oder Kampagnen zum Beseitigen von Bugs durch, um die Anzahl von Fehlern zu verringern und die Fähigkeiten Ihrer Entwickler auszuweiten.
## Ressourcen
**Zugehörige bewährte Methoden:**
+ [SEC11-BP08 Ein Programm entwickeln, das den Workload-Teams die Verantwortung für die Sicherheit überträgt](sec_appsec_build_program_that_embeds_security_ownership_in_teams.md)
**Zugehörige Dokumente:**
+ [AWS Training und Zertifizierung](https://www.aws.training/LearningLibrary?query=&filters=Language%3A1%20Domain%3A27&from=0&size=15&sort=_score&trk=el_a134p000007C9OtAAK&trkCampaign=GLBL-FY21-TRAINCERT-800-Security&sc_channel=el&sc_campaign=GLBL-FY21-TRAINCERT-800-Security-Blog&sc_outcome=Training_and_Certification&sc_geo=mult)
+ [How to think about cloud security governance](https://aws.amazon.com/blogs/security/how-to-think-about-cloud-security-governance/) (Über Cloud-Sicherheits-Governance nachdenken)
+ [How to approach threat modeling](https://aws.amazon.com/blogs/security/how-to-approach-threat-modeling/) (Konzepte für Bedrohungsmodellierung)
+ [Accelerating training – The AWS Skills Guild](https://docs.aws.amazon.com/whitepapers/latest/public-sector-cloud-transformation/accelerating-training-the-aws-skills-guild.html) (Schulungen beschleunigen – AWS Skills Guild)
**Zugehörige Videos:**
+ [Proactive security: Considerations and approaches](https://www.youtube.com/watch?v=CBrUE6Qwfag) (Proaktive Sicherheit: Überlegungen und Ansätze)
**Zugehörige Beispiele:**
+ [Workshop on threat modeling](https://catalog.workshops.aws/threatmodel) (Workshop zur Bedrohungsmodellierung)
+ [Industry awareness for developers](https://owasp.org/www-project-top-ten/) (Branchenbewusstsein für Entwickler)
**Zugehörige Services:**
+ [AWS CloudFormation](https://aws.amazon.com/cloudformation/)
+ [AWS Cloud Development Kit (AWS CDK) (AWS CDK) Konstrukte](https://docs.aws.amazon.com/cdk/v2/guide/constructs.html)
+ [Service Catalog](https://aws.amazon.com/servicecatalog/)
+ [AWS BugBust](https://docs.aws.amazon.com/codeguru/latest/bugbust-ug/what-is-aws-bugbust.html)
# SEC11-BP02 Das Testen während des Entwicklungs- und Veröffentlichungslebenszyklus automatisieren
Automatisieren Sie das Testen der Sicherheitseigenschaften während des Entwicklungs- und Veröffentlichungslebenszyklus. Automatisierung vereinfacht die kontinuierliche und wiederholbare Identifizierung potenzieller Probleme. Dadurch wird das Risiko von Sicherheitsproblemen bei der bereitgestellten Software verringert.
**Gewünschtes Resultat: **Das Ziel von automatisiertem Testen ist, eine programmatische Möglichkeit zur frühen Erkennung von potenziellen Problemen – häufig im Laufe des Entwicklungslebenszyklus – zu bieten. Wenn Sie Regressionstests automatisieren, können Sie funktionale und nicht-funktionale Tests erneut durchführen, um zu überprüfen, ob zuvor getestete Software nach einer Änderung weiterhin wie erwartet funktioniert. Wenn Sie Sicherheitstests für Komponenten definieren, um nach häufigen Fehlkonfigurationen zu suchen, wie einer fehlerhaften oder fehlenden Authentifizierung, können Sie diese Fehler früh im Entwicklungsprozess identifizieren und beheben.
Testautomatisierung verwendet speziell entwickelte Testfälle zur Anwendungsvalidierung auf Basis der Anforderungen und der gewünschten Funktionalität der Anwendung. Das Ergebnis von automatisiertem Testen basiert auf dem Vergleich zwischen der erstellten Testausgabe und der erwarteten Ausgabe, wodurch der gesamte Lebenszyklus des Testens beschleunigt wird. Testmethoden wie Regressionstests und Komponententestsuites eignen sich am besten zur Automatisierung. Durch die Automatisierung des Testens von Sicherheitseigenschaften können Entwickler automatisiertes Feedback erhalten, ohne auf eine Sicherheitsüberprüfung warten zu müssen. Automatisierte Tests in Form von statischer oder dynamischer Codeanalyse können die Qualität von Code erhöhen und dabei helfen, potenzielle Softwareprobleme früh im Entwicklungslebenszyklus zu erkennen.
**Typische Anti-Muster:**
+ Testfälle und Testergebnisse des automatisierten Testens nicht kommunizieren.
+ Automatisiertes Testen nur vor einer Veröffentlichung durchführen.
+ Testfälle mit sich häufig ändernden Anforderungen automatisieren.
+ Keine Anweisungen für den Umgang mit den Ergebnissen von Sicherheitstests bieten.
**Vorteile der Nutzung dieser bewährten Methode:**
+ Verringerte Abhängigkeit von Menschen, um die Sicherheitseigenschaften eines Systems zu evaluieren.
+ Beständige Resultate bei mehreren Arbeitsabläufen verbessern die Konsistenz.
+ Verringerte Wahrscheinlichkeit, dass Sicherheitsprobleme in die Softwareproduktion eingeschleppt werden.
+ Kürzeres Zeitfenster zwischen der Erkennung und Lösung von Softwareproblemen, da sie früher entdeckt werden.
+ Erhöhte Sichtbarkeit von systemischem oder wiederholtem Verhalten bei mehreren Arbeitsabläufen, dank derer unternehmensweite Verbesserungen vorangetrieben werden können.
** Risikostufe, wenn diese bewährte Methode nicht eingeführt wird:** mittel
## Implementierungsleitfaden
Setzen Sie während der Entwicklung Ihrer Software unterschiedliche Mechanismen für das Testen von Software ein, um sicherzustellen, dass Sie Ihre Anwendung sowohl auf funktionale Anforderungen – basierend auf Ihrer Geschäftslogik – als auch auf nicht-funktionale Anforderungen testen, die sich auf die Zuverlässigkeit, Leistung und Sicherheit der Anwendung konzentrieren.
Statisches Anwendungssicherheitstesten (SAST) untersucht Ihren Quellcode auf Anomalien bei Sicherheitsmustern und bietet Hinweise auf einen fehleranfälligen Code. SAST nutzt statische Eingaben, wie Dokumentation (Anforderungsspezifikationen, Designdokumentation und Designspezifikationen) und den Anwendungscode, um Tests in Bezug auf eine Reihe von bekannten Sicherheitsproblemen durchzuführen. Statische Code-Analyzer helfen dabei, die Analyse von großen Codemengen zu beschleunigen. Die [NIST Quality Group](https://www.nist.gov/itl/ssd/software-quality-group) bietet einen Vergleich von [Source Code Security Analyzers](https://www.nist.gov/itl/ssd/software-quality-group/source-code-security-analyzers), die Open-Source-Tools für [Byte Code Scanner](https://samate.nist.gov/index.php/Byte_Code_Scanners.html) und [Binary Code Scanner](https://samate.nist.gov/index.php/Binary_Code_Scanners.html) enthalten.
Ergänzen Sie Ihr statisches Testen mit Methodologien zum dynamischen Anwendungssicherheitstesten (DAST), wobei die Anwendung bei ihrer Ausführung getestet wird, um potenzielles unerwartetes Verhalten zu identifizieren. Dynamisches Testen kann verwendet werden, um potenzielle Probleme zu erkennen, die über die statische Analyse nicht gefunden werden können. Das Testen der Code-Repository-, Build- und Pipeline-Stadien ermöglicht Ihnen, nach unterschiedlichen Arten potenzieller Fehler in Ihrem Code zu suchen. [Amazon CodeWhisperer](https://aws.amazon.com/codewhisperer/) bietet Codeempfehlungen, einschließlich Sicherheitsscans in der IDE des Entwicklers. [Amazon CodeGuru Reviewer](https://aws.amazon.com/codeguru/) kann kritische Fehler, Sicherheitsprobleme und schwer zu findende Bugs während der Anwendungsentwicklung identifizieren und bietet Empfehlungen zur Verbesserung der Codequalität.
Der [Workshop „Security for Developers“](https://catalog.workshops.aws/sec4devs) verwendet AWS-Entwickler-Tools, wie [AWS CodeBuild](https://aws.amazon.com/codebuild/), [AWS CodeCommit](https://aws.amazon.com/codecommit/) und [AWS CodePipeline](https://aws.amazon.com/codepipeline/) für die Automatisierung der Veröffentlichungs-Pipeline, die SAST- und DAST-Testmethodologien umfasst.
Richten Sie beim Durchlaufen Ihres Softwareentwicklungs-Lebenszyklus einen iterativen Prozess ein, der regelmäßige Anwendungsüberprüfungen mit Ihrem Sicherheitsteam enthält. Aus diesen Sicherheitsüberprüfungen gewonnenes Feedback sollte adressiert und im Rahmen der Bereitschaftsüberprüfung Ihrer Softwareversion validiert werden. Diese Überprüfungen schaffen einen robusten Sicherheitsstatus der Anwendungen und bieten Entwicklern umsetzbares Feedback, um Maßnahmen zum Beheben von Problemen zu ergreifen.
### Implementierungsschritte
+ Implementieren Sie eine integrierte Entwicklungsumgebung, Codeüberprüfung und CI/CD-Tools, die Sicherheitstests enthalten.
+ Überlegen Sie, wo im Softwareentwicklungs-Lebenszyklus Pipelines blockiert werden können, anstatt Entwickler darüber zu informieren, dass Probleme behoben werden müssen.
+ Der [Workshop „Security for Developers“](https://catalog.workshops.aws/sec4devs) bietet ein Beispiel für das Integrieren von statischem und dynamischem Testen in eine Veröffentlichungs-Pipeline.
+ Das Durchführen von Tests oder Codeanalyse mithilfe von automatisierten Tools, wie [Amazon CodeWhisperer](https://aws.amazon.com/codewhisperer/), das mit IDEs von Entwicklern integriert ist, und [Amazon CodeGuru Reviewer](https://aws.amazon.com/codeguru/) für das Scannen von Code beim Commit, ermöglicht Entwicklern, Feedback zur richtigen Zeit zu erhalten.
+ Beim Entwickeln mithilfe von AWS Lambda können Sie [Amazon Inspector](https://aws.amazon.com/about-aws/whats-new/2023/02/code-scans-lambda-functions-amazon-inspector-preview/) verwenden, um den Anwendungscode in Ihren Funktionen zu scannen.
+ Der [AWS CI/CD-Workshop](https://catalog.us-east-1.prod.workshops.aws/workshops/ef1c179d-8097-4f34-8dc3-0e9eb381b6eb/en-US/) bietet einen Ausgangspunkt für das Entwickeln von CI/CD-Pipelines auf AWS.
+ Wenn automatisiertes Testen bei CI/CD-Pipelines enthalten ist, sollten Sie ein Ticketing-System verwenden, um das Melden und Lösen von Softwareproblemen nachzuverfolgen.
+ Bei Sicherheitstests, die möglicherweise Erkenntnisse liefern, sollten Sie Lösungsanweisungen bieten, damit Entwickler die Codequalität verbessern können.
+ Analysieren Sie von automatisierten Tools gewonnenen Einblicke, um die nächste Automatisierung, Entwicklerschulung oder Bewusstmachungskampagne zu planen.
## Ressourcen
**Zugehörige Dokumente:**
+ [Continuous Delivery und Continuous Deployment](https://aws.amazon.com/devops/continuous-delivery/)
+ [AWS DevOps Competency Partners](https://aws.amazon.com/devops/partner-solutions/?blog-posts-cards.sort-by=item.additionalFields.createdDate&blog-posts-cards.sort-order=desc&partner-solutions-cards.sort-by=item.additionalFields.partnerNameLower&partner-solutions-cards.sort-order=asc&awsf.partner-solutions-filter-partner-type=partner-type%23technology&awsf.Filter%20Name%3A%20partner-solutions-filter-partner-location=*all&awsf.partner-solutions-filter-partner-location=*all&partner-case-studies-cards.sort-by=item.additionalFields.sortDate&partner-case-studies-cards.sort-order=desc&awsm.page-partner-solutions-cards=1) (AWS-Dev-Ops-Kompetenzpartner)
+ [AWS Security Competency Partners](https://aws.amazon.com/security/partner-solutions/?blog-posts-cards.sort-by=item.additionalFields.createdDate&blog-posts-cards.sort-order=desc&partner-solutions-cards.sort-by=item.additionalFields.partnerNameLower&partner-solutions-cards.sort-order=asc&awsf.partner-solutions-filter-partner-type=*all&awsf.Filter%20Name%3A%20partner-solutions-filter-partner-categories=use-case%23app-security&awsf.partner-solutions-filter-partner-location=*all&partner-case-studies-cards.sort-by=item.additionalFields.sortDate&partner-case-studies-cards.sort-order=desc&events-master-partner-webinars.sort-by=item.additionalFields.startDateTime&events-master-partner-webinars.sort-order=asc) for Application Security (Sicherheitskompetenzpartner für Anwendungssicherheit)
+ [Choosing a Well-Architected CI/CD approach](https://aws.amazon.com/blogs/devops/choosing-well-architected-ci-cd-open-source-software-aws-services/) (Auswählen eines Well-Architected-CI/CD-Ansatzes)
+ [Monitoring CodeCommit events in Amazon EventBridge and Amazon CloudWatch Events](https://docs.aws.amazon.com/codecommit/latest/userguide/monitoring-events.html) (Überwachen von AWS-CodeCommit-Ereignissen in Amazon EventBridge und Amazon CloudWatch Events)
+ [Secrets detection in Amazon CodeGuru Review](https://docs.aws.amazon.com/codeguru/latest/reviewer-ug/recommendations.html#secrets-detection) (Secrets-Erkennung bei der Code-Überprüfung in CodeGuru Reviewer)
+ [Accelerate deployments on AWS with effective governance](https://aws.amazon.com/blogs/architecture/accelerate-deployments-on-aws-with-effective-governance/) (Beschleunigen von Bereitstellungen auf AWS mit effektiver Governance)
+ [How AWS approaches automating safe, hands-off deployments](https://aws.amazon.com/builders-library/automating-safe-hands-off-deployments/) (Wie AWS die Automatisierung sicherer, vollautomatischer Bereitstellungen durchführt)
**Zugehörige Videos:**
+ [Hands-off: Automating continuous delivery pipelines at Amazon](https://www.youtube.com/watch?v=ngnMj1zbMPY) (Vollständige Automatisierung: Automatisieren der Pipelines für kontinuierliche Bereitstellung bei Amazon)
+ [Automating cross-account CI/CD pipelines](https://www.youtube.com/watch?v=AF-pSRSGNks) (Automatisieren von kontoübergreifenden CI/CD-Pipelines)
**Zugehörige Beispiele:**
+ [Industry awareness for developers](https://owasp.org/www-project-top-ten/) (Branchenbewusstsein für Entwickler)
+ [AWS CodePipeline Governance](https://github.com/awslabs/aws-codepipeline-governance) (GitHub)
+ [Workshop „Security for Developers“](https://catalog.us-east-1.prod.workshops.aws/workshops/66275888-6bab-4872-8c6e-ed2fe132a362/en-US) (Workshop „Sicherheit für Entwickler“)
+ [AWS-CI/CD-Workshop](https://catalog.us-east-1.prod.workshops.aws/workshops/ef1c179d-8097-4f34-8dc3-0e9eb381b6eb/en-US/)
# SEC11-BP03 Regelmäßig Penetrationstests durchführen
Führen Sie regelmäßige Penetrationstests bei Ihrer Software durch. Dieser Mechanismus hilft bei der Identifizierung potenzieller Softwareprobleme, die bei automatisierten Tests oder einer manuellen Überprüfung des Codes nicht erkannt werden können. Er kann Ihnen außerdem dabei helfen, die Wirksamkeit Ihrer Erkennungskontrollen zu verstehen. Penetrationstests sollten feststellen, ob es möglich ist, die Software so zu beeinflussen, dass sie auf unerwartete Weise ausgeführt wird, beispielsweise das Freigeben von Daten, die geschützt sein sollten, oder die Gewährung umfassenderer Berechtigungen als erwartet.
**Gewünschtes Ergebnis:** Penetrationstests werden verwendet, um die Sicherheitseigenschaften Ihrer Anwendung zu erkennen, zu lösen und zu validieren. Regelmäßige und geplante Penetrationstests sollten als Teil des Softwareentwicklungs-Lebenszyklus durchgeführt werden. Die aus Penetrationstests gewonnenen Erkenntnisse sollten vor der Veröffentlichung der Software adressiert werden. Sie sollten die Ergebnisse von Penetrationstests verwenden, um festzustellen, ob es sich um Probleme handelt, die mithilfe von Automatisierung gefunden werden könnten. Ein regelmäßiger und wiederholbarer Prozess für Penetrationstests, der einen aktiven Feedback-Mechanismus umfasst, fließt in die Anweisungen für Entwickler ein und verbessert die Softwarequalität.
**Typische Anti-Muster:**
+ Penetrationstests nur für bekannte oder weit verbreitete Sicherheitsprobleme verwenden.
+ Penetrationstests bei Anwendungen ohne abhängige Drittanbieter-Tools und -Bibliotheken durchführen.
+ Penetrationstests nur bei Paketsicherheitsproblemen durchführen und die implementierte Geschäftslogik nicht evaluieren.
**Vorteile der Nutzung dieser bewährten Methode:**
+ Gesteigertes Vertrauen in die Sicherheitseigenschaften der Software vor der Veröffentlichung.
+ Die Möglichkeit, bevorzugte Anwendungsmuster zu identifizieren, wodurch die Softwarequalität erhöht wird.
+ Verbresserte Sicherheitseigenschaften von Software durch eine Feedbackschleife, die früher im Entwicklungszyklus bestimmt, wo Automatisierung oder zusätzliche Schulungen erforderlich sind.
** Risikostufe, wenn diese bewährte Methode nicht eingeführt wird:** hoch
## Implementierungsleitfaden
Penetrationstests sind eine strukturierte Sicherheitstestübung, wobei Sie Szenarios mit geplanten Sicherheitsverstößen durchführen, um Sicherheitskontrollen zu erkennen, zu lösen und zu validieren. Penetrationstests starten mit einer Erkundung, bei der Daten basierend auf dem aktuellen Design der Anwendung und ihrer Abhängigkeiten erfasst werden. Eine kuratierte Liste an sicherheitsspezifischen Testszenarios wird entwickelt und ausgeführt. Der wesentliche Zweck dieser Tests ist, die Sicherheitsprobleme in Ihrer Anwendung aufzudecken, die dazu genutzt werden könnten, unbeabsichtigten Zugriff auf Ihre Umgebung oder unautorisierten Zugriff auf Daten zu erhalten. Sie sollten Penetrationstests durchführen, wenn Sie neue Funktionen einführen oder wenn bei Ihrer Anwendung wesentliche Änderungen hinsichtlich der Funktion oder technischen Implementierung erfolgt sind.
Sie sollten in Ihrem Entwicklungslebenszyklus die am besten geeignete Phase bestimmen, um Penetrationstests durchzuführen. Das Testen sollte so spät stattfinden, dass sich das System nahe am vorgesehenen Veröffentlichungszustand befindet, aber es sollte ausreichend Zeit vorhanden sein, damit Probleme behoben werden können.
### Implementierungsschritte
+ Implementieren Sie einen strukturierten Prozess für den Umfang der Penetrationstests und dieser Prozess sollte auf einem [Bedrohungsmodell](https://aws.amazon.com/blogs/security/how-to-approach-threat-modeling/) basieren, um den Kontext zu bewahren.
+ Bestimmen Sie den geeigneten Zeitpunkt im Entwicklungszyklus zum Durchführen von Penetrationstests. Penetrationstests sollten dann erfolgen, wenn die geringsten Änderungen an der Anwendung erwartet werden, aber noch ausreichend Zeit für die Fehlerbehebung übrig ist.
+ Schulen Sie Ihre Entwickler in Bezug darauf, was sie von den Ergebnissen von Penetrationstests erwarten und wie Informationen zur Mängelbeseitigung erhalten können.
+ Verwenden Sie Tools zum Beschleunigen des Penetrationstestvorgangs, indem Sie gängige oder wiederholbare Tests automatisieren.
+ Analysieren Sie Ergebnisse von Penetrationstests, um systemische Sicherheitsprobleme zu identifizieren, und verwenden Sie diese Daten, um sie in zusätzliche automatisierte Tests und fortlaufende Entwicklerschulungen einfließen zu lassen.
## Ressourcen
**Zugehörige bewährte Methoden:**
+ [SEC11-BP01 Für Anwendungssicherheit schulen](sec_appsec_train_for_application_security.md)
+ [SEC11-BP02 Das Testen während des Entwicklungs- und Veröffentlichungslebenszyklus automatisieren](sec_appsec_automate_testing_throughout_lifecycle.md)
**Zugehörige Dokumente:**
+ [AWS-Penetrationstest](https://aws.amazon.com/security/penetration-testing/) bieten ausführliche Anweisungen für Penetrationstests mit AWS
+ [Accelerate deployments on AWS with effective governance](https://aws.amazon.com/blogs/architecture/accelerate-deployments-on-aws-with-effective-governance/) (Beschleunigen von Bereitstellungen auf AWS mit effektiver Governance)
+ [AWS Security Competency Partners](https://aws.amazon.com/security/partner-solutions/?blog-posts-cards.sort-by=item.additionalFields.createdDate&blog-posts-cards.sort-order=desc&partner-solutions-cards.sort-by=item.additionalFields.partnerNameLower&partner-solutions-cards.sort-order=asc&awsf.partner-solutions-filter-partner-type=*all&awsf.Filter%20Name%3A%20partner-solutions-filter-partner-categories=*all&awsf.partner-solutions-filter-partner-location=*all&partner-case-studies-cards.sort-by=item.additionalFields.sortDate&partner-case-studies-cards.sort-order=desc&events-master-partner-webinars.sort-by=item.additionalFields.startDateTime&events-master-partner-webinars.sort-order=asc) (AWS-Kompetenzpartner für Sicherheit)
+ [Modernize your penetration testing architecture on AWS Fargate](https://aws.amazon.com/blogs/architecture/modernize-your-penetration-testing-architecture-on-aws-fargate/) (Modernisieren Ihrer Penetrationstestarchitektur auf AWS Fargate)
+ [AWS Fault Injection Simulator](https://aws.amazon.com/fis/)
**Zugehörige Beispiele:**
+ [Automate API testing with AWS CodePipeline](https://github.com/aws-samples/aws-codepipeline-codebuild-with-postman) (Automatisieren von API-Testen mit AWS Codepipeline mit Postman) (GitHub)
+ [Automated security helper](https://github.com/aws-samples/automated-security-helper) (Automatisierter Sicherheitshelfer) (GitHub)
# SEC11-BP04 Manuelle Codeüberprüfungen
Führen Sie eine manuelle Codeüberprüfung der von Ihnen produzierten Software durch. Dieser Prozess hilft zu verifizieren, dass die Person, die den Code geschrieben hat, die Qualität des Codes nicht allein überprüft.
**Gewünschtes Ergebnis:** Das Hinzufügen einer manuellen Codeüberprüfung während der Entwicklung erhöht die Qualität der geschriebenen Software, hilft dabei, weniger erfahrene Teammitglieder weiterzubilden, und bietet eine Möglichkeit, Stellen zum Einsetzen von Automatisierung zu identifizieren. Manuelle Codeüberprüfungen können von automatisierten Tools und Tests unterstützt werden.
**Typische Anti-Muster:**
+ Keine Codeüberprüfungen vor der Bereitstellung durchführen.
+ Die gleiche Person zum Schreiben und Überprüfen des Codes einsetzen.
+ Keine Automatisierung zum Unterstützen und Orchestrieren von Codeüberprüfungen einsetzen.
+ Entwickler nicht hinsichtlich Anwendungssicherheit schulen, bevor sie Code überprüfen.
**Vorteile der Nutzung dieser bewährten Methode:**
+ Verbesserte Codequalität.
+ Erhöhte Konsistenz bei der Codeentwicklung durch das erneute Verwenden von gängigen Ansätzen.
+ Verringerte Anzahl von Schwierigkeiten, die bei Penetrationstests und in späteren Phasen entdeckt werden.
+ Verbesserter Wissenstransfer innerhalb des Teams.
**Risikostufe, wenn diese bewährte Methode nicht eingeführt wird:** mittel
## Implementierungsleitfaden
Der Überprüfungsschritt sollte als Teil des allgemeinen Codeverwaltungs-Flows implementiert werden. Die Details hängen vom Ansatz an, der für Verzweigen, Pull-Anforderungen und Zusammenführen verwendet wird. Sie verwenden möglicherweise AWS CodeCommit oder Drittanbieterlösungen wie GitHub, GitLab oder Bitbucket. Welche Methode auch immer Sie verwenden – es ist wichtig, dass Sie verifizieren, dass Ihre Prozesse eine Überprüfung von Code erfordern, bevor dieser in einer Produktionsumgebung bereitgestellt wird. Das Verwenden von Tools wie [Amazon CodeGuru Reviewer](https://docs.aws.amazon.com/codeguru/latest/reviewer-ug/welcome.html) kann das Orchestrieren des Codeüberprüfungsvorgangs vereinfachen.
### Implementierungsschritte
+ Implementieren Sie einen Schritt zur manuellen Überprüfung als Teil Ihres Codeverwaltungs-Flows und führen Sie diese Überprüfung durch, bevor Sie fortfahren.
+ Erwägen Sie [Amazon CodeGuru Reviewer](https://aws.amazon.com/codeguru/) für das Verwalten und Unterstützen bei Codeüberprüfungen.
+ Implementieren Sie einen Genehmigungs-Workflow, bei dem eine Codeüberprüfung erforderlich ist, bevor Code zur nächsten Stufe übergehen kann.
+ Verifizieren Sie, dass es einen Vorgang gibt, um Probleme bei manuellen Codeüberprüfungen zu finden, die automatisch erkannt werden könnten.
+ Integrieren Sie den Schritt zur manuellen Codeüberprüfung auf eine Weise, die mit Ihren Codeentwicklungspraktiken übereinstimmt.
## Ressourcen
**Zugehörige bewährte Methoden:**
+ [SEC11-BP02 Das Testen während des Entwicklungs- und Veröffentlichungslebenszyklus automatisieren](sec_appsec_automate_testing_throughout_lifecycle.md)
**Zugehörige Dokumente:**
+ [Working with pull requests in AWS CodeCommit repositories](https://docs.aws.amazon.com/codecommit/latest/userguide/pull-requests.html) (Arbeiten Mit Pull-Anforderungen in AWS CodeCommit)
+ [Working with approval rule templates in AWS CodeCommit](https://docs.aws.amazon.com/codecommit/latest/userguide/approval-rule-templates.html) (Arbeiten mit Genehmigungsregelvorlagen in AWS CodeCommit)
+ [About pull requests in GitHub](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/about-pull-requests) (Informationen über Pull-Anforderungen auf GitHub)
+ [Automate code reviews with Amazon CodeGuru Reviewer](https://aws.amazon.com/blogs/devops/automate-code-reviews-with-amazon-codeguru-reviewer/) (Automatisieren von Codeüberprüfungen mit Amazon CodeGuru Reviewer)
+ [Automating detection of security vulnerabilities and bugs in CI/CD pipelines using Amazon CodeGuru Reviewer CLI](https://aws.amazon.com/blogs/devops/automating-detection-of-security-vulnerabilities-and-bugs-in-ci-cd-pipelines-using-amazon-codeguru-reviewer-cli/) (Automatisieren der Erkennung von Sicherheitsschwachstellen und Bugs in CI/CD-Pipelines mithilfe der CLI von Amazon CodeGuru Reviewer
**Zugehörige Videos:**
+ [Continuous improvement of code quality with Amazon CodeGuru](https://www.youtube.com/watch?v=iX1i35H1OVw) (Kontinuierliche Verbesserung der Codequalität mit Amazon CodeGuru)
**Zugehörige Beispiele:**
+ [Security for Developers workshop](https://catalog.workshops.aws/sec4devs) (Workshop „Sicherheit für Entwickler“)
# SEC11-BP05 Services für Pakete und Abhängigkeiten zentralisieren
Stellen Sie zentralisierte Services für Entwicklungsteams bereit, sodass sie Softwarepakete und andere Abhängigkeiten erhalten können. Dadurch können Pakete validiert werden, bevor sie in die von Ihnen geschriebene Software integriert werden, und es kann eine Datenquelle für die Analyse der Software bereitgestellt werden, die in Ihrer Organisation verwendet wird.
**Gewünschtes Ergebnis:** Software besteht aus einem Set aus anderen Softwarepaketen zusätzlich zum Code, der geschrieben wird. Dadurch wird die Implementierung von häufig verwendeten Funktionen vereinfacht, wie einem JSON-Parser oder einer Verschlüsselungsbibliothek. Das logische Zentralisieren der Quellen und Abhängigkeiten für diese Pakete bietet einen Mechanismus für Sicherheitsteams, damit diese die Eigenschaften der Pakete validieren können, bevor sie verwendet werden. Dieser Ansatz verringert auch das Risiko, dass ein unerwartetes Problem durch die Änderung eines vorhandenen Pakets verursacht wird oder dass Entwicklungsteams beliebige Pakete direkt aus dem Internet einbeziehen. Verwenden Sie diesen Ansatz zusammen mit manuellem und automatischem Testen, um das Vertrauen in die Qualität der entwickelten Software zu steigern.
**Typische Anti-Muster:**
+ Pakete aus beliebigen Repositorys im Internet abrufen.
+ Neue Pakete nicht testen, bevor sie für Entwickler verfügbar gemacht werden.
**Vorteile der Nutzung dieser bewährten Methode:**
+ Besseres Verständnis darüber, welche Pakete in der entwickelten Software verwendet werden.
+ Benachrichtigung von Workload-Teams, wenn ein Paket aktualisiert werden muss – basierend auf dem Verständnis davon, wer was verwendet.
+ Geringeres Risiko, dass ein Paket mit Problemen in Ihrer Software enthalten ist.
**Risikostufe, wenn diese bewährte Methode nicht eingeführt wird:** mittel
## Implementierungsleitfaden
Stellen Sie zentralisierte Services für Pakete und Abhängigkeiten so bereit, dass sie von Entwicklern einfach verwendet werden können. Zentralisierte Services können logisch zentral sein, anstatt als monolithisches System implementiert zu werden. Mit diesem Ansatz können Sie Services anbieten, die die Anforderungen Ihrer Entwickler erfüllen. Sie sollten eine effiziente Möglichkeit zum Hinzufügen von Paketen zum Repository implementieren, wenn Updates erfolgen oder neue Anforderungen aufkommen. Mithilfe von AWS-Services wie [AWS CodeArtifact](https://aws.amazon.com/codeartifact/) oder ähnlichen AWS-Partnerlösungen kann diese Funktion geboten werden.
### Implementierungsschritte:
+ Implementieren Sie einen logisch zentralisierten Repository-Service, der in allen Umgebungen, in welchen die Software entwickelt wird, verfügbar ist.
+ Fügen Sie den Zugriff auf das Repository als Teil des AWS-Konto-Vergabeprozesses hinzu.
+ Entwickeln Sie eine Automatisierung zum Testen von Paketen, bevor diese in einem Repository veröffentlicht werden.
+ Pflegen Sie Metriken der am häufigsten verwendeten Pakete, Sprachen und Teams mit den häufigsten Änderungen.
+ Stellen Sie Entwicklungsteams einen automatisierten Mechanismus bereit, damit sie neue Pakete anfordern und Feedback abgeben können.
+ Scannen Sie regelmäßig Pakete in Ihrem Repository, um die Auswirkungen von kürzlich entdecken Problemen zu identifizieren.
## Ressourcen
**Zugehörige bewährte Methoden:**
+ [SEC11-BP02 Das Testen während des Entwicklungs- und Veröffentlichungslebenszyklus automatisieren](sec_appsec_automate_testing_throughout_lifecycle.md)
**Zugehörige Dokumente:**
+ [Accelerate deployments on AWS with effective governance](https://aws.amazon.com/blogs/architecture/accelerate-deployments-on-aws-with-effective-governance/) (Beschleunigen von Bereitstellungen auf AWS mit effektiver Governance)
+ [Tighten your package security with CodeArtifact Package Origin Control toolkit](https://aws.amazon.com/blogs/devops/tighten-your-package-security-with-codeartifact-package-origin-control-toolkit/) (Erhöhen Ihrer Paketsicherheit mit dem Toolkit von CodeArtifact Package Origin Control)
+ [Detecting security issues in logging with Amazon CodeGuru Reviewer](https://aws.amazon.com/blogs/devops/detecting-security-issues-in-logging-with-amazon-codeguru-reviewer/) (Erkennen von Sicherheitsproblemen beim Protokollieren mit Amazon CodeGuru Reviewer)
+ [Supply chain Levels for Software Artifacts (SLSA)](https://slsa.dev/) (Lieferkettenebenen für Software-Artefakte)
**Zugehörige Videos:**
+ [Proactive security: Considerations and approaches](https://www.youtube.com/watch?v=CBrUE6Qwfag) (Proaktive Sicherheit: Überlegungen und Ansätze)
+ [The AWS Philosophy of Security (re:Invent 2017)](https://www.youtube.com/watch?v=KJiCfPXOW-U) (Die AWS-Philosophie zu Sicherheit)
+ [When security, safety, and urgency all matter: Handling Log4Shell](https://www.youtube.com/watch?v=pkPkm7W6rGg) (Wenn Sicherheit und Dringlichkeit von Bedeutung sind: Umgang mit Log4Shell)
**Zugehörige Beispiele:**
+ [Multi Region Package Publishing Pipeline](https://github.com/aws-samples/multi-region-python-package-publishing-pipeline) (Mehrregions-Veröffentlichungs-Pipeline für Pakete) (GitHub)
+ [Publishing Node.js Modules on AWS CodeArtifact using AWS CodePipeline](https://github.com/aws-samples/aws-codepipeline-publish-nodejs-modules) (Node.js-Module auf AWS CodeArtifact mithilfe von AWS CodePipeline veröffentlichen) (GitHub)
+ [AWS CDK Java CodeArtifact Pipeline Sample](https://github.com/aws-samples/aws-cdk-codeartifact-pipeline-sample) (Beispiel für eine Java-CodeArtifact-Pipeline) (GitHub)
+ [Distribute private .NET NuGet packages with AWS CodeArtifact](https://github.com/aws-samples/aws-codeartifact-nuget-dotnet-pipelines) (Verteilen von privaten .NET-NuGet-Pakete mit AWS CodeArtifact) (GitHub)
# SEC11-BP06 Software programmgesteuert bereitstellen
Führen Sie Bereitstellungen von Software möglichst programmgesteuert durch. Dieser Ansatz verringert die Wahrscheinlichkeit eines Bereitstellungsfehlers oder der Einführung eines unerwarteten Problem aufgrund eines menschlichen Fehlers.
**Gewünschtes Ergebnis: **Menschen von Daten fernhalten ist eines der Prinzipien für sicheres Entwickeln in der AWS Cloud. Dieses Prinzip umfasst, wie Sie Ihre Software bereitstellen.
Wenn Sie sich nicht auf Menschen verlassen müssen, um Software bereitzustellen, bietet dies den Vorteil, dass Sie mehr Vertrauen darin haben können, dass das, was getestet wird, auch das ist, was bereitgestellt wird, und dass die Bereitstellung jedes Mal konsistent durchgeführt wird. Die Software sollte nicht geändert werden müssen, um in unterschiedlichen Umgebungen zu funktionieren. Mithilfe der Prinzipien der 12-Faktor-Anwendungsentwicklung, insbesondere dem Externalisieren der Konfiguration, können Sie denselben Code ohne Änderungen in mehreren Umgebungen bereitstellen. Das kryptografische Signieren von Softwarepaketen ist eine gute Möglichkeit, zu verifizieren, dass sich zwischen den Umgebungen nichts geändert hat. Das Gesamtergebnis dieses Ansatzes ist die Risikoverringerung bei Ihrem Änderungsprozess und die Verbesserung der Konsistenz von Softwareveröffentlichungen.
**Typische Anti-Muster:**
+ Software manuell in die Produktion bereitstellen.
+ Manuelle Änderungen an Software durchführen, um unterschiedliche Umgebungen zu bedienen.
**Vorteile der Nutzung dieser bewährten Methode:**
+ Gesteigertes Vertrauen in den Prozess der Softwareveröffentlichung.
+ Verringertes Risiko, dass eine fehlgeschlagene Änderung, die Geschäftsfunktionen beeinträchtigt.
+ Erhöhte Veröffentlichungsfrequenz, aufgrund eines geringeren Änderungsrisikos.
+ Automatische Rollback-Funktion für unerwartete Ereignisse während der Bereitstellung.
+ Die Möglichkeit, kryptografisch zu beweisen, dass es sich bei der getesteten Software um die bereitgestellte Software handelt.
**Risikostufe, wenn diese bewährte Methode nicht eingeführt wird:** hoch
## Implementierungsleitfaden
Entwickeln Sie Ihre AWS-Konto-Struktur, um den fortlaufenden menschlichen Zugriff über Umgebungen zu verhindern und CI/CD-Tools zum Durchführen von Bereitstellungen zu verwenden. Entwerfen Sie Ihre Anwendungen so, dass umgebungsspezifische Konfigurationsdaten von externen Quellen gewonnen werden, wie [AWS Systems Manager Parameter Store](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-parameter-store.html). Signieren Sie Pakete, nachdem sie getestet wurden, und validieren Sie diese Signaturen während der Bereitstellung. Konfigurieren Sie Ihre CI/CD-Pipelines, um den Anwendungscode zu übertragen und verwenden Sie Canaries, um die erfolgreiche Bereitstellung zu bestätigen. Verwenden Sie Tools wie [AWS CloudFormation](https://aws.amazon.com/cloudformation/) oder [AWS CDK](https://aws.amazon.com/cdk/), um Ihre Infrastruktur zu definieren, und verwenden Sie dann [AWS CodeBuild](https://aws.amazon.com/codebuild/) und [AWS CodePipeline](https://aws.amazon.com/codepipeline/), um CI/CD-Vorgänge durchzuführen.
### Implementierungsschritte
+ Entwicklen Sie gut definierte CI/CD-Pipelines, um den Bereitstellungsprozess zu optimieren.
+ Die Verwendung von [AWS CodeBuild](https://aws.amazon.com/codebuild/) und [AWS Code Pipeline](https://aws.amazon.com/codepipeline/), um die CI/CD-Funktionalität zu bieten, vereinfacht das Integrieren von Sicherheitstesten in Ihre Pipelines.
+ Befolgen Sie die Anweisungen für die Trennung von Umgebungen im Whitepaper [Organisation Ihrer AWS-Umgebung mit mehreren Konten](https://docs.aws.amazon.com/whitepapers/latest/organizing-your-aws-environment/organizing-your-aws-environment.html).
+ Verifzieren Sie, dass es keinen fortlaufenden Zugriff durch Personen auf Umgebungen gibt, in welchen Produktions-Workloads ausgeführt werden.
+ Entwickeln Sie Ihre Anwendungen so, dass sie die Externalisierung von Konfigurationsdaten unterstützen.
+ Ziehen Sie eine Bereitstellung mithilfe eines Blau/Grün-Modells in Betracht.
+ Setzen Sie Canaries ein, um die erfolgreiche Bereitstellung der Software zu validieren.
+ Verwenden Sie kryptografische Tools wie [AWS Signer](https://docs.aws.amazon.com/signer/latest/developerguide/Welcome.html) oder [AWS Key Management Service (AWS KMS)](https://aws.amazon.com/kms/), um die Softwarepakete, die Sie bereitstellen, zu signieren und zu verifizieren.
## Ressourcen
**Zugehörige bewährte Methoden:**
+ [SEC11-BP02 Das Testen während des Entwicklungs- und Veröffentlichungslebenszyklus automatisieren](sec_appsec_automate_testing_throughout_lifecycle.md)
**Zugehörige Dokumente:**
+ [AWS-CI/CD-Workshop](https://catalog.us-east-1.prod.workshops.aws/workshops/ef1c179d-8097-4f34-8dc3-0e9eb381b6eb/en-US/)
+ [Accelerate deployments on AWS with effective governance](https://aws.amazon.com/blogs/architecture/accelerate-deployments-on-aws-with-effective-governance/) (Beschleunigen von Bereitstellungen auf AWS mit effektiver Governance)
+ [Automating safe, hands-off deployments](https://aws.amazon.com/builders-library/automating-safe-hands-off-deployments/) (Automatisierung sicherer, vollautomatischer Bereitstellungen)
+ [Code signing using AWS Certificate Manager Private CA and AWS Key Management Service asymmetric keys](https://aws.amazon.com/blogs/security/code-signing-aws-certificate-manager-private-ca-aws-key-management-service-asymmetric-keys/) (Codesignatur mithilfe von AWS Certificate Manager Private CA und asymmetrischen Schlüsseln von AWS Key Management Service)
+ [Code Signing, a Trust and Integrity Control for AWS Lambda](https://aws.amazon.com/blogs/aws/new-code-signing-a-trust-and-integrity-control-for-aws-lambda/) (Codesignatur, eine Vertrauens- und Integritätskontrolle für AWS Lambda)
**Zugehörige Videos:**
+ [Hands-off: Automating continuous delivery pipelines at Amazon](https://www.youtube.com/watch?v=ngnMj1zbMPY) (Vollständige Automatisierung: Automatisieren der Pipelines für kontinuierliche Bereitstellung bei Amazon)
**Zugehörige Beispiele:**
+ [Blue/Green deployments with AWS Fargate](https://catalog.us-east-1.prod.workshops.aws/workshops/954a35ee-c878-4c22-93ce-b30b25918d89/en-US) (Blau/Grün-Bereitstellungen mit AWS Fargate)
# SEC11-BP07 Die Sicherheitseigenschaften der Pipelines regelmäßig bewerten
Wenden Sie die Prinzipien der Säule der Well-Architected-Sicherheit bei Ihren Pipelines an und achten Sie dabei besonders auf die Trennung von Berechtigungen. Bewerten Sie die Sicherheitseigenschaften Ihrer Pipeline-Infrastruktur regelmäßig. Durch die effektive Verwaltung *der* Pipeline-Sicherheit können Sie bei der Software, die diese Pipelines *durchläuft*, für Sicherheit sorgen.
**Gewünschtes Ergebnis:** Die Pipelines, die zum Entwickeln und Bereitstellen Ihrer Software verwendet werden, sollten dieselben empfohlenen Praktiken wie jeder andere Workload in Ihrer Umgebung befolgen. Die Tests, die in den Pipelines implementiert sind, sollten nicht von Entwicklern bearbeitet werden können, die sie verwenden. Die Pipelines sollten nur Berechtigungen für die Bereitstellungen haben, die sie durchführen, und sollten Sicherheitsmaßnahmen zum Verhindern von Bereitstellungen in den falschen Umgebungen implementieren. Pipelines sollten sich nicht auf langfristige Anmeldeinformationen verlassen und sollten konfiguriert sein, um den Status auszugeben, sodass die Integrität der Entwicklungsumgebung validiert werden kann.
**Typische Anti-Muster:**
+ Sicherheitstests können von Entwicklern umgangen werden.
+ Berechtigungen für Bereitstellungs-Pipelines sind übermäßig breit gefasst.
+ Pipelines sind nicht konfiguriert, um Eingaben zu validieren.
+ Berechtigungen in Zusammenhang mit Ihrer CI/CD-Infrastruktur werden nicht regelmäßig überprüft.
+ Langfristige oder fest codierte Anmeldeinformationen werden verwendet.
**Vorteile der Nutzung dieser bewährten Methode:**
+ Größeres Vertrauen in die Integrität der Software, die über die Pipelines entwickelt und bereitgestellt wird.
+ Eine Bereitstellung kann angehalten werden, wenn es verdächtige Aktivitäten gibt.
** Risikostufe, wenn diese bewährte Methode nicht eingeführt wird:** hoch
## Implementierungsleitfaden
Durch den Beginn mit CI/CD-Services, die IAM-Rollen unterstützen, wird das Risiko von Anmeldeinformationslecks verringert. Durch das Anwenden der Prinzipien der Säule „Sicherheit“ auf Ihre CI/CD-Pipeline-Infrastruktur können Sie bestimmen, wo Sicherheitsverbesserungen durchgeführt werden können. Das Befolgen der [AWS Deployment Pipelines Reference Architecture](https://aws.amazon.com/blogs/aws/new_deployment_pipelines_reference_architecture_and_-reference_implementations/) (Referenzarchitektur für AWS-Bereitstellungs-Pipelines) ist ein guter Startpunkt für das Erstellen Ihrer eigenen CI/CD-Umgebungen. Regelmäßige Überprüfungen der Pipeline-Implementierung und Untersuchungen von Protokollen auf unerwartetes Verhalten können Ihnen dabei helfen, die Verwendungsmuster der Pipelines, die zum Bereitstellen der Software verwendet werden, besser zu verstehen.
### Implementierungsschritte
+ Beginnen Sie mit der [AWS Deployment Pipelines Reference Architecture](https://aws.amazon.com/blogs/aws/new_deployment_pipelines_reference_architecture_and_-reference_implementations/) (Referenzarchitektur für AWS-Bereitstellungs-Pipelines).
+ Erwägen Sie, [AWS IAM Access Analyzer](https://docs.aws.amazon.com//latest/UserGuide/what-is-access-analyzer.html) zu verwenden, um für die Pipelines programmatisch IAM-Richtlinien mit der geringsten Berechtigung zu erstellen.
+ Integrieren Sie Ihre Pipelines mit Überwachung und Benachrichtigung, sodass Sie über unerwartete oder abnorme Aktivitäten benachrichtigt werden. Bei von AWS verwalteten Services können Sie mithilfe von [Amazon EventBridge](https://aws.amazon.com/eventbridge/) Daten zu Zielen wie [AWS Lambda](https://aws.amazon.com/lambda/) oder [Amazon Simple Notification Service](https://aws.amazon.com/sns/) (Amazon SNS) umleiten.
## Ressourcen
**Zugehörige Dokumente:**
+ [AWS Deployment Pipelines Reference Architecture](https://aws.amazon.com/blogs/aws/new_deployment_pipelines_reference_architecture_and_-reference_implementations/) (Referenzarchitektur für AWS-Bereitstellungs-Pipelines)
+ [Monitoring AWS CodePipeline](https://docs.aws.amazon.com/codepipeline/latest/userguide/monitoring.html) (Überwachen von AWS CodePipeline)
+ [Security best practices for AWS CodePipeline](https://docs.aws.amazon.com/codepipeline/latest/userguide/security-best-practices.html) (Bewährte Methoden für die Sicherheit mit AWS CodePipeline)
**Zugehörige Beispiele:**
+ [DevOps monitoring dashboard](https://github.com/aws-solutions/aws-devops-monitoring-dashboard) (DevOps-Überwachungs-Dashboard) (GitHub)
# SEC11-BP08 Ein Programm entwickeln, das den Workload-Teams die Verantwortung für die Sicherheit überträgt
Entwickeln Sie ein Programm oder einen Mechanismus, der es Entwicklerteams ermöglicht, Entscheidungen bezüglich der Sicherheit der von ihnen erstellten Software zu treffen. Zwar muss Ihr Sicherheitsteam diese Entscheidungen immer noch während einer Überprüfung validieren, doch macht das Übertragen der Sicherheitsverantwortlichkeit auf Entwicklerteams eine schnellere und sicherer Workload-Erstellung möglich. Zudem fördert dieser Mechanismus eine Kultur der Verantwortlichkeit, die einen positiven Einfluss auf den Betrieb der von Ihnen entwickelten Systeme hat.
**Gewünschtes Ergebnis:** Um Entwicklungsteams Verantwortung und Entscheidungsfindung zu überlassen, können Sie entweder Entwickler in Bezug darauf schulen, wie sie über Sicherheit nachdenken, oder Sie können ihre Schulung mithilfe von Sicherheitsexperten verbessern, die Teil des Entwicklungsteams sind oder damit in Kontakt stehen. Beide Ansätze sind valide und ermöglichen dem Team, bessere Sicherheitsentscheidungen früher im Entwicklungszyklus zu treffen. Dieses Verantwortungsmodell basiert auf Schulungen in Anwendungssicherheit. Wenn Sie mit einem Bedrohungsmodell für den bestimmten Workload beginnen, hilft Ihnen dies dabei, das Design Thinking auf den entsprechenden Kontext zu konzentrieren. Ein weiterer Vorteil, eine Community an sicherheitsorientierten Entwicklern oder eine Gruppe an Sicherheitstechnikern zu haben, die mit Entwicklungsteams zusammenarbeiten, ist, dass Sie ein besseres Verständnis darüber erlangen, wie Code geschrieben wird. Dieses Verständnis hilft Ihnen dabei, die nächsten verbesserungswürdigen Bereiche bei Ihrem Automatisierungsunterfangen zu bestimmen.
**Typische Anti-Muster:**
+ Einem Sicherheitsteam alle Entscheidungen bezüglich des Sicherheitsdesigns überlassen.
+ Sicherheitsanforderungen nicht früh genug im Entwicklungsprozess adressieren.
+ Kein Feedback bezüglich des Programmbetriebs von Entwicklern und Sicherheitsexperten einholen.
**Vorteile der Nutzung dieser bewährten Methode:**
+ Kürzere Dauer zum Abschließen von Sicherheitsüberprüfungen.
+ Verringerung von Sicherheitsproblemen, die nur auf der Ebene der Sicherheitsüberprüfung erkannt werden.
+ Verbesserung der gesamten Qualität der Software, die geschrieben wird.
+ Die Möglichkeit, systemische Probleme oder Bereiche mit hoher Wertverbesserung zu identifizieren und zu verstehen.
+ Verringerung der erforderlichen Überarbeitung aufgrund von Erkenntnissen in Bezug auf Sicherheit.
+ Verbesserung der Wahrnehmung von Sicherheitsfunktionen.
**Risikostufe, wenn diese bewährte Methode nicht eingeführt wird:** niedrig
## Implementierungsleitfaden
Beginnen Sie mit den Anweisungen unter [SEC11-BP01 Für Anwendungssicherheit schulen](sec_appsec_train_for_application_security.md). Bestimmen Sie danach das Betriebsmodell für das Programm, von dem Sie denken, dass es am besten für Ihr Unternehmen funktioniert. Die zwei Hauptmuster bestehen daraus, Entwickler zu schulen oder Sicherheitsexperten in in Entwicklungsteams zu positionieren. Nachdem Sie sich für eine anfängliche Verfahrensweise entschieden haben, sollten Sie einen Pilotlauf mit einem einzelnen Team oder einer kleinen Gruppe von Workload-Teams durchführen, um zu bestätigen, dass das Modell für Ihr Unternehmen funktioniert. Unterstützung der Führungskräfte aus den Entwicklungs- und Sicherheitsbereichen des Unternehmens hilft Ihnen beim Durchführen und dem Erfolg des Programms. Während Sie dieses Programm entwickeln, ist es wichtig, Metriken auszuwählen, die auf den Wert des Programms hinweisen. Zu erfahren, wie AWS mit diesem Problem umgegangen ist, bietet eine gute Lernerfahrung. Die bewährte Methode konzentriert sich auf die Veränderung und Kultur des Unternehmens. Die von Ihnen eingesetzten Tools sollten die Zusammenarbeit zwischen den Entwicklung- und Sicherheits-Communities unterstützen.
### Implementierungsschritte
+ Beginnen Sie damit, Ihre Entwickler im Bereich der Anwendungssicherheit zu schulen.
+ Schaffen Sie eine Community und ein Onboarding-Programm zum Schulen der Entwickler.
+ Geben Sie dem Programm einen Namen. Guardians, Champions oder Advocates werden häufig verwendet.
+ Bestimmen Sie das Modell, das verwendet werden soll: Schulen Sie Entwickler und bringen Sie Sicherheitstechniker oder andere verwandte Sicherheitsrollen ein.
+ Identifizieren Sie Projektsponsoren aus Sicherheitsexperten, Entwicklern und anderen potenziell relevanten Gruppen.
+ Verfolgen Sie Metriken für die Anzahl der im Programm involvierten Personen, die für Überprüfungen erforderliche Zeit und das Feedback von Entwicklern und Sicherheitsexperten. Nutzen Sie diese Metriken, um Verbesserungen vorzunehmen.
## Ressourcen
**Zugehörige bewährte Methoden:**
+ [SEC11-BP01 Für Anwendungssicherheit schulen](sec_appsec_train_for_application_security.md)
+ [SEC11-BP02 Das Testen während des Entwicklungs- und Veröffentlichungslebenszyklus automatisieren](sec_appsec_automate_testing_throughout_lifecycle.md)
**Zugehörige Dokumente:**
+ [How to approach threat modeling](https://aws.amazon.com/blogs/security/how-to-approach-threat-modeling/) (Konzepte für Bedrohungsmodellierung)
+ [How to think about cloud security governance](https://aws.amazon.com/blogs/security/how-to-think-about-cloud-security-governance/) (Über Cloud-Sicherheits-Governance nachdenken)
**Zugehörige Videos:**
+ [Proactive security: Considerations and approaches](https://www.youtube.com/watch?v=CBrUE6Qwfag) (Proaktive Sicherheit: Überlegungen und Ansätze)