[{"data":1,"prerenderedAt":682},["ShallowReactive",2],{"/de-de/the-source/security/":3,"footer-de-de":37,"the-source-banner-de-de":343,"the-source-navigation-de-de":355,"the-source-newsletter-de-de":382,"the-source-the-source-resources-de-de":393,"security-articles-list-authors-de-de":425,"security-articles-list-de-de":456,"security-page-categories-de-de":681},{"_path":4,"_dir":5,"_draft":6,"_partial":6,"_locale":7,"config":8,"seo":9,"content":14,"type":29,"slug":30,"_id":31,"_type":32,"title":7,"_source":33,"_file":34,"_stem":35,"_extension":36},"/de-de/the-source/security","the-source",false,"",{"layout":5},{"title":10,"description":11,"ogImage":7,"config":12},"Sicherheit und Compliance","Erfahre, wie Unternehmen sicherstellen können, dass sie bei sich entwickelnden Sicherheitsbedrohungen und Compliance-Anforderungen immer auf dem neuesten Stand sind.",{"ignoreDescriptionCharLimit":13},true,[15,21],{"componentName":16,"componentContent":17},"TheSourceCategoryHero",{"title":10,"description":11,"image":18},{"config":19},{"src":20},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1751463273/aplkxrvwpii26xao5yhi.png",{"componentName":22,"componentContent":23},"TheSourceCategoryMainSection",{"config":24},{"gatedAssets":25},[26,27,28],"source-lp-guide-to-dynamic-sboms","source-lp-a-field-guide-to-threat-vectors-in-the-software-supply-chain","application-security-in-the-digital-age","category","security","content:de-de:the-source:security:index.yml","yaml","content","de-de/the-source/security/index.yml","de-de/the-source/security/index","yml",{"_path":38,"_dir":39,"_draft":6,"_partial":6,"_locale":7,"data":40,"_id":339,"_type":32,"title":340,"_source":33,"_file":341,"_stem":342,"_extension":36},"/shared/de-de/main-footer","de-de",{"text":41,"source":42,"edit":48,"contribute":53,"config":58,"items":63,"minimal":331},"Git ist eine Marke von Software Freedom Conservancy und unsere Verwendung von „GitLab“ erfolgt unter Lizenz.",{"text":43,"config":44},"Quelltext der Seite anzeigen",{"href":45,"dataGaName":46,"dataGaLocation":47},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/","page source","footer",{"text":49,"config":50},"Diese Seite bearbeiten",{"href":51,"dataGaName":52,"dataGaLocation":47},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/-/blob/main/content/","web ide",{"text":54,"config":55},"Beteilige dich",{"href":56,"dataGaName":57,"dataGaLocation":47},"https://gitlab.com/gitlab-com/marketing/digital-experience/about-gitlab-com/-/blob/main/CONTRIBUTING.md/","please contribute",{"twitter":59,"facebook":60,"youtube":61,"linkedin":62},"https://x.com/gitlab","https://www.facebook.com/gitlab","https://www.youtube.com/channel/UCnMGQ8QHMAnVIsI3xJrihhg","https://www.linkedin.com/company/gitlab-com",[64,91,163,231,293],{"title":65,"links":66,"subMenu":72},"Plattform",[67],{"text":68,"config":69},"DevSecOps-Plattform",{"href":70,"dataGaName":71,"dataGaLocation":47},"/de-de/platform/","devsecops platform",[73],{"title":74,"links":75},"Preise",[76,81,86],{"text":77,"config":78},"Tarife anzeigen",{"href":79,"dataGaName":80,"dataGaLocation":47},"/de-de/pricing/","view plans",{"text":82,"config":83},"Vorteile von Premium",{"href":84,"dataGaName":85,"dataGaLocation":47},"/de-de/pricing/premium/","why premium",{"text":87,"config":88},"Vorteile von Ultimate",{"href":89,"dataGaName":90,"dataGaLocation":47},"/de-de/pricing/ultimate/","why ultimate",{"title":92,"links":93},"Lösungen",[94,99,103,108,113,118,123,128,133,138,143,148,153,158],{"text":95,"config":96},"Digitale Transformation",{"href":97,"dataGaName":98,"dataGaLocation":47},"/de-de/topics/digital-transformation/","digital transformation",{"text":10,"config":100},{"href":101,"dataGaName":102,"dataGaLocation":47},"/solutions/application-security-testing/","Application security testing",{"text":104,"config":105},"Automatisierte Softwarebereitstellung",{"href":106,"dataGaName":107,"dataGaLocation":47},"/de-de/solutions/delivery-automation/","automated software delivery",{"text":109,"config":110},"Agile Entwicklung",{"href":111,"dataGaName":112,"dataGaLocation":47},"/de-de/solutions/agile-delivery/","agile delivery",{"text":114,"config":115},"Cloud-Transformation",{"href":116,"dataGaName":117,"dataGaLocation":47},"/de-de/topics/cloud-native/","cloud transformation",{"text":119,"config":120},"SCM",{"href":121,"dataGaName":122,"dataGaLocation":47},"/de-de/solutions/source-code-management/","source code management",{"text":124,"config":125},"CI/CD",{"href":126,"dataGaName":127,"dataGaLocation":47},"/de-de/solutions/continuous-integration/","continuous integration & delivery",{"text":129,"config":130},"Wertstrommanagement",{"href":131,"dataGaName":132,"dataGaLocation":47},"/de-de/solutions/value-stream-management/","value stream management",{"text":134,"config":135},"GitOps",{"href":136,"dataGaName":137,"dataGaLocation":47},"/de-de/solutions/gitops/","gitops",{"text":139,"config":140},"Enterprise",{"href":141,"dataGaName":142,"dataGaLocation":47},"/de-de/enterprise/","enterprise",{"text":144,"config":145},"Kleinunternehmen",{"href":146,"dataGaName":147,"dataGaLocation":47},"/de-de/small-business/","small business",{"text":149,"config":150},"Öffentlicher Sektor",{"href":151,"dataGaName":152,"dataGaLocation":47},"/de-de/solutions/public-sector/","public sector",{"text":154,"config":155},"Bildungswesen",{"href":156,"dataGaName":157,"dataGaLocation":47},"/de-de/solutions/education/","education",{"text":159,"config":160},"Finanzdienstleistungen",{"href":161,"dataGaName":162,"dataGaLocation":47},"/de-de/solutions/finance/","financial services",{"title":164,"links":165},"Ressourcen",[166,171,176,181,186,191,196,201,206,211,216,221,226],{"text":167,"config":168},"Installieren",{"href":169,"dataGaName":170,"dataGaLocation":47},"/de-de/install/","install",{"text":172,"config":173},"Kurzanleitungen",{"href":174,"dataGaName":175,"dataGaLocation":47},"/de-de/get-started/","quick setup checklists",{"text":177,"config":178},"Lernen",{"href":179,"dataGaName":180,"dataGaLocation":47},"https://university.gitlab.com/","learn",{"text":182,"config":183},"Produktdokumentation",{"href":184,"dataGaName":185,"dataGaLocation":47},"https://docs.gitlab.com/","docs",{"text":187,"config":188},"Blog",{"href":189,"dataGaName":190,"dataGaLocation":47},"/de-de/blog/","blog",{"text":192,"config":193},"Kundenerfolge",{"href":194,"dataGaName":195,"dataGaLocation":47},"/customers/","customer success stories",{"text":197,"config":198},"Remote",{"href":199,"dataGaName":200,"dataGaLocation":47},"https://handbook.gitlab.com/handbook/company/culture/all-remote/","remote",{"text":202,"config":203},"GitLab-Services",{"href":204,"dataGaName":205,"dataGaLocation":47},"/de-de/services/","services",{"text":207,"config":208},"TeamOps",{"href":209,"dataGaName":210,"dataGaLocation":47},"/de-de/teamops/","teamops",{"text":212,"config":213},"Community",{"href":214,"dataGaName":215,"dataGaLocation":47},"/community/","community",{"text":217,"config":218},"Forum",{"href":219,"dataGaName":220,"dataGaLocation":47},"https://forum.gitlab.com/","forum",{"text":222,"config":223},"Veranstaltungen",{"href":224,"dataGaName":225,"dataGaLocation":47},"/events/","events",{"text":227,"config":228},"Partner",{"href":229,"dataGaName":230,"dataGaLocation":47},"/de-de/partners/","partners",{"title":232,"links":233},"Unternehmen",[234,239,244,249,254,259,264,268,273,278,283,288],{"text":235,"config":236},"Über",{"href":237,"dataGaName":238,"dataGaLocation":47},"/de-de/company/","company",{"text":240,"config":241},"Karriere",{"href":242,"dataGaName":243,"dataGaLocation":47},"/jobs/","jobs",{"text":245,"config":246},"Geschäftsführung",{"href":247,"dataGaName":248,"dataGaLocation":47},"/company/team/e-group/","leadership",{"text":250,"config":251},"Team",{"href":252,"dataGaName":253,"dataGaLocation":47},"/company/team/","team",{"text":255,"config":256},"Handbuch",{"href":257,"dataGaName":258,"dataGaLocation":47},"https://handbook.gitlab.com/","handbook",{"text":260,"config":261},"Investor Relations",{"href":262,"dataGaName":263,"dataGaLocation":47},"https://ir.gitlab.com/","investor relations",{"text":265,"config":266},"Sustainability",{"href":267,"dataGaName":265,"dataGaLocation":47},"/sustainability/",{"text":269,"config":270},"Vielfalt, Inklusion und Zugehörigkeit",{"href":271,"dataGaName":272,"dataGaLocation":47},"/diversity-inclusion-belonging/","Diversity, inclusion and belonging",{"text":274,"config":275},"Trust Center",{"href":276,"dataGaName":277,"dataGaLocation":47},"/de-de/security/","trust center",{"text":279,"config":280},"Newsletter",{"href":281,"dataGaName":282,"dataGaLocation":47},"/company/contact/","newsletter",{"text":284,"config":285},"Presse",{"href":286,"dataGaName":287,"dataGaLocation":47},"/press/","press",{"text":289,"config":290},"Transparenzerklärung zu moderner Sklaverei",{"href":291,"dataGaName":292,"dataGaLocation":47},"https://handbook.gitlab.com/handbook/legal/modern-slavery-act-transparency-statement/","modern slavery transparency statement",{"title":294,"links":295},"Nimm Kontakt auf",[296,301,306,311,316,321,326],{"text":297,"config":298},"Sprich mit einem Experten/einer Expertin",{"href":299,"dataGaName":300,"dataGaLocation":47},"/de-de/sales/","sales",{"text":302,"config":303},"Support",{"href":304,"dataGaName":305,"dataGaLocation":47},"/support/","get help",{"text":307,"config":308},"Kundenportal",{"href":309,"dataGaName":310,"dataGaLocation":47},"https://customers.gitlab.com/customers/sign_in/","customer portal",{"text":312,"config":313},"Status",{"href":314,"dataGaName":315,"dataGaLocation":47},"https://status.gitlab.com/","status",{"text":317,"config":318},"Nutzungsbedingungen",{"href":319,"dataGaName":320,"dataGaLocation":47},"/terms/","terms of use",{"text":322,"config":323},"Datenschutzerklärung",{"href":324,"dataGaName":325,"dataGaLocation":47},"/de-de/privacy/","privacy statement",{"text":327,"config":328},"Cookie-Einstellungen",{"dataGaName":329,"dataGaLocation":47,"id":330,"isOneTrustButton":13},"cookie preferences","ot-sdk-btn",{"items":332},[333,335,337],{"text":317,"config":334},{"href":319,"dataGaName":320,"dataGaLocation":47},{"text":322,"config":336},{"href":324,"dataGaName":325,"dataGaLocation":47},{"text":327,"config":338},{"dataGaName":329,"dataGaLocation":47,"id":330,"isOneTrustButton":13},"content:shared:de-de:main-footer.yml","Main Footer","shared/de-de/main-footer.yml","shared/de-de/main-footer",{"_path":344,"_dir":345,"_draft":6,"_partial":6,"_locale":7,"id":346,"visibility":13,"title":347,"button":348,"_id":352,"_type":32,"_source":33,"_file":353,"_stem":354,"_extension":36},"/shared/de-de/the-source/banner/the-economics-of-software-innovation-2025-08-18","banner","The Economics of Software Innovation","The Economics of Software Innovation—AI’s $750 Billion Opportunity",{"config":349,"text":351},{"href":350},"https://about.gitlab.com/software-innovation-report/","Get the research report","content:shared:de-de:the-source:banner:the-economics-of-software-innovation-2025-08-18.yml","shared/de-de/the-source/banner/the-economics-of-software-innovation-2025-08-18.yml","shared/de-de/the-source/banner/the-economics-of-software-innovation-2025-08-18",{"_path":356,"_dir":5,"_draft":6,"_partial":6,"_locale":7,"logo":357,"subscribeLink":362,"navItems":366,"_id":378,"_type":32,"title":379,"_source":33,"_file":380,"_stem":381,"_extension":36},"/shared/de-de/the-source/navigation",{"altText":358,"config":359},"the source logo",{"src":360,"href":361},"https://res.cloudinary.com/about-gitlab-com/image/upload/v1750191004/t7wz1klfb2kxkezksv9t.svg","/de-de/the-source/",{"text":363,"config":364},"Abonnieren",{"href":365},"#subscribe",[367,371,374],{"text":368,"config":369},"Künstliche Intelligenz",{"href":370},"/de-de/the-source/ai/",{"text":10,"config":372},{"href":373},"/de-de/the-source/security/",{"text":375,"config":376},"Plattform und Infrastruktur",{"href":377},"/de-de/the-source/platform/","content:shared:de-de:the-source:navigation.yml","Navigation","shared/de-de/the-source/navigation.yml","shared/de-de/the-source/navigation",{"_path":383,"_dir":5,"_draft":6,"_partial":6,"_locale":7,"title":384,"description":385,"submitMessage":386,"formData":387,"_id":390,"_type":32,"_source":33,"_file":391,"_stem":392,"_extension":36},"/shared/de-de/the-source/newsletter","The-Source-Newsletter","Bleibe mit Erkenntnissen für die Zukunft der Softwareentwicklung auf dem Laufenden.","Du hast dich erfolgreich für den Newsletter von The Source angemeldet.",{"config":388},{"formId":389,"formName":282,"hideRequiredLabel":13},28465,"content:shared:de-de:the-source:newsletter.yml","shared/de-de/the-source/newsletter.yml","shared/de-de/the-source/newsletter",[394,411],{"_path":395,"_dir":396,"_draft":6,"_partial":6,"_locale":7,"config":397,"title":400,"description":401,"link":402,"_id":408,"_type":32,"_source":33,"_file":409,"_stem":410,"_extension":36},"/shared/de-de/the-source/gated-assets/navigating-ai-maturity-in-devsecops","gated-assets",{"id":398,"formId":399},"navigating-ai-maturity-in-devsecops",1002,"Navigation durch die KI-Entwicklung in DevSecOps","Lies dir die [Ergebnisse unserer Umfrage unter mehr als 5.000 DevSecOps-Fachleuten weltweit](https://about.gitlab.com/de-de/developer-survey/2024/ai/) durch und erhalte Einblicke darin, wie Unternehmen KI in den Software-Entwicklungsprozess integrieren.",{"text":403,"config":404},"Bericht lesen",{"href":405,"dataGaName":406,"dataGaLocation":407},"https://about.gitlab.com/developer-survey/2024/ai/","Navigating AI Maturity in DevSecOps","thesource","content:shared:de-de:the-source:gated-assets:navigating-ai-maturity-in-devsecops.yml","shared/de-de/the-source/gated-assets/navigating-ai-maturity-in-devsecops.yml","shared/de-de/the-source/gated-assets/navigating-ai-maturity-in-devsecops",{"_path":412,"_dir":396,"_draft":6,"_partial":6,"_locale":7,"config":413,"title":415,"description":416,"link":417,"_id":422,"_type":32,"_source":33,"_file":423,"_stem":424,"_extension":36},"/shared/de-de/the-source/gated-assets/source-lp-how-to-get-started-using-ai-in-software-development",{"id":414,"formId":399},"source-lp-how-to-get-started-using-ai-in-software-development","How to Get Started Using AI in Software Development (nur in englischer Sprache)","Lies dir unser E-Book mit konkreten Erkenntnissen durch, die dir dabei helfen, ein strategisches KI-Framework für die schnellere Entwicklung sicherer Software zu erstellen (nur in englischer Sprache).",{"text":418,"config":419},"E-Book lesen",{"href":420,"dataGaName":421,"dataGaLocation":407},"https://about.gitlab.com/the-source/ai/getting-started-with-ai-in-software-development-a-guide-for-leaders/","How to Get Started Using AI in Software Development","content:shared:de-de:the-source:gated-assets:source-lp-how-to-get-started-using-ai-in-software-development.yml","shared/de-de/the-source/gated-assets/source-lp-how-to-get-started-using-ai-in-software-development.yml","shared/de-de/the-source/gated-assets/source-lp-how-to-get-started-using-ai-in-software-development",{"amanda-rueda":426,"andre-michael-braun":427,"andrew-haschka":428,"ayoub-fandi":429,"brian-wald":430,"bryan-ross":431,"chandler-gibbons":432,"dave-steer":433,"ddesanto":434,"derek-debellis":435,"emilio-salvador":436,"erika-feldman":437,"george-kichukov":438,"gitlab":439,"grant-hickman":440,"haim-snir":441,"iganbaruch":442,"jlongo":443,"joel-krooswyk":444,"josh-lemos":445,"julie-griffin":446,"kristina-weis":447,"lee-faus":448,"ncregan":449,"rschulman":450,"sabrina-farmer":451,"sandra-gittlen":452,"sharon-gaudin":453,"stephen-walters":454,"taylor-mccaslin":455},"Amanda Rueda","Andre Michael Braun","Andrew Haschka","Ayoub Fandi","Brian Wald","Bryan Ross","Chandler Gibbons","Dave Steer","David DeSanto","Derek DeBellis","Emilio Salvador","Erika Feldman","George Kichukov","GitLab","Grant Hickman","Haim Snir","Itzik Gan Baruch","Joseph Longo","Joel Krooswyk","Josh Lemos","Julie Griffin","Kristina Weis","Lee Faus","Niall Cregan","Robin Schulman","Sabrina Farmer","Sandra Gittlen","Sharon Gaudin","Stephen Walters","Taylor McCaslin",{"allArticles":457,"visibleArticles":680,"showAllBtn":6},[458,483,521,541,561,581,602,637,659],{"_path":459,"_dir":30,"_draft":6,"_partial":6,"_locale":7,"config":460,"seo":465,"content":469,"type":478,"category":30,"slug":479,"_id":480,"_type":32,"title":466,"_source":33,"_file":481,"_stem":482,"_extension":36,"date":470,"description":471,"timeToRead":472,"heroImage":468,"keyTakeaways":473,"articleBody":477},"/de-de/the-source/security/key-security-trends-for-cisos-in-2025",{"layout":5,"template":461,"articleType":462,"author":463,"featured":6,"gatedAsset":464,"isHighlighted":6,"authorName":445},"TheSourceArticle","Regular","josh-lemos","source-lp-ai-guide-for-enterprise-leaders-building-the-right-approach",{"title":466,"description":467,"ogImage":468},"Wichtige Sicherheitstrends für CISOs im Jahr 2025","Entdecke die Sicherheitstrends 2025 und erfahre, wie KI neue Risiken, aber auch Chancen schafft, das Identitätsmanagement umgestaltet und DevOps-Teams stärkt.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1751464506/hyue0lgqq2lqk3arwnel.jpg",{"title":466,"date":470,"description":471,"timeToRead":472,"heroImage":468,"keyTakeaways":473,"articleBody":477},"2025-02-25","Entdecke die wichtigsten Sicherheitstrends im Jahr 2025 und erfahre, wie KI neue Risiken, aber auch Chancen schafft, das Identitätsmanagement umgestaltet und DevOps-Teams stärkt.","Lesezeit: 5 Min.",[474,475,476],"Die Einführung von KI birgt sowohl Sicherheitsrisiken als auch Chancen. Unternehmen müssen die KI-Nutzung in Produkten ihrer Anbieter nachverfolgen, sich auf potenzielle Ausfälle vorbereiten und die KI nutzen, um Sicherheitskontrollen zu stärken.","Das Identitätsmanagement muss modernisiert werden, um komplexen Interaktionen zwischen Maschinen, dynamischen Berechtigungen und Zugriffsberechtigungen für KI-Systeme gerecht zu werden. Dazu sind flexiblere und adaptive Sicherheitstools erforderlich.","KI-Tools können dazu beitragen, Lücken bei den Sicherheitskompetenzen im DevOps-Bereich zu überbrücken, indem sie sichere Coding Patterns vorschlagen und Sicherheit in den gesamten Software-Entwicklungsprozess integrieren.","2025 werden viele wichtige Sicherheitstools KI-Modelle enthalten, die du nicht untersuchen oder nicht vollständig kontrollieren kannst. Dein Vorstand fragt vielleicht bereits, wie du den nächsten Sicherheitsverstoß, der groß auf den Titelseiten prangen wird, verhindern wirst. In der Zwischenzeit nutzen deine Konkurrenten KI, um Sicherheit in einem Ausmaß zu automatisieren, das noch vor wenigen Monaten unmöglich schien. Dazu kommen aufkommende regulatorische Anforderungen, die das Ganze zusätzlich komplex machen, wie etwa in der Europäischen Union und in Kalifornien, wo neue Vorschriften die Nutzung von KI-Systemen beeinflussen.\n\nDie Sicherheitslandschaft entwickelt sich rasend schnell weiter, doch mit dem richtigen Ansatz kannst du diese Herausforderungen zu deinem Vorteil machen, um eine stärkere Abwehr zu erschaffen und dich vor neuen Cyberbedrohungen zu schützen. Hier findest du drei Trends, die die Sicherheitslandschaft für Unternehmen in diesem Jahr beschäftigen werden und auf die du dich vorbereiten solltest.\n\n## 1. Sicherheitslücken in proprietären LLMs\nViele Anbieter nutzen derzeit proprietäre große Sprachmodelle (LLMs) als Grundlage für ihre Produkte, durch die neue Risiken für dein Unternehmen entstehen. Die meisten dieser LLMs sind undurchsichtig, sodass du nicht sehen kannst, wie sie funktionieren oder welche Sicherheitskontrollen sie verwenden. Sicherheitsexpert(inn)en haben bereits bewiesen, wie fragil KI-Leitlinien sind. Die Modelle selbst bieten eine immer größere Angriffsfläche – und damit auch die Produkte, die auf diesen Modellen basieren.\n\nDa viele Produkte auf einigen wenigen proprietären LLMs basieren, könnte sich ein Angriff auf eines dieser Modelle gleichzeitig auf viele deiner Systeme auswirken. Diese Risikokonzentration ist besonders besorgniserregend, da immer mehr wichtige geschäftliche Funktionen auf KI-basierten Tools aufbauen. Du musst daher:\n\n- Nachverfolgen, welche deiner Anbieter LLMs verwenden\n- Die Sicherheitskontrollen dieser Anbieter beurteilen\n- Mögliche Ausfälle einplanen, wenn ein LLM-basierter Dienst ausfällt\n- Backup-Pläne für wichtige, von KI abhängige Systeme entwickeln\n\n> Weiterlesen: [7 Transparenzfragen an deinen DevOps-KI-Anbieter](https://about.gitlab.com/the-source/ai/building-a-transparency-first-ai-strategy-7-questions-to-ask-your-devops/)\n\n## 2. Herausforderungen beim Identitätsmanagement\nCloud- und KI-Systeme verändern die Art und Weise, wie wir den Zugang zu unseren täglich genutzten Systemen verwalten. Deine Identitätssysteme müssen nun Folgendes bewältigen:\n\n- Einen Anstieg an nicht menschlichen, dienstbasierten Identitäten\n- Mehr Verbindungen zwischen Maschinen\n- Schnellere Änderungen dessen, wer auf was zugreifen darf\n- Komplexe Berechtigungsketten zwischen Diensten\n- KI-Systeme, die verschiedene Ebenen des Datenzugriffs benötigen\n\nTraditionelle Tools für Identitäts- und Zugriffsmanagement wurden nicht für diese Herausforderungen entwickelt. Du brauchst flexiblere Identitätstools, die sich schnell an deine sich ändernden Bedürfnisse anpassen können. Erwäge [Zero-Trust-Prinzipien sowie Just-in-Time-Zugriff (nur in englischer Sprache verfügbar)](https://about.gitlab.com/the-source/security/field-guide-to-threat-vectors-in-the-software-supply-chain/), um in diesen dynamischen Umgebungen mehr Kontrolle zu haben.\n\nSicherheitsteams sollten auch Strategien entwickeln und sich auf die wachsende Komplexität einer agentischen KI vorbereiten, wobei dieselbe Strenge und Überwachbarkeit wie bei menschlichen Benutzer(inne)n gelten sollten. Da sich KI-Systeme immer weiter verbreiten, wird es ebenso wichtig, diese [nicht menschlichen Identitäten nachzuverfolgen und zu sichern (nur in englischer Sprache verfügbar)](https://about.gitlab.com/blog/improve-ai-security-in-gitlab-with-composite-identities/), wie es beim Zugriff menschlicher Benutzer(innen) ist.## 3. Sicherheit in DevOps\nIn einer [kürzlich durchgeführten Umfrage](https://about.gitlab.com/developer-survey/) gaben 58 % der Entwickler(innen) an, dass sie ein gewisses Maß an Verantwortung für die Anwendungssicherheit empfinden. Dennoch bleibt es schwierig, DevOps-Mitarbeitende mit Fähigkeiten im Sicherheitsbereich zu finden. KI-basierte Tools können dabei helfen, indem sie:\n\n- Code früh im Entwicklungsprozess auf Sicherheitslücken und potenzielle Bedrohungen überprüfen, bevor diese Probleme verursachen können\n- Sichere Coding Patterns vorschlagen\n- Automatisch die richtigen Zugriffsberechtigungen festlegen\n- Sich wiederholende Aufgaben im gesamten Entwicklungsprozess automatisieren.\n\nDiese Tools können dein bestehendes Sicherheitsteam darin unterstützen, effizienter zu arbeiten. Sie können Entwickler(inne)n auch dabei helfen, häufige Sicherheitsprobleme zu erkennen, bevor der Code in die Produktion geht. Dies bedeutet weniger Notfälle für dein Team und insgesamt bessere Sicherheitsergebnisse.\n\nErwäge, in Tools zu investieren, die sich direkt in die Workflows der Entwickler(innen) integrieren lassen. Je einfacher du es den Entwickler(inne)n machst, sicher zu arbeiten, desto wahrscheinlicher werden sie es auch wirklich tun.\n\n## Jetzt bist du dran: Nutze die KI, um dich vor Bedrohungen zu schützen\nGehe folgendermaßen vor, um diesen Veränderungen einen Schritt voraus zu sein:\n\n1. Sieh dir an, wo KI-Tools mit deinen Systemen in Kontakt kommen, und bewerte die Risiken.\n1. Aktualisiere deinen Ansatz für das Identitätsmanagement für Cloud- und KI-Anforderungen.\n1. Suche nach Möglichkeiten, wie die KI deine Sicherheit verbessern kann.\n1. Informiere deinen Vorstand über neue KI-Risiken und -Vorschriften.\n1. Baue Beziehungen zu wichtigen Anbietern auf, um ihre KI-Sicherheitsmaßnahmen zu verstehen.\n1. Schule dein Team zu KI-Sicherheitsrisiken und -Chancen.\n\nWährend die KI zwar neue Risiken mit sich bringt, bietet sie auch neue Tools zum Schutz deines Unternehmens. Fokussiere dich darauf, mithilfe der KI deine Sicherheitslage zu verbessern, während du gleichzeitig Ausschau nach neuen Bedrohungen hältst. Indem du deine KI-Sicherheitslage regelmäßig überprüfst, bist du aufkommenden Risiken immer einen Schritt voraus.\n\n## Ausblick\nDie Sicherheitslandschaft wird sich mit dem Fortschritt der KI-Technologie weiterentwickeln. Bleibe flexibel und passe deine Sicherheitsstrategie an, wenn neue Bedrohungen und Chancen auftauchen. Intensiviere die Zusammenarbeit in deinem Unternehmen, insbesondere mit den Rechts-, Entwicklungs- und IT-Betriebsteams. Diese Kooperation hilft dir, effektiver auf Sicherheitsherausforderungen zu reagieren.\n\nDenke daran, dass sich zwar die Technologie ändert, deine wichtigste Mission jedoch gleich bleibt: der Schutz deiner Unternehmens-Assets sowie ein sicherer Geschäftsbetrieb. Nutze neue Tools und Ansätze, wenn sie sinnvoll sind, verliere jedoch bei all dem Trubel rund um die KI-Einführung nicht die Grundsätze der Sicherheit aus den Augen.","article","key-security-trends-for-cisos-in-2025","content:de-de:the-source:security:key-security-trends-for-cisos-in-2025:index.yml","de-de/the-source/security/key-security-trends-for-cisos-in-2025/index.yml","de-de/the-source/security/key-security-trends-for-cisos-in-2025/index",{"_path":484,"_dir":30,"_draft":6,"_partial":6,"_locale":7,"slug":485,"type":478,"category":30,"config":486,"seo":489,"content":493,"_id":518,"_type":32,"title":494,"_source":33,"_file":519,"_stem":520,"_extension":36,"description":491,"date":495,"timeToRead":496,"heroImage":492,"keyTakeaways":497,"articleBody":501,"faq":502},"/de-de/the-source/security/why-legacy-code-is-a-security-risk-and-how-ai-can-help","why-legacy-code-is-a-security-risk-and-how-ai-can-help",{"layout":5,"template":461,"featured":6,"articleType":462,"author":487,"gatedAsset":488,"isHighlighted":6,"authorName":444},"joel-krooswyk","source-lp-how-a-devsecops-platform-drives-business-success-the-complete-guide",{"title":490,"ogTitle":490,"description":491,"ogDescription":491,"ogImage":492},"Legacy-Code als Sicherheitsrisiko: So hilft KI","Erfahre, wie KI-gestütztes Code-Refactoring Altsysteme modernisieren, deine Sicherheitsprotokolle verbessern und dein Unternehmen in die Zukunft führen kann.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1751463670/cdynzww9p2annh3mmbhl.png",{"title":494,"description":491,"date":495,"timeToRead":496,"heroImage":492,"keyTakeaways":497,"articleBody":501,"faq":502},"Warum Legacy-Code ein Sicherheitsrisiko darstellt – und wie KI helfen kann","2025-01-15","Lesezeit: 6 Min.",[498,499,500],"Legacy-Code ist teuer und zeitaufwändig in der Wartung und kann, wenn er nicht mit den neuesten Sicherheitstools kompatibel ist, zu einer ernsthaften Belastung für Unternehmen aller Branchen werden.","Code-Refactoring ist eine Strategie, die dazu beitragen kann, den Code lesbarer zu machen und so die Stabilität der Codebase sowie die Produktivität und Effizienz der Entwickler(innen) zu verbessern.","Zusammen mit präventiven Sicherheitstools kann KI-gestütztes Code-Refactoring Teams dabei helfen, ihren Legacy-Code zu modernisieren und gleichzeitig das Risiko von Sicherheitslücken zu verringern.","Die rasante Beschleunigung der heutigen Technologie ist aufregend. Neue Produkte und Möglichkeiten für Wachstum und Innovation gibt es quasi überall. Doch diese Geschwindigkeit des Wachstums und der Veränderung hat auch ihre Schattenseiten, vor allem in Bezug auf die Sicherheit: Schon eine einzige böswillige Handlung kann zu massiven Geschäftsunterbrechungen, Rufschädigung und Umsatzeinbußen führen.\n\nWahrscheinlich hast du schon gehört, wie Branchenführer über die Notwendigkeit der digitalen Transformation und die besorgniserregende Abhängigkeit von veralteten oder „Legacy“-Systemen gesprochen haben. Auch wenn Legacy-Code an sich nicht problematisch ist, ist er oft nicht mit modernen Sicherheitstools kompatibel, was zu Sicherheitslücken führt, die ausgenutzt werden können. In Verbindung mit Open-Source-Code, der ständige Sicherheitsvorkehrungen erfordert, kann deine Codebase die Daten, die Benutzer(innen) und den Ruf deines Unternehmens in Gefahr bringen.\n\nLegacy-Code ist aus Sicht der Sicherheit und der Compliance riskant und für die Entwickler(innen) teuer und zeitaufwändig zu pflegen – falls die Entwickler(innen) in deinem Team überhaupt über das nötige Wissen verfügen, um diese Arbeit zu erledigen.\n\nLetztlich ist diese branchenweite Abhängigkeit von Legacy-Code eine bedenkliche und kostspielige Praxis. Wie können wir uns also davon befreien?\n\nIm Folgenden gehe ich auf Legacy-Code ein und zeige, wie Unternehmen die Sicherheit ihrer Codebase durch KI-basiertes Code-Refactoring erhöhen können. Zusammen mit KI-gestützten Test- und Sicherheitsfunktionen wird das Code-Refactoring deine Codebase in die Zukunft befördern und dein ganzes Team in die Lage versetzen, nach vorne und nicht zurück zu schauen.\n\n## Was ist Legacy-Code?\n\nIm Großen und Ganzen bezeichnet Legacy-Code eine bestehende Codebase, die ein Team von früheren Teammitgliedern geerbt hat und weiterhin nutzt und pflegt. Der Code mag gut funktionieren, aber wahrscheinlich haben im Laufe der Jahre mehrere verschiedene Entwickler(innen) daran gearbeitet. Dem aktuellen Team fällt es vielleicht schwer, zu erkennen, welche Änderungen sinnvoll sind und welche nicht. Außerdem könnte der Code mit einem veralteten Framework oder in einer Programmiersprache geschrieben worden sein, die niemand im Team kennt (egal, ob sie einfach nur alt oder völlig überholt ist).\n\nEs mag seltsam erscheinen, dass Unternehmen immer noch auf Legacy-Code zurückgreifen. Dafür gibt es verschiedene Gründe, aber betrachte es einmal so: Du wohnst in einem alten Haus. Es ist gemütlich und vertraut, aber die Rohrleitungen sind unzuverlässig, die Verkabelung ist veraltet und jedes Mal, wenn du eine Sache reparierst, geht etwas anderes kaputt. Klar, du könntest umbauen, aber das bedeutet einen riesigen Aufwand – Handwerker(innen), Genehmigungen, monatelanges Chaos und Kosten, die außer Kontrolle geraten können.\n\nAlso flickst du alles und hoffst auf das Beste. Das ist nicht ideal, aber es funktioniert – vorerst. So ähnlich ist es auch mit Legacy-Code. Es ist die vertraute, „funktionierende“ Lösung, auch wenn sie klapprig und ineffizient ist. Den Code von Grund auf neu zu schreiben, ist eine gewaltige Herausforderung mit eigenen Risiken und Kosten. Und wer hat schon Zeit für eine umfassende Überarbeitung, wenn neue Funktionen zu entwickeln und dringende Bugs zu beheben sind?\n\nWenn es darum geht, Code zu aktualisieren, entscheiden sich viele Unternehmen dafür, ihren Legacy-Code beizubehalten, weil die Instandhaltung auf kurze Sicht weniger Unterbrechungen mit sich bringen kann. Die Aktualisierung des Codes ist mit viel Entwicklungs- und Testarbeit verbunden. Außerdem muss das Team geschult werden, um sicherzustellen, dass es mit der veralteten Programmiersprache oder dem veralteten Framework arbeiten kann. Wenn es keine Dokumentation gibt, kann es sogar noch schwieriger sein, sich zurechtzufinden.\n\n## Was ist das Problem mit Legacy-Code?\n\nWenn sich dein Unternehmen dazu entschließt, den alten Code beizubehalten – und das tun viele –, riskierst du damit eine ganze Reihe von Problemen. Da dieser Code nicht für neuere Technologien entwickelt wurde, kannst du ihn möglicherweise nicht mit der neuesten und besten Software (z. B. KI-Tools) integrieren, was sich auch auf die Leistung und Skalierbarkeit deiner Produkte auswirken kann. Das kann dich zurückwerfen und die Kundenerfahrung beeinträchtigen.\n\nDas Schlimmste an Legacy-Code, egal ob er vor fünf oder vor 50 Jahren geschrieben wurde, ist, dass es möglicherweise keine Sicherheitsscanner gibt, die diesen Code überprüfen können. Das bedeutet, dass du Probleme bei der Aktualisierung nicht selbst erkennen kannst. Außerdem verstehen die Entwickler(innen), die diese Aktualisierungen vornehmen, die Programmiersprache oder ihre Struktur möglicherweise nicht ausreichend und könnten dabei sogar versehentlich Sicherheitslücken erzeugen. Und schließlich sind ältere Anwendungen häufig in C oder C++ geschrieben, also in speicherunsicheren Sprachen, in denen sich nachweislich [70 % der identifizierten Sicherheitslücken](https://www.cisa.gov/news-events/news/urgent-need-memory-safety-software-products) befinden.\n\nDiese drei Punkte – die Tatsache, dass es möglicherweise keine Möglichkeit gibt, Legacy-Code zu schützen, dass es weniger Methoden gibt, ihn sicher zu aktualisieren, und dass das Endergebnis viel wahrscheinlicher angreifbar ist – sollten Warnsignale für Unternehmen aller Branchen sein.\n\nDie US-[Behörde für Cybersicherheit und Infrastruktursicherheit (U.S. Cybersecurity and Infrastructure Security Agency)](https://www.cisa.gov/stopransomware/bad-practices) hat einen Katalog von schlechten Praktiken erstellt, die wichtige Infrastrukturen in Gefahr bringen können:\n\n„Die Verwendung von nicht unterstützter (oder veralteter) Software im Dienst von kritischen Infrastrukturen und staatlichen kritischen Funktionen ist gefährlich und erhöht das Risiko für die nationale Sicherheit, die nationale wirtschaftliche Sicherheit und die landesweite öffentliche Gesundheit und Sicherheit erheblich. Diese gefährliche Praxis ist besonders gravierend bei Technologien, die über das Internet zugänglich sind.“\n\nAuch wenn du nicht im Bereich der nationalen Sicherheit oder im Bereich der nationalen öffentlichen Gesundheit und Sicherheit arbeitest, gilt diese Warnung dennoch: Die Verwendung von altem Code ist keine bewährte Methode. Es ist eine schlechte.\n\n## Die Lösung: Code-Refactoring\n\nDer Softwareentwickler und Autor [Martin Fowler](https://www.martinfowler.com/) sagt: „Refactoring ist eine kontrollierte Technik zur Verbesserung des Designs einer bestehenden Codebase, eine systematische Technik zur Umstrukturierung von bestehendem Code, bei der die interne Struktur verändert wird, ohne das externe Verhalten zu ändern.“\n\nMit anderen Worten: Mit Code-Refactoring kannst du deinen Legacy-Code schützen und modernisieren, ohne seine ursprüngliche Funktionalität zu beeinträchtigen.\n\nEs gibt viele Refactoring-Techniken – vom Inline-Refactoring, bei dem der Code durch das Entfernen veralteter Elemente vereinfacht wird, bis zum Refactoring durch Abstraktion, bei dem doppelter Code gelöscht wird. Es ist wichtig zu wissen, dass Code-Refactoring Zeit und umfangreiche Kenntnisse in der Entwicklung erfordert, damit es gut funktioniert. Außerdem sind viele Tests erforderlich, während die Entwickler(innen) bereits mit anderen Aufgaben beschäftigt sind.\n\nCode-Refactoring ist zwar die Lösung, um deinen Legacy-Code zukunftsfähig, lesbar, effizient und sicher zu machen, aber es ist ein Projekt für sich, vor allem im großen Maßstab.\n\n## Wie KI helfen kann\n\nWir wissen, dass KI den Lebenszyklus der Softwareentwicklung bereits beschleunigt – und es gibt eine Menge, was [KI tun kann, um auch den Refactoring-Prozess zu beschleunigen](https://about.gitlab.com/blog/2024/08/26/refactor-code-into-modern-languages-with-ai-powered-gitlab-duo/). Tools wie [GitLab Duo](https://about.gitlab.com/blog/2024/04/18/gitlab-duo-chat-now-generally-available/) können zum Beispiel dabei helfen, bestehenden Code zu erklären und neuen Code zu erstellen – zwei der größten Hürden bei der Modernisierung von Legacy-Code. Wenn Entwickler(innen) mit einer Programmiersprache nicht vertraut sind, kann KI helfen, die Lücken zu füllen. In Bezug auf Tests und Sicherheit kann KI auch [Ursachen analysieren, Tests generieren](https://about.gitlab.com/blog/2024/06/06/developing-gitlab-duo-blending-ai-and-root-cause-analysis-to-fix-ci-cd/) und [Entwickler(innen) helfen, Sicherheitslücken zu beheben](https://about.gitlab.com/the-source/ai/understand-and-resolve-vulnerabilities-with-ai-powered-gitlab-duo/). Mit KI im Toolkit wird Code-Refactoring endlich zugänglicher und für Unternehmen realisierbar, sodass sie dieses Projekt endgültig aus ihrem Backlog streichen können.\n\nLaut [unserer Studie](https://about.gitlab.com/developer-survey/2024/ai/) nutzen 34 % aller Befragten, die KI im gesamten Lebenszyklus der Softwareentwicklung einsetzen, KI bereits zur Modernisierung von Legacy-Code. In der Finanzdienstleistungsbranche ist dieser Anteil sogar noch höher (46 %).\n\nNatürlich gibt es ein paar Dinge zu beachten, wenn du mit der Implementierung von KI in deiner Praxis beginnst.\n\nKI ist nicht perfekt. Sie muss immer noch getestet, mit Leitlinien versehen und von Menschen beaufsichtigt werden. KI kann zwar einige dieser wichtigen, zeitaufwändigen manuellen Aufgaben erleichtern und beschleunigen, aber sie kann diese Arbeit nicht allein erledigen. Vor allem im Hinblick auf die Sicherheit solltest du andere Tools einsetzen, um deinen Code so sicher wie möglich zu machen. Du solltest eine [dynamische Software-Stückliste](https://about.gitlab.com/blog/2022/10/25/the-ultimate-guide-to-sboms/) (auch SBOM genannt) erstellen, damit du einen vollständigen Überblick über die Lizenz- und Sicherheitsrisiken deiner Software hast, einschließlich des eventuell vorhandenen Legacy-Codes.\n\n## Mach deine Codebase zukunftssicher\n\nDer Sprung von der Wartung der Legacy-Codebase zur Modernisierung mag sich zwar beängstigend anfühlen, ist aber der beste Weg, wenn du die Sicherheit deines Unternehmens und deiner Benutzerdaten gewährleisten willst. Mit den richtigen Tools und Methoden kann er für deine Teams effizienter und für dein Unternehmen kostengünstiger sein.\n\nDie gute Nachricht ist, dass deine Teams keine Zeit und Ressourcen darauf verwenden müssen, alte Programmiersprachen zu entschlüsseln und mit alten Frameworks zu arbeiten – was zu Frustration, Verzögerungen und Engpässen führt. Indem du der KI die harte Arbeit des Code-Refactorings überlässt, damit er sicher ist und so funktioniert, wie er sollte, können sich die Entwickler(innen) auf das konzentrieren, was sie am besten können: neue Produkte und Funktionen entwickeln und den Wert für die Kund(inn)en steigern.",[503,506,509,512,515],{"header":504,"content":505},"Warum gilt Legacy-Code als Sicherheitsrisiko?","Legacy-Code ist riskant, da er oft veraltete Frameworks oder Programmiersprachen verwendet, denen moderne Sicherheitsmaßnahmen fehlen. Dadurch ist sie nicht mit den neuesten Sicherheitstools kompatibel, was das Risiko von Sicherheitslücken erhöht. Außerdem kann nicht unterstützte oder veraltete Software leicht von Angreifer(inne)n ausgenutzt werden und die Datenintegrität und -sicherheit gefährden.",{"header":507,"content":508},"Wie kann KI-basiertes Code-Refactoring die Sicherheit von Legacy-Code verbessern?","KI-basiertes Code-Refactoring modernisiert Legacy-Systeme wie folgt:\n - Identifikation von veralteten oder unsicheren Programmiermustern und Vorschlagen von sicheren Alternativen\n - Automatisierte Codeverbesserungen ohne Änderung des externen Verhaltens, wodurch die Lesbarkeit und Wartbarkeit verbessert wird\n - Generierung von Sicherheitstests und Analyse der Grundursachen von Sicherheitslücken, was eine schnellere Behebung ermöglicht\nDieser Ansatz reduziert den manuellen Aufwand und beschleunigt den Übergang zu sichereren, effizienteren und besser skalierbaren Codebases.",{"header":510,"content":511},"Was sind die Herausforderungen bei der Pflege von Legacy-Code ohne KI?","Zu den Herausforderungen gehören:\n - __Fehlende moderne Sicherheitsunterstützung__: Traditionelle Sicherheitsscanner sind möglicherweise nicht mit Legacy-Code kompatibel\n - __Komplexe und veraltete Frameworks__: Entwickler(innen) verfügen möglicherweise nicht über das nötige Fachwissen, um den alten Code zu warten oder zu aktualisieren\n - __Hohe Wartungskosten__: Die Wartung von Altsystemen ist kostspielig und zeitaufwändig und bindet Ressourcen, die für Innovationen fehlen\n - __Sicherheitsrisiken__: Veralteter Code ist anfälliger für Sicherheitslücken und Angriffe, was das Risiko von Datenschutzverletzungen erhöht",{"header":513,"content":514},"Wie unterstützt GitLab KI-basiertes Refactoring und die Modernisierung von Legacy-Code?","GitLab verwendet GitLab Duo, um Entwickler(innen) dabei zu helfen, Legacy-Code zu verstehen, indem es Erklärungen liefert und neuen Code generiert. Außerdem bietet es:\n - KI-gestützte Sicherheitsscans zur Erkennung von Sicherheitslücken in Legacy-Code\n - Automatisierte Tests und Abhilfe zur Verbesserung der Codesicherheit\n - Dynamische Software-Stücklisten (SBOMs) für den Einblick in Lizenz- und Sicherheitsrisiken, einschließlich Legacy-Komponenten",{"header":516,"content":517},"Welche Vorteile bietet die Verwendung von KI für das Refactoring von Legacy-Code?","Zu den Vorteilen gehören:\n - __Verbesserte Sicherheit__: KI identifiziert und mildert Sicherheitslücken und verbessert die Sicherheitslage\n - __Erhöhte Produktivität__: Durch die Automatisierung sich wiederholender Aufgaben können sich Entwickler(innen) auf Innovationen konzentrieren\n - __Kosteneffizienz__: Reduzierte Wartungskosten durch die Modernisierung des Codes, um mit aktuellen Frameworks und Tools zu arbeiten\n - __Skalierbare Modernisierung__: KI ermöglicht skalierbares und konsistentes Refactoring über komplexe Codebases hinweg, um die Software-Assets des Unternehmens zukunftssicher zu machen","content:de-de:the-source:security:why-legacy-code-is-a-security-risk-and-how-ai-can-help:index.yml","de-de/the-source/security/why-legacy-code-is-a-security-risk-and-how-ai-can-help/index.yml","de-de/the-source/security/why-legacy-code-is-a-security-risk-and-how-ai-can-help/index",{"_path":522,"_dir":30,"_draft":6,"_partial":6,"_locale":7,"config":523,"seo":524,"content":528,"type":478,"category":30,"slug":537,"_id":538,"_type":32,"title":529,"_source":33,"_file":539,"_stem":540,"_extension":36,"date":530,"description":526,"timeToRead":531,"heroImage":527,"keyTakeaways":532,"articleBody":536},"/de-de/the-source/security/security-its-more-than-culture-addressing-the-root-cause-of-common-security",{"layout":5,"template":461,"articleType":462,"author":463,"featured":13,"gatedAsset":28,"isHighlighted":6,"authorName":445},{"title":525,"description":526,"ogImage":527},"Grundursachen für Frustration im Sicherheitsbereich","Was steht hinter den häufigsten Frustrationen im Sicherheitsbereich? Das sehen wir uns in diesem Artikel genauer an.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1751464489/mragusmxl1wz8ozdaoml.png",{"title":529,"date":530,"description":526,"timeToRead":531,"heroImage":527,"keyTakeaways":532,"articleBody":536},"Frustrationen im Sicherheitsbereich – die häufigsten Ursachen","2024-10-29","Lesedauer: 5 Min.",[533,534,535],"Der Umstieg auf authentifiziertes Scannen im Schwachstellenmanagement verbessert zwar die Wirksamkeit, aber dadurch arbeiten Engineers ggf. an nicht kritischen Aufgaben, wodurch ein Konflikt zwischen den Sicherheits- und Engineering-Teams entstehen kann.","Ein minimalistischer Ansatz bei der Softwareentwicklung kann Abhängigkeiten auf ein Minimum reduzieren, das Scanner-Rauschen reduzieren und die Belastung der Entwickler(innen) verringern, um so zu verbesserter Software-Sicherheit beizutragen.","Mit einem Ansatz, der auf sogenannte „Paved Roads“, also bereits getestete und abgesicherte Entwurfsmuster mit wiederholbaren Anwendungsfällen basiert, kann die Last der Engineering-Teams verringert und die Sicherheit verbessert werden.","In der [jährlichen Umfrage von GitLab unter DevSecOps-Expert(inn)en](https://about.gitlab.com/de-de/developer-survey/) wurden zahlreiche Themen aufgedeckt, die sich auf eine Organisationskultur beziehen, die eine tiefere Abstimmung zwischen Engineering- und Sicherheitsteams verhindern könnte. Die Mehrheit (58 %) der Befragten im Sicherheitsbereich gab an, dass es für sie schwierig ist, Entwickler dazu zu bringen, das Beheben von Sicherheitslücken zu priorisieren. 52 % sagten, dass übermäßige Bürokratisierung die rasche Behebung von Sicherheitslücken behindere. Außerdem nannten die Befragten im Sicherheitsbereich einige spezifische Frustrationspunkte in ihrer Arbeit, darunter die Schwierigkeit, Sicherheitsergebnisse zu verstehen, zu viele falsch positive Ergebnisse und Tests, die erst spät im Softwareentwicklungsprozess stattfinden.\n\n[DevSecOps](/topics/devsecops/) verspricht eine bessere Integration zwischen Engineering und Sicherheit, aber es ist klar, dass Frustrationen und Fehlausrichtungen bestehen bleiben. Diese Herausforderungen sind nämlich Symptome eines größeren Problems, wie Unternehmen Sicherheit sehen und wie Teams zusammenarbeiten und ihre Zeit für Sicherheit aufwenden.\n\n## Entkomme dem Sicherheitslücken-Hamsterrad\n\nDas Scannen von Sicherheitslücken zeigt alle potenziellen Sicherheitslücken auf – aber nur weil ein Softwarepaket eine häufige Sicherheitslücke oder Gefährdung (CVE; Common Vulnerability or Exposure) aufweist, bedeutet das nicht, dass diese zugänglich oder ausnutzbar ist. Sowohl Sicherheitsteams als auch Entwickler(innen) priorisieren und filtern Sicherheitslücken, die exponentiell im Laufe der Jahre angewachsen sind, seit authentifizierte Sicherheitsscans zur Norm wurden.\n\nDer Umstieg auf authentifizierte Scans hat die Wirksamkeit von Sicherheitsprogrammen in vielerlei Hinsicht verbessert, hat jedoch die Entwickler(innen) in eine endloses Hamsterrad getrieben, in dem sie Dinge beheben müssen, die nicht wichtig sind. Wenn Teams ihre Bemühungen auf Patches verschwenden, die nicht ausnutzbare Sicherheitslücken beheben, werden sie von wichtigeren Aufgaben abgehalten, wie etwa von Patches für gefährliche und ausnutzbare Schwachstellen. Das ist die Hauptursache für die heutige Trennung zwischen Sicherheits- und Engineering-Teams.\n\nWie können Unternehmen also die Grundursachen dieser Probleme angehen und eine bessere Integration zwischen Engineering und Sicherheit fördern? Hier sind drei Möglichkeiten, um häufige Frustrationspunkte hinsichtlich der Sicherheit schon von Grund auf zu verhindern.\n\n### 1. Schalte das Rauschen aus und konzentriere dich auf umsetzbare, deutliche Signale\n\nÜbermäßige falsch positive Ergebnisse sind der am zweithäufigsten genannte Frustrationspunkt, den die Befragten im Sicherheitsbereich in unserer Umfrage angaben. Falsch positive Ergebnisse sind natürlich eine Herausforderung, sie sind aber oft auch ein verstecktes Problem im Sicherheitslückenmanagement.Wenn ein Unternehmen viele falsch positive Ergebnisse hat, kann dies ein Anzeichen dafür sein, dass vielleicht nicht alles Mögliche getan wurde, um sicherzustellen, dass die Sicherheitsergebnisse auch wirklich deutlich sind. Unternehmen sollten den Fokus ihrer Sicherheitsbemühungen auf das Wesentliche beschränken. Das bedeutet, dass herkömmliche Lösungen für statische Anwendungssicherheitstests (SAST) wahrscheinlich nicht ausreichen. SAST ist ein leistungsstarkes Tool, das jedoch viel seines Wertes verliert, wenn die Ergebnisse nicht genutzt werden können oder der entsprechende Kontext fehlt. Damit SAST so effektiv wie möglich ist, muss es [nahtlos mit anderen Sicherheits- und Entwicklungstools zusammen eingesetzt werden und den Entwickler(inne)n zugänglich sein](https://about.gitlab.com/blog/oxeye-joins-gitlab-to-advance-application-security-capabilities/).Ein weiteres Problem ist, dass die meisten Scan-Tools ein sehr enges Kontextfenster haben, um die Sicherheitslücken zu verstehen. Dies ist einer der Bereiche, in denen KI mit [KI-basierten Funktionen, die Sicherheitslücken erklären](https://about.gitlab.com/de-de/the-source/ai/understand-and-resolve-vulnerabilities-with-ai-powered-gitlab-duo/), helfen kann.\n\n### 2. Minimiere den Tech-Stack und damit die Angriffsfläche\n\nNicht nur bei Sicherheitstests gilt, sich auf das Wesentliche zu konzentrieren – das sollte damit beginnen, wie ein Unternehmen überhaupt Software erstellt.\n\nObwohl KI verspricht, die Softwareentwicklungsprozesse zu vereinfachen, [deutet unsere Umfrage darauf hin, dass viele Unternehmen noch einen langen Weg vor sich haben](https://about.gitlab.com/de-de/the-source/platform/3-surprising-findings-from-our-2024-global-devsecops-survey/). Tatsächlich wollten jene Befragten, die KI nutzen, ihre Toolchain deutlich wahrscheinlicher konsolidieren als jene, die keine KI nutzen. Das lässt darauf schließen, dass der Anstieg an verschiedensten Problempunkten durch unterschiedliche KI-Modelle die Komplexität erhöht, anstatt sie zu verringern.\n\nDie ständig zunehmende Komplexität der Tech-Stacks von Unternehmen trägt wesentlich zu Frustrationen im Bereich der Sicherheit bei. Eine gewisse Komplexität ist beim Aufbau großer, facettenreicher Softwaresysteme unvermeidlich. Unternehmen sollten jedoch Maßnahmen ergreifen, um Komplexität zu vermeiden, die sich aus suboptimalen Designentscheidungen ergibt, wie z. B. schwer zu wartender Code und redundante Abhängigkeiten. Diese unnötige Komplexität schafft eine größere Angriffsfläche und generiert mehr Sicherheitsscan-Ergebnisse, die Teams durchsuchen, priorisieren und bearbeiten müssen.\n\nUnternehmen sollten bei der Softwareentwicklung den Grundsatz der Softwareminimierung walten lassen, also sich bewusst sein, welche Tools sie einsetzen und was sie in ihre Codebase integrieren möchten. Das trägt dazu bei, Abhängigkeiten zu minimieren, die Sicherheit der Software-Lieferkette zu verbessern, Scanner-Rauschen zu reduzieren und die Belastung der Entwickler(innen) zu reduzieren, wenn es darum geht, nicht kritische Probleme zu beheben.\n\n### 3. Normalisiere die sogenannten „Paved Roads“\n\nSicherheitstests, die zu spät im Lebenszyklus der Softwareentwicklung stattfinden, waren ein weiterer der größten Frustrationspunkte, die unsere Umfrageteilnehmer(innen) erleben. Teams sind vielleicht frustriert, wenn sie etwas veröffentlichen wollen und sich das verzögert, weil eine Sicherheitslücke zu spät erkannt wird. In vielen Fällen wäre es jedoch gar nicht möglich gewesen, diese Sicherheitslücke früher zu finden. Es wäre jedoch möglich, einfach bereitstellbare, wiederverwendbare Sicherheitskomponenten zu nutzen und die Variablen und möglichen Sicherheitslücken dadurch einzugrenzen.Teams können Überraschungen in der späten Phase vermeiden, indem sie [getestete und abgesicherte Entwurfsmuster basierend auf wiederholbaren Anwendungsfällen](https://about.gitlab.com/the-source/platform/how-devops-and-platform-engineering-turbocharge-efficiency/) nutzen: den Ansatz der sogenannten „gepflasterten Straßen“ (Paved Roads). Eine gepflasterte Straße ist ein empfohlener Pfad, der eine kuratierte Auswahl an Tools, Prozessen und Komponenten enthält. Dieser Straße können Teams folgen, um sichere Anwendungen effizienter zu erstellen, z. B. indem sie GitOps nutzen, um gut konstruierte und getestete Infrastructure as Code zu versionieren und bereitzustellen, die sich für alle Workloads skalieren lässt.\n\nDurch solche gepflasterten Straßen geht zwar etwas Flexibilität verloren, doch der betriebliche Aufwand und Überarbeitungen für Engineering-Teams werden reduziert und die Sicherheit wird verbessert. Das muss eine gemeinsame Anstrengung zwischen Sicherheit und Entwicklung sein. Das Sicherheitsteam kann helfen, gepflasterte Straßen zu entwerfen, aber das Engineering muss einbezogen werden, um sie als Teil der Codebasis zu betreiben und zu warten.\n\n## Sicherheit ist eine Domain, kein Team{class=\"no-anchor\"}\n\nWir erleben bereits, dass Sicherheit immer mehr in den Bereich der Engineering-Teams rutscht, und können annehmen, dass die Grenzen zwischen den Bereichen auch weiter verschwimmen werden. Durch die rasche Einführung von KI und der damit einhergehenden Beschleunigung der Softwareentwicklung – 66 % der Befragten unserer Umfrage gaben an, dass sie Software bereits doppelt so schnell oder noch schneller veröffentlichen als im Vorjahr – ist es für Unternehmen äußerst wichtig, Systeme und Frameworks einzuführen, die für den größtmöglichen Sicherheitsvorteil optimiert sind. Deshalb ist die Idee einer kulturellen Trennung zwischen Entwicklung und Sicherheit nicht die ganze Geschichte. Es ist unerlässlich, eine Kultur der Zusammenarbeit zu fördern. Sicherheits- und Engineering-Teams müssen aber auch wirklich zusammenarbeiten, um die grundlegenden Aspekte der Softwareentwicklung neu zu durchdenken, wie etwa die Optimierung bestehender Codebases und der Aufbau skalierbarer Lösungen, bei denen das Engineering im Mittelpunkt steht und die nahtlos von technischen Teams im gesamten Unternehmen eingeführt werden können.","security-its-more-than-culture-addressing-the-root-cause-of-common-security","content:de-de:the-source:security:security-its-more-than-culture-addressing-the-root-cause-of-common-security:index.yml","de-de/the-source/security/security-its-more-than-culture-addressing-the-root-cause-of-common-security/index.yml","de-de/the-source/security/security-its-more-than-culture-addressing-the-root-cause-of-common-security/index",{"_path":542,"_dir":30,"_draft":6,"_partial":6,"_locale":7,"config":543,"seo":544,"content":549,"type":478,"category":30,"slug":557,"_id":558,"_type":32,"title":550,"_source":33,"_file":559,"_stem":560,"_extension":36,"date":530,"description":546,"timeToRead":551,"heroImage":547,"keyTakeaways":552,"articleBody":556},"/de-de/the-source/security/strengthen-your-cybersecurity-strategy-with-secure-by-design",{"layout":5,"template":461,"articleType":462,"author":487,"featured":6,"gatedAsset":26,"isHighlighted":6,"authorName":444},{"title":545,"description":546,"ogImage":547,"config":548},"Cybersicherheit stärken mit Secure by Design-Prinzipien","Erfahre mehr über Secure-by-Design-Prinzipien und verwandte Konzepte und wie du heute Sicherheit in deine Software-Entwicklungsprozesse integrieren kannst.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1751463932/pnfdgovoaq5qd1yprxuc.png",{"ignoreDescriptionCharLimit":13},{"title":550,"date":530,"description":546,"timeToRead":551,"heroImage":547,"keyTakeaways":552,"articleBody":556},"Stärke deine Cybersicherheitsstrategie mit Secure by Design-Prinzipien","Lesezeit: 6 Min.",[553,554,555],"Secure by Design, Secure by Default und Secure by Demand verhindern Schwachstellen und Angriffe auf die Software-Lieferkette, indem sie Technologiehersteller ermutigen, Sicherheit in jeden Aspekt von Produktdesign und -entwicklung zu integrieren.","Die Einführung eines umfassenden DevSecOps-Ansatzes und die Erstellung und Pflege von Software-Stücklisten (SBOMs) sind wichtige Schritte auf dem Weg zur Anwendung der Secure-by-Design-Prinzipien.","Die Integration von KI in den Software-Entwicklungsprozess kann zudem Entwicklungsprozesse beschleunigen, die Sicherheit verbessern und bei der Behebung von Sicherheitslücken hilfreich sein.","Der Ansatz eines Unternehmens auf dem Gebiet der Cybersicherheit muss sich kontinuierlich weiterentwickeln, da die Angriffsflächen zunehmen und mehr über potenzielle Bedrohungen bekannt wird. Ausgehend von der Erkenntnis, dass Bedrohungen an jedem Punkt der Software-Lieferkette eintreten können, integriert ein Secure-by-Design-Ansatz Sicherheit in die Design-, Programmierungs-, Test- und Bereitstellungsphase der Softwareentwicklung. Als Standard für die Bundesbehörden der USA – und jedes Unternehmen, das mit ihrer Software zu tun hat – haben sich die Secure-by-Design-Prinzipien zu einem Benchmark für die Integration von Sicherheit in den Software-Entwicklungsprozess entwickelt.\n\nIm Laufe der Zeit haben sich die Secure-by-Design-Prinzipien in verwandte Konzepte wie _Secure by Default_ und _Secure by Demand_ weiterentwickelt, bei denen verschiedene Ansätze von Secure-by-Design-Prinzipien im Vordergrund stehen:\n\n- [Secure by Default](#what-is-secure-by-default) verfolgt das Ziel, dass sämtliche Softwareprodukte standardmäßig sicher sind.\n- [Secure by Demand](#what-is-secure-by-demand) erweitert die Secure-by-Design-Prinzipien auf den Beschaffungsprozess.\n\nHier erfährst du mehr über Secure-by-Design-Prinzipien und die erwähnten verwandten Ansätze, darunter auch eine [Schritt-für-Schritt-Anleitung](#building-a-secure-by-design-cybersecurity-strategy), wie Unternehmen ihre Strategien so anpassen können, dass sie ausnutzbare Sicherheitslücken und Angriffe auf die Software-Lieferkette verhindern können.\n\n## Was sind Secure-by-Design-Prinzipien?\nDie US-amerikanische Cybersecurity and Infrastructure Security Agency (CISA) hat im April 2023 ihre [Secure-by-Design-Initiative](https://www.cisa.gov/securebydesign) eingeführt, die sich auf drei wichtige Prinzipien der Softwaresicherheit konzentriert: \n\n1. Verantwortung für die Ergebnisse der Kundensicherheit\n1. Nutzung von radikaler Transparenz und Verantwortlichkeit\n1. Aufbau einer Organisationsstruktur und Führung zur Erreichung dieser Ziele\n\nSecure-by-Design-Prinzipien integrieren Sicherheitsrichtlinien und entsprechende Protokolle in jede Phase des Software-Entwicklungsprozesses. Das bedeutet: Sicherheitsmaßnahmen werden in die Design-, Programmierungs-, Test- und Bereitstellungsphase der Softwareentwicklung integriert und nicht erst im Nachhinein ergänzt.\n\nDas Ziel von Secure-by-Design-Prinzipien ist die Entwicklung einer sicheren Grundlage für Software, und zwar von Anfang an, um Sicherheitslücken und potenzielle Angriffsflächen zu reduzieren.\n\n### Was ist Secure by Default?\nSecure by Default ist ein Teilbereich der Secure-by-Design-Prinzipien. Im Mittelpunkt steht dabei die Sicherstellung, dass jede Software oder Hardware auf ihre sicherste Konfiguration eingestellt ist, ohne dass eine Neukonfiguration durch Benutzer(innen) erforderlich ist. Produkte, die Secure by Default nutzen, aktivieren automatisch die wichtigsten Sicherheitskontrollen, die notwendig sind, um Unternehmen vor unbefugtem Zugriff durch bösartige Akteure zu schützen – so müssen die Benutzer(innen) keine weiteren Schritte unternehmen, um sicherzustellen, dass ein Produkt vor gängigen Methoden des Missbrauchs geschützt ist.\n\nZu den Strategien von Secure by Default gehören die Beseitigung von Standardpasswörtern und die Verpflichtung zu Multi-Faktor-Authentifizierung und Single Sign-On, wodurch gewährleistet wird, dass ausschließlich befugten Benutzer(inne)n der Zugriff auf Ressourcen gewährt wird. Teil dieses Ansatzes sind auch automatische Updates und Patches sowie sichere Konfigurationen für alle Konten und Geräte der Benutzer(innen).\n\n### Was ist Secure by Demand?\nSecure by Demand kombiniert die Secure-by-Design-Prinzipien mit Budgetplanung und Beschaffungsverträgen, um diese als Verpflichtung für Anbieter(innen) und Auftragnehmer(innen) zu fördern. [Der Secure-by-Demand-Guide von CISA](https://www.cisa.gov/resources-tools/resources/secure-demand-guide) bietet eine Reihe von Fragen und Ressourcen, die Softwarekund(inn)en, Käufer(innen) und Beschaffer(innen) nutzen können, um den Cybersicherheits-Ansatz eines potenziellen Anbieters besser zu verstehen. Dazu gehören auch Fragen zu den Authentifizierungsverfahren eines Anbieters, zur Sicherheit seiner Software-Lieferkette und zur Offenlegung und Meldung von Sicherheitslücken.\n\nIndem Unternehmen die Anbieter dazu verpflichten, die Prinzipien und Protokolle von Secure by Design bei ihren Produkten und Dienstleistungen einzuhalten, können sie einen weiteren Beitrag dazu leisten, dass potenzielle Sicherheitslücken nicht in ihre Software-Lieferkette gelangen. Der Secure-by-Demand-Ansatz bietet den Anbietern auch weitere Anreize für eine kontinuierliche Verbesserung ihrer eigenen Cybersicherheitslage.\n\n## Aufbau einer Cybersicherheitsstrategie mit Secure by Design\nUnternehmen messen Secure-by-Design-Prinzipien eine höhere Priorität bei. Zu den Maßnahmen gehören auch die Nutzung von effektiven DevSecOps-Praktiken, die Pflege einer Software-Stückliste (SBOM) und die Integration von KI zur Abwehr von Bedrohungen, die an jedem Punkt des Software-Entwicklungsprozesses eintreten könnten.\n\n### Die Einführung von DevSecOps-Praktiken\nEiner der ersten Schritte zur Unterstützung einer Secure-by-Design-Position ist ein sicherer Software-Entwicklungsprozess: Entwicklung, Erstellung, Sicherung und Bereitstellung von Software unter Verwendung eines umfassenden DevSecOps-Ansatzes.\n\nHeute nutzen viele Entwickler(innen) komplexe Toolsets für die Entwicklung neuer Programme. Eine [aktuelle Umfrage von GitLab](https://about.gitlab.com/de-de/developer-survey/) ergab, dass 62 % der Befragten sechs oder mehr Tools für die Entwicklung nutzen und 20 % sogar elf oder mehr – diese Ineffizienz erhöht die Risiken, da auf diese Weise die Anzahl potenzieller Sicherheitslücken zunimmt.\n\nEntwickler(innen) sollten über eine einzige, einfach zu nutzende Bedienoberfläche auf alle Tools zugreifen können, die für DevSecOps-Workflows benötigt werden. Mit einer End-to-End-Lösung wie einer [DevSecOps-Plattform](/platform/) können Unternehmen einen Secure-by-Design-Ansatz implementieren, ohne die Entwickler(innen) zusätzlich zu belasten.\n\n### Entwicklung und Pflege von SBOMs\nTransparenz ist ein weiterer wichtiger Bestandteil der Secure-by-Design-Prinzipien. Unternehmen müssen verstehen, was in ihrer Software enthalten ist, besonders dann, wenn sie Komponenten aus mehreren Quellen enthalten kann.\n\n[SBOMs sind unerlässliche Werkzeuge für die Erreichung dieser Transparenz](https://about.gitlab.com/de-de/blog/the-ultimate-guide-to-sboms/). Sie bieten eine detaillierte Bestandsaufnahme der Softwarekomponenten, darunter auch Details zur Version, Lizenz und Abhängigkeit, was ein größeres Bewusstsein für potenzielle Sicherheitslücken oder bösartigen Code ermöglicht.\n\nDie Pflege dieses Inventars ermöglicht Unternehmen ein umfassendes Verständnis über potenzielle Sicherheitslücken und Risiken, die entstehen könnten, wenn Elemente aus Open-Source-Repositories und lizenzierten Drittanbieter-Komponenten entfernt werden. Eine DevSecOps-Plattform kann [SBOMs automatisch generieren und aktualisieren](/solutions/security-compliance/), sie in bestehende Workflows integrieren und mit zugehörigen Sicherheitslücken verknüpfen.\n\nViele Unternehmen nutzen heute SBOMs. Allerdings müssen sie dynamisch, mit Sicherheitsscan-Tools verbunden und immer auf dem neusten Stand sein, um ihre volle Wirksamkeit zu erreichen. Wenn SBOMs in Scan-Tools und Dashboards integriert sind, können damit die mit einer Anwendung verbundenen Risiken identifiziert werden. Auch in Fällen, in denen sie nicht notwendig sind, können SBOMs die Compliance mit Sicherheitsvorschriften unterstützen, indem sie die Codesicherheit validieren.\n\n### Der Einsatz von KI in der Softwareentwicklung\nUnternehmen beschäftigen sich mit verschiedenen Möglichkeiten der KI-Nutzung. Softwareentwicklungs-Workflows ermöglichen einen nützlichen Einstieg in die Technologie, die das Potenzial hat, Entwicklungsprozesse zu beschleunigen und die Sicherheit zu verbessern.\n\nUnternehmen aller Branchen beginnen bereits, diese Anwendungen zu erkunden: 39 % der Befragten [in der Umfrage von GitLab](https://about.gitlab.com/de-de/developer-survey/2024/ai/) gaben an, dass sie KI bereits im Software-Entwicklungsprozess einsetzen.\n\nDie Anwendung von KI über den gesamten Software-Entwicklungsprozess hinweg kann Unternehmen dabei helfen, Silos und Backlogs innerhalb von Entwicklungs-Workflows zu vermeiden, die durch die Nutzung von KI entstehen können. KI kann zentrale Funktionen ausführen, wie zum Beispiel:\n\n* Codeerläuterung und Legacy-Code-Refactoring in [speichersicheren Sprachen](https://about.gitlab.com/blog/memory-safe-vs-unsafe/) (nur in englischer Sprache)\n* [Grundursachenanalyse für DevSecOps-Pipelines](https://about.gitlab.com/blog/developing-gitlab-duo-blending-ai-and-root-cause-analysis-to-fix-ci-cd/), die Lösungen für komplexe Probleme beim Testen beschleunigt \n* [Behebung von Sicherheitslücken](https://about.gitlab.com/de-de/the-source/ai/understand-and-resolve-vulnerabilities-with-ai-powered-gitlab-duo/) für einen besseren Abgleich von bekannten Sicherheitslücken und eine sorgfältigere Behebung (nur in englischer Sprache)\n\nJe mehr Entscheidungsträger KI in ihre Arbeitsabläufe integrieren, desto wichtiger ist es, dem Datenschutz und der Datensicherheit Priorität einzuräumen. Ein entscheidender Aspekt der Anwendung eines Secure-by-Design-Ansatzes ist die Entwicklung einer [KI-Strategie, die sensible oder vertrauliche Daten und geistige Eigentumsrechte schützt](https://about.gitlab.com/the-source/ai/building-a-transparency-first-ai-strategy-7-questions-to-ask-your-devops/) (nur in englischer Sprache).\n\n### Was die Zukunft bringt\nDie Secure-by-Design-Prinzipien könnten bald der Standard-Ansatz für die Entwicklung eines vertrauenswürdigeren Software-Ökosystems werden. Die [US-Regierung](https://about.gitlab.com/the-source/security/national-cybersecurity-strategy-a-wake-up-call-for-software-developers/) (nur in englischer Sprache) arbeitet momentan mit Softwareentwickler(inne)n an Rahmenkonzepten, die dem Privatsektor auf gesetzlicher Grundlage Anreize bieten, um Software, die auf Secure-by-Design-Prinzipien basieren, zu produzieren und zu veröffentlichen, was Unternehmen dazu veranlassen soll, mehr in sichere Technologien und Verfahren zu investieren.\n\nDa die Sicherheit von Anfang an in die Softwareentwicklung integriert ist, die Transparenz durch effektive SBOMs gewährleistet wird und die KI den Entwicklungsprozess verbessert, können alle am Software-Entwicklungsprozess beteiligten Personen erfolgreich sein.","strengthen-your-cybersecurity-strategy-with-secure-by-design","content:de-de:the-source:security:strengthen-your-cybersecurity-strategy-with-secure-by-design:index.yml","de-de/the-source/security/strengthen-your-cybersecurity-strategy-with-secure-by-design/index.yml","de-de/the-source/security/strengthen-your-cybersecurity-strategy-with-secure-by-design/index",{"_path":562,"_dir":30,"_draft":6,"_partial":6,"_locale":7,"config":563,"seo":565,"content":570,"type":478,"category":30,"slug":577,"_id":578,"_type":32,"title":566,"_source":33,"_file":579,"_stem":580,"_extension":36,"date":571,"description":567,"timeToRead":472,"heroImage":568,"keyTakeaways":572,"articleBody":576},"/de-de/the-source/security/how-gitlab-can-help-you-prepare-for-your-soc-2-exam",{"layout":5,"template":461,"articleType":462,"author":564,"featured":6,"isHighlighted":6,"authorName":439},"gitlab",{"title":566,"description":567,"ogImage":568,"config":569},"So hilft dir GitLab, dich auf deine SOC-2-Prüfung vorzubereiten","Erfahre mehr über die Funktionen der DevSecOps-Plattform, die dich bei der Vorbereitung auf eine Prüfung nach dem SOC-2-Framework unterstützen.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1751463759/yk7f6poowtw5y5d5oflv.png",{"ignoreTitleCharLimit":13},{"title":566,"date":571,"description":567,"timeToRead":472,"heroImage":568,"keyTakeaways":572,"articleBody":576},"2024-07-18",[573,574,575],"Automatisierte Test- und Codeabdeckungsberichte sorgen für eine bessere Verfügbarkeit und Prozessintegrität nach SOC 2.","Die Sicherheitsscans und rollenbasierten Kontrollen von GitLab stellen sicher, dass das SOC-2-Framework eingehalten werden kann, wodurch Daten vor Sicherheitslücken und unautorisiertem Zugriff geschützt werden.","Mit den GitLab-Vorlagen für Browser- und Lasttest werden SOC-2-Prüfungen erleichtert, da damit die Leistung der Anwendung und ihre Sicherheit in jeder Entwicklungsphase validiert werden können.","Kund(inn)en von GitLab haben festgestellt, dass die Verwendung von GitLab als DevSecOps-Plattform den SOC-2-Prüfungsprozess vereinfacht hat. In diesem Blog werden das SOC-2-Framework und die GitLab-Funktionen vorgestellt, die Kund(inn)en bei ihrer Vorbereitung auf die SOC-2-Prüfung helfen.\n\n## Einführung in SOC 2\nDie System and Organization Controls 2, auch als [SOC 2](https://us.aicpa.org/interestareas/frc/assuranceadvisoryservices/serviceorganization-smanagement) bekannt, ist ein freiwilliger Compliance-Standard, der festlegt, wie Unternehmen Kundendaten verwalten sollten. Mit dem SOC-2-Prüfungsbericht können Unternehmen die Vertrauenswürdigkeit ihrer angebotenen Software für Geschäftskunden bescheinigen.\n\nSOC 2 wurde von der Association of International Certified Professional Accountants (AICPA) entwickelt und setzt auf fünf sogenannte TSCs, die Trust Services Criteria, mit der vertrauenswürdige Dienste ausgezeichnet werden sollen:\n- Sicherheit: Schutz von Kundendaten vor Sicherheitslücken und unbefugtem Zugriff\n- Verfügbarkeit: Dieser Aspekt soll sicherstellen, dass Systeme auch unter hohen Lasten fehlertolerant und leistungsfähig sind, um Verfügbarkeits-Service-Level-Vereinbarungen zu erfüllen \n- Verarbeitungsintegrität: Systeme funktionieren wie geplant ohne Sicherheitslücken, Fehler oder Bugs\n- Vertraulichkeit: Schutz vertraulicher Informationen wie Anwendungsquellcode, Benutzernamen und Passwörter, Kreditkarteninformationen usw., sodass nur Personen Zugriff erhalten, die diese für ihre Arbeit wirklich benötigen\n- Datenschutz: Schutz sensibler personenbezogener Daten vor unautorisierten Benutzer(inne)n\n\nSicherheit ist das einzige erforderliche Kriterium für jede SOC-2-Prüfung. Die anderen Kriterien können der Prüfung hinzugefügt werden, wenn sie als kritisch für die erbrachten Dienstleistungen erachtet werden.\n\n## TSC-Kriterium „Sicherheit“\nDas Sicherheitskriterium bezieht sich nicht nur auf die Sicherheit von Servern und physischen Systemen, sondern auch auf die Anwendungssicherheit. Software-Sicherheitslücken können Anwendungen für Angreifer(innen) öffnen und die Daten der Kund(inn)en gefährden – doch dies ist ein Bereich, in dem GitLab helfen kann. \n\nGitLab bietet Sicherheitsscans, um potenzielle Sicherheitslücken in den Anwendungen, die ein Unternehmen entwickelt, unter anderem durch folgende Angebote aufzudecken (Artikel sind nur in englischer Sprache verfügbar):\n- [Statische Anwendungssicherheitstests (SAST)](https://docs.gitlab.com/ee/user/application_security/sast/), bei denen der Quellcode auf potenzielle Bugs und Sicherheitslücken wie unsicheren Code, der zu unerwünschter Ausführung dieses Codes führt, überprüft wird\n- [Abhängigkeitssuche](https://docs.gitlab.com/ee/user/application_security/dependency_scanning/), bei der Sicherheitslücken in den Software-Abhängigkeiten einer Anwendung gesucht werden\n- [Container-Scanning](https://docs.gitlab.com/ee/user/application_security/container_scanning/), bei dem Sicherheitslücken in den Betriebssystemabhängigkeiten einer containerisierten Anwendung gesucht werden\n- [Dynamische Anwendungssicherheitstests (DAST)](https://docs.gitlab.com/ee/user/application_security/dast/), bei der Sicherheitslücken in laufenden Webanwendungen gesucht werden, durch die das System anfällig für Angriffe ist\n- [IaC-Scanning (Infrastructure as Code)](https://docs.gitlab.com/ee/user/application_security/iac_scanning/), bei dem Konfigurationsdateien für Infrastructure as Code, unter anderem von Terraform, Ansible, AWS, CloudFormation und Kubernetes, auf Sicherheitslücken überprüft werden\n\nGitLab bietet außerdem [Sicherheitslückenberichte](https://docs.gitlab.com/ee/user/application_security/vulnerability_report/), in denen alle bekannten Sicherheitslücken, die mit den genannten Tests in der aktuellen Anwendung gefunden wurden, aufgelistet werden. Zudem bietet GitLab eine Software-Stückliste ([SBOM](https://docs.gitlab.com/ee/user/application_security/dependency_list/), Artikel nur in englischer Sprache verfügbar) im Standard-JSON-Format von CycloneDX an, in der alle Abhängigkeiten auf Software- und Betriebssystemebene sowie bekannte Sicherheitslücken angezeigt werden.\n\nRegelmäßige Sicherheitslückenscans und aussagekräftige Berichte über Sicherheitslücken helfen, die Anforderungen in drei Sicherheitsbereichen zu erfüllen:\n- CC7.1: Um die Ziele dieses Aspekts zu erfüllen, werden Erkennungs- und Überwachungsprozesse eingesetzt, um (1) Änderungen an Konfigurationen zu erkennen, die neue Sicherheitslücken entstehen lassen, und (2) Anfälligkeiten für neu erkannte Sicherheitslücken zu identifizieren.\n- CC4.1 – COSO-Prinzip 16: Das Unternehmen wählt, entwickelt und führt laufende und/oder separate Überprüfungen durch, um festzustellen, ob die Komponenten eines internen Kontrollsystems vorhanden sind und funktionieren.\n- CC4.2 – COSO-Prinzip 17: Das Unternehmen bewertet und kommuniziert Mängel der internen Kontrolle rechtzeitig an die Parteien, die für Korrekturmaßnahmen verantwortlich sind, einschließlich der Geschäftsleitung und des Vorstands.\n\nEin entscheidendes Element bei Sicherheitsscans sind Governance und Durchsetzung. GitLab stellt mit seinen Funktionen sicher, dass Scans regelmäßig durchgeführt werden und nicht durch die Entwicklungsteams umgangen werden können. Zu diesen Funktionen gehören (die Artikel sind nur in englischer Sprache verfügbar):\n- [Rollenbasierte Zugriffskontrollen](https://docs.gitlab.com/ee/user/permissions.html), um einzuschränken, wer Änderungen an Konfigurationseinstellungen auf Projektebene vornehmen kann\n- [Scan-Ausführungsrichtlinien](https://docs.gitlab.com/ee/user/application_security/policies/scan-execution-policies.html), um sicherzustellen, dass Scans in jedem Code-Repository ausgeführt werden \n- [Merge-Request-Approvalrichtlinien](https://docs.gitlab.com/ee/user/application_security/policies/merge_request_approval_policies.html), um sicherzustellen, dass die Merge Requests von den entsprechenden Sicherheitsbeteiligten überprüft und genehmigt werden, damit neu entdeckte Sicherheitslücken nicht in die bereitgestellte Software einfließen\n- [Compliance-Berichte](https://docs.gitlab.com/ee/user/application_security/), um Änderungen an GitLab-Konfigurationen anzuzeigen, die gegen geltende Sicherheitsprozesse verstoßen könnten\n\nMit diesen Konfigurationen können Unternehmen nachweisen, dass Softwaresicherheit für ihre Anwendungen oberste Priorität hat und Sicherheitspraktiken durchgesetzt werden.\n\n## TSC-Kriterien „Verfügbarkeit“ und „Prozessintegrität“\nGitLab kann auch bei den TSC-Kriterien für Verfügbarkeit und Prozessintegrität unterstützen. Bei diesen Kriterien geht es um die Qualität und Leistung der Anwendung selbst. Dazu bietet GitLab folgende Funktionen (die Artikel sind nur in englischer Sprache verfügbar):\n- Ergebnisse von Unit-Tests und Änderungen der Testabdeckung in Form von [Testabdeckungsberichten](https://docs.gitlab.com/ee/ci/testing/code_coverage.html), die sicherstellen, dass der Quellcode durch eine Test-Suite validiert wird\n- [Codequalität](https://docs.gitlab.com/ee/ci/testing/code_quality.html), mit der die Qualität und Komplexität des Quellcodes analysiert werden, damit dieser einfach zu lesen und zu warten ist\n\nDie genannten Softwareentwicklungspraktiken kommen früh im Software-Entwicklungsprozess zum Einsatz, um hochwertigen, getesteten Code zu garantieren. GitLab bietet außerdem Vorlagen für verschiedenste Arten von automatisierten Tests für laufende Anwendungen, um sicherzustellen, dass diese wie erwartet funktionieren. Zu diesen Tests gehören (die Artikel sind nur in englischer Sprache verfügbar):\n- [Browser-Performance-Tests](https://docs.gitlab.com/ee/ci/testing/browser_performance_testing.html), bei denen die Ladezeit von Websites während des Entwicklungslebenszyklus gemessen wird, um die Auswirkungen von Codeänderungen auf die Browser-Performance zu testen\n- [Lasttests](https://docs.gitlab.com/ee/ci/testing/load_performance_testing.html), die die Systemleistung des Backends einer Anwendung während des Entwicklungslebenszyklus misst, um die Auswirkungen von Codeänderungen auf die Leistung zu testen\n- [Abdeckungs-Fuzzing](https://docs.gitlab.com/ee/user/application_security/coverage_fuzzing/), das unerwartete, fehlerhafte oder zufällige Daten an eine Anwendung sendet und sie dann auf instabile Verhaltensweisen und Abstürze überwacht\n- [Web-API-Fuzzing](https://docs.gitlab.com/ee/user/application_security/api_fuzzing/), das unerwartete, fehlerhafte oder zufällige Daten an API-Endpunkte sendet, um nach Fehlern und Sicherheitsproblemen zu suchen\n\nMit GitLab können Unternehmen auf starke DevSecOps-Praktiken setzen und hochwertige, sichere Anwendungen entwickeln, die dazu beitragen, SOC-2-Prüfungen einfacher zu bestehen und so die Sicherheit von Kundendaten offiziell bestätigen zu lassen.\n\n> **Mehr erfahren:** [Stärke deine Cybersicherheitsstrategie mit Secure-by-Design-Prinzipien](https://about.gitlab.com/de-de/the-source/security/strengthen-your-cybersecurity-strategy-with-secure-by-design/).","how-gitlab-can-help-you-prepare-for-your-soc-2-exam","content:de-de:the-source:security:how-gitlab-can-help-you-prepare-for-your-soc-2-exam:index.yml","de-de/the-source/security/how-gitlab-can-help-you-prepare-for-your-soc-2-exam/index.yml","de-de/the-source/security/how-gitlab-can-help-you-prepare-for-your-soc-2-exam/index",{"_path":582,"_dir":30,"_draft":6,"_partial":6,"_locale":7,"config":583,"seo":584,"content":589,"type":478,"category":30,"slug":598,"_id":599,"_type":32,"title":585,"_source":33,"_file":600,"_stem":601,"_extension":36,"date":590,"description":591,"timeToRead":592,"heroImage":587,"keyTakeaways":593,"articleBody":597},"/de-de/the-source/security/10-tips-to-prioritize-security-in-software-development",{"layout":5,"template":461,"articleType":462,"author":564,"featured":6,"isHighlighted":6,"authorName":439},{"title":585,"description":586,"ogImage":587,"config":588},"10 Tipps, wie du Sicherheit zu einer Priorität bei der Softwareentwicklung machst","Befolge diese Tipps, um die Sicherheit früher in deinem Pozess zu überprüfen. So kannst du effizienter werden und die Sicherheit der Software verbessern.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1751464607/pmqkaclogv0y5tf4hk3t.png",{"ignoreTitleCharLimit":13},{"title":585,"date":590,"description":591,"timeToRead":592,"heroImage":587,"keyTakeaways":593,"articleBody":597},"2024-04-16","Halte dich an diese Tipps, um die Sicherheit zu einem früheren Zeitpunkt in deinem Entwicklungsprozess zu überprüfen. So kannst du effizienter werden und die Sicherheit der Software verbessern.","Lesezeit: 2 Min.",[594,595,596],"Wenn die Sicherheit im Vorfeld kontrolliert wird, können Sicherheitslücken frühzeitig im SDLC erkannt werden.","GitLab integriert die Sicherheit in DevSecOps für ein proaktives Risikomanagement.","Optimiere deine Prozesse mit GitLab, um die Geschwindigkeit und Compliance bei der Entwicklung zu verbessern.","Cyberangriffe und Cybersicherheitsbedrohungen zählen weiterhin zu den höchsten Prioritäten für Unternehmen. Deshalb entwickelt sich die Rolle von Entwickler(innen) kontinuierlich weiter. Mehr als die Hälfte der in der [globalen DevSecOps-Umfrage 2024](https://about.gitlab.com/developer-survey/) von GitLab befragten Umfrageteilnehmer(innen) gab an, für die Anwendungssicherheit als Teil eines größeren Teams verantwortlich zu sein. Das zeigt, dass die Sicherheit immer mehr im Vorfeld kontrolliert wird.\n\nDurch die Implementierung eines „Shift Left“-Ansatzes, d. h. die Entwicklung von Software mit integrierten bewährten Sicherheitspraktiken zur Erkennung und Behebung von Sicherheitslücken zu einem früheren Zeitpunkt im Software-Entwicklungsprozess (SDLC), können Teams effizienter arbeiten und Software schneller veröffentlichen.\n\nWährend 67 % der von GitLab befragten Sicherheitsexpert(inn)en angaben, dass sie entweder diesen Shift-Left-Ansatz bereits nutzen oder dies in den nächsten drei Jahren planen, bist du möglicherweise unsicher, wie du anfangen sollst.\n\nHier findest du 10 Tipps, die deinen Teams dabei helfen, die Sicherheit im Vorfeld zu kontrollieren und so DevSecOps effizienter zu machen:\n\n### 1. Erfasse die Zeit\n\nWie viel Zeit geht beim Beheben von Sicherheitslücken verloren, nachdem der Code zusammengeführt wurde? Erfasse die Zeit dafür, suche dann nach einem Muster in der Art oder Quelle dieser Sicherheitslücken und nimm die notwendigen Anpassungen vor, um Verbesserungen zu erzielen.\n\n### 2. Erkenne Engpässe\n\nWo befinden sich die Herausforderungen und Engpässe zwischen Sicherheitsprotokollen und -prozessen? Identifiziere diese, erstelle anschließend einen Lösungsplan und führe ihn aus.\n\n### 3. Beginne mit kleinen Änderungen\n\nNimm kleine Codeänderungen vor – sie sind einfacher zu überprüfen, zu sichern und schneller zu veröffentlichen als große Projektänderungen.\n\n### 4. Verabschiede dich vom Wasserfallprinzip\n\nHalten Teammitglieder immer noch an Sicherheitsprozessen im Wasserfallprinzip innerhalb des SDLC fest? Wenn du diesen Wasserfall beseitigst oder reduzierst, hilft dies deinem Unternehmen, Konflikte um einen Richtungswechsel bei Bedarf zu verhindern.\n\n### 5. Automatisiere Scans\n\nVerlangsamen und behindern manuelle Abläufe die Erkennung von Sicherheitslücken? Automatisiere Ergebnisse in einem Merge Request, damit Entwickler(innen) Sicherheitslücken einfacher überprüfen, Quellen finden und darauf zugreifen können, um Sicherheitslücken zu beheben.\n\n### 6. Aktualisiere die Workflows \n\nSind Sicherheitsscans im Workflow deiner Entwickler(innen) enthalten? Durch den Aufbau und die Integration von Sicherheit in die Arbeitsabläufe der Entwickler(innen) können sie Sicherheitslücken finden und beheben, bevor sie den Code überhaupt weitergeben.\n\n### 7. Beweise Compliance\n\nVerzögern ungeplante Arbeiten deine Veröffentlichungen? Die Automatisierung und Implementierung von Compliance-Frameworks tragen zur Konsistenz zwischen Entwicklungsumgebungen, Teams und Anwendungen bei.\n\n### 8. Unterstütze Entwickler(innen) mit Sicherheitsberichten\n\nHaben deine Entwickler(innen) Zugriff auf SAST- und DAST-Berichte? Diese wertvollen Tools helfen Entwicklungsteams, sichere Programmierpraktiken zu entwickeln und Sicherheitslücken im Rahmen ihrer Workflows zu beheben.\n\n### 9. Ermögliche deinen Teams, intelligenter zu arbeiten\n\nErmögliche dem Sicherheitsteam, mit Sicherheits-Dashboards sowohl für behobene als auch für nicht behobene Sicherheitslücken intelligenter zu arbeiten, herauszufinden, wo sich die Sicherheitslücken befinden, wer sie verursacht hat und welchen Status ihre Behebung hat.\n\n### 10. Weg mit der Toolchain\n\nOptimiere und reduziere deine Toolchain, damit sich die Mitarbeiter(innen) auf eine einzige Schnittstelle konzentrieren können – eine einzige Quelle der Wahrheit.\n\n## Kontrolliere mit GitLab die Sicherheit im Vorfeld\n\nGitLab hilft dir, eine proaktive Sicherheitsstrategie einzuführen, mit der du Sicherheitslücken zu einem früheren Zeitpunkt im SDLC entdecken kannst. Sicherheit und Konformität sind in die DevSecOps-Plattform von GitLab integriert. Sie bietet einen End-to-End-Workflow, der es dir ermöglicht, Risiken zu verstehen und zu steuern. Scanne automatisch nach Sicherheitslücken in einem Feature-Branch, damit du Sicherheitslücken beheben kannst, bevor sie in die Produktion gepusht werden.GitLab unterstützt seit jeher die DevSecOps-Initiativen von US-amerikanischen Bundes-, Landes- und Kommunalbehörden, Anbietern und Bildungseinrichtungen mit einer End-to-End-Softwareentwicklungsplattform, die strenge Sicherheits- und Konformitätsanforderungen erfüllt. Erfahre mehr darüber, [wie GitLab dir helfen kann, die Sicherheit im Vorfeld zu überprüfen](https://about.gitlab.com/solutions/public-sector/) und deine Geschwindigkeit beizubehalten, die du brauchst, um deine Mission zu erreichen.","10-tips-to-prioritize-security-in-software-development","content:de-de:the-source:security:10-tips-to-prioritize-security-in-software-development:index.yml","de-de/the-source/security/10-tips-to-prioritize-security-in-software-development/index.yml","de-de/the-source/security/10-tips-to-prioritize-security-in-software-development/index",{"_path":603,"_dir":30,"_draft":6,"_partial":6,"_locale":7,"slug":604,"type":478,"category":30,"config":605,"seo":607,"content":610,"_id":634,"_type":32,"title":612,"_source":33,"_file":635,"_stem":636,"_extension":36,"description":611,"date":613,"timeToRead":614,"heroImage":615,"keyTakeaways":616,"articleBody":620,"faq":621},"/de-de/the-source/security/how-to-implement-secret-management-best-practices-with-gitlab","how-to-implement-secret-management-best-practices-with-gitlab",{"layout":5,"template":461,"featured":6,"articleType":462,"author":606,"isHighlighted":6,"authorName":443},"jlongo",{"description":608,"ogDescription":608,"title":609,"ogTitle":609},"So implementierst du sicheres Secret Management mit GitLab. Praktische Tipps für API-Keys, Passwörter und sensible Daten im DevOps-Workflow.","Secret Management Best Practices mit GitLab umsetzen",{"description":611,"title":612,"date":613,"timeToRead":614,"heroImage":615,"keyTakeaways":616,"articleBody":620,"faq":621},"Ein unsicherer Umgang mit Geheimnissen stellt ein Risiko für Unternehmen dar, die Kundendaten speichern und schützen sollten. Erfahre, wie du diese Risiken minderst und das Vertrauen stärkst.","So implementierst du mit GitLab Best Practices für den Umgang mit Geheimnissen","2024-03-12","5 min read","https://res.cloudinary.com/about-gitlab-com/image/upload/v1751463593/wgbh2snwpsyle9jom1k1.png",[617,618,619],"Ein unsicherer Umgang mit Geheimnissen birgt das Risiko von Datenschutzverletzungen. Die native Integration von GitLab verbessert dagegen die Sicherheit.","Durch einen überprüfbaren, zuordenbaren Umgang mit Geheimnissen können Sicherheitsteams abnormale oder böswillige Aktivitäten erkennen und schnell darauf reagieren.","GitLab unterstützt die Speicherung und Verwendung von Geheimnissen mit robusten Zugriffskontrollen und Erkennungstools.","Insecure secret management practices (SMPs) pose a significant risk to any company, especially those tasked with the storage and protection of their customers' data. It's a common problem, and it is often at the core of a company's risk register. A leaked secret can result in a loss of confidentiality and potentially a data breach. These types of incidents can lead to significant financial losses and a loss of trust amongst an entity's customer base.\n\nFor many companies, insecure SMPs may result from a lack of expertise or being unaware of the tools and strategies that exist to solve this issue. Appropriate SMPs can help reduce the potential for compromise and increase trust in an organization's secret management strategy. In this post, we will discuss secret management best practices, GitLab's ability to support those practices, and our strategy for improving the DevSecOps platform's native secret management capabilities.\n\n## Develop a cryptographic strategy\n\nEvery company needs a cryptographic strategy as a foundation to ensure developers are operating in a standardized way and all applications and their components are being developed in accordance with the company's cryptographic requirements.\n\nUnderstanding the data your company processes, and your company's risk tolerance and threat landscape will help you develop a strong cryptographic strategy.\n\n### Secret generation\n\nSecrets, including access tokens and SSH keys, should be generated using cryptographic devices such as Hardware Security Modules (HSM). These devices help generate cryptographically strong secrets and store them in a tamper- and intrusion-resistant manner.\n\nWhile relying on physical devices can be costly and operationally prohibitive for companies, the leading cloud service providers offer cloud HSM services – for example, [AWS CloudHSM](https://aws.amazon.com/cloudhsm/) and [GCP Cloud HSM](https://cloud.google.com/kms/docs/hsm).\n\n### Secret storage\n\nStoring secrets is just as critical as generating them. Generated secrets must be stored in a manner that supports secure long-term storage and enables users to securely retrieve and use them when necessary.\n\nThe leading cloud service providers, as well as security companies such as [HashiCorp](https://www.vaultproject.io/), offer cloud-based services for securely storing and retrieving secrets. These services enable users to seamlessly leverage secrets within their processes and code, thereby eliminating the need to hardcode secrets.\n\n#### How does GitLab support secret storage?\n\nGitLab provides native support for the following [secret management providers](https://docs.gitlab.com/ee/ci/secrets/index.html):\n\n- Vault by HashiCorp\n- Google Cloud Secret Manager\n- Azure Key Vault\n\nBy configuring GitLab to connect with a secret management provider, secrets are explicitly requested only when needed by a CI job. When secrets aren't needed by CI jobs, they remain securely stored in the secret management service's environment, thereby reducing the potential for compromise. In addition to native support for the above secret management providers, GitLab also offers [OIDC authentication](https://docs.gitlab.com/ee/ci/secrets/id_token_authentication.html) to authenticate against other providers (i.e. AWS Secret Manager). This is a much more secure and preferred method of storing secrets when compared to storing and [masking](https://docs.gitlab.com/ee/ci/variables/#mask-a-cicd-variable) secrets as CI/CD variables.\n\n### Secret use\n\nSecrets should be used for a single purpose. Reusing secrets across different applications or services increases the potential for exposure and increases the impact if the secrets are compromised.\n\nTo reduce the potential for exposure or malicious activity, access to secrets should be controlled with the [principle of least privilege](https://about.gitlab.com/blog/2024/03/06/the-ultimate-guide-to-least-privilege-access-with-gitlab/) in mind. Access should only be granted to the individuals or services that require such access in order to support their work and operational activities.\n\n#### How does GitLab support secret use?\n\nGitLab provides administrators with a strong [role-based access control model](https://docs.gitlab.com/ee/user/permissions.html) and also offers the ability to create [custom roles](https://docs.gitlab.com/ee/user/custom_roles.html), thereby allowing administrators to align access profiles with their organizational standards and risk tolerance.\n\nGitLab also allows users to perform [secret detection](https://docs.gitlab.com/ee/user/application_security/secret_detection/) to check for unintentionally committed secrets and credentials. GitLab Ultimate users can enforce [automatic responses to leaked secrets](https://docs.gitlab.com/ee/user/application_security/secret_detection/automatic_response/), such as revoking the secret, to mitigate the impact of leaked credentials.\n\n### Auditability\n\nAccess and use of secrets should be auditable and attributable. In an ideal scenario, individuals would not have access to view secrets in plaintext, but the state of a company's operations are not always ideal.\n\nAuditable and attributable secret management allows security teams to monitor for anomalous or malicious activity, and quickly respond to such activity through automated and manual intervention.\n\n#### How does GitLab support auditability?\n\nGitLab's [audit events](https://docs.gitlab.com/ee/administration/audit_events.html) capture activities related to tokens and keys that are created within GitLab. Some examples include:\n\n- personal access token events\n- deploy token events\n- cluster agent token events\n\nThese activities are saved to the database and are also available for [audit event streaming](https://docs.gitlab.com/ee/administration/audit_event_streaming/) for GitLab Ultimate customers.\n\n## Upcoming: GitLab Secret Manager\n\nGitLab plans to launch a native secret management experience in late 2024. GitLab Secret Manager is a multi-tenant, cloud-based solution and will be accessible to both GitLab.com and self-managed customers via our Cloud Connector service. This new service offers an easy-to-use interface, consistent with the current CI/CD variables interface, making adoption easier than a third-party product with a minimal learning curve. The GitLab Secret Manager will ensure the security and protection of sensitive information in your CI pipelines. \n\n> For more information or questions about GitLab Secret Manager, please visit our [MVC epic](https://gitlab.com/groups/gitlab-org/-/epics/10723) and leave a comment.",[622,625,628,631],{"header":623,"content":624},"Was ist der Umgang mit Geheimnissen bzw. Geheimnismanagement und warum ist dies für die Softwaresicherheit wichtig?","Beim Umgang mit Geheimnissen, auch Geheimnismanagement genannt, geht es darum, vertrauliche Informationen wie API-Schlüssel, Zugriffstoken und Passwörter sicher zu speichern, darauf zuzugreifen und sie sicher zu nutzen. Ein solides Geheimnismanagement verhindert den unautorisierten Zugriff, senkt das Risiko von Datenschutzverletzungen und stellt die Vertraulichkeit und Integrität sensibler Daten bei der Softwareentwicklung und in Bereitstellungsprozessen sicher.",{"header":626,"content":627},"Wie unterstützt GitLab die sichere Speicherung und den sicheren Abruf von Geheimnissen?","GitLab lässt sich in führende Sicherheitsmanagementlösungen integrieren, darunter Vault von HashiCorp, Google Cloud Secret Manager und Azure Key Vault. Dank dieser Integrationen können Geheimnisse sicher gespeichert und explizit nur dann abgerufen werden, wenn sie von CI-Jobs benötigt werden. So wird das Risiko für Verstöße und unautorisierten Zugriff gesenkt.",{"header":629,"content":630},"Was sind die besten Methoden, um Geheimnisse zu generieren und zu verwenden?","- __Erstellung von Geheimnissen__: Verwende kryptografische Geräte wie Hardware Security Modules (HSMs), um starke Geheimnisse zu erstellen. Cloud-HSM-Dienste (z. B. AWS CloudHSM, GCP Cloud HSM) bieten kostengünstige, manipulationssichere Lösungen für die Erstellung von Geheimnissen.\n- __Verwendung von Geheimnissen__: Setze auf das Prinzip des geringsten Privilegs, um sicherzustellen, dass Geheimnisse nur für einen einzigen Zweck verwendet werden können und dass nur autorisierte Benutzer(innen) oder Dienste darauf zugreifen könne. Vermeide, Geheimnisse fest zu programmieren, um Kompromittierungen zu verhindern.",{"header":632,"content":633},"Wie hilft GitLab bei der Erkennung von Geheimnissen und der Überprüfbarkeit?","GitLab bietet eine Erkennung von Geheimnissen, mit der du nach Geheimnisse und Zugangsdaten suchen kannst, die versehentlich kompromittiert wurden. Administrator(inn)en können automatisierte Reaktionen erzwingen, z. B. durch das Widerrufen von durchgesickerten Geheimnissen, um Sicherheitsbedrohungen zu minimieren. Zudem können Audit Events Aktivitäten in Bezug auf die Nutzung von Tokens und Schlüsseln erfassen und streamen, wodurch eine kontinuierliche Überwachung sowie die Erkennung von Anomalien möglich werden.","content:de-de:the-source:security:how-to-implement-secret-management-best-practices-with-gitlab:index.yml","de-de/the-source/security/how-to-implement-secret-management-best-practices-with-gitlab/index.yml","de-de/the-source/security/how-to-implement-secret-management-best-practices-with-gitlab/index",{"_path":638,"_dir":30,"_draft":6,"_partial":6,"_locale":7,"config":639,"seo":641,"content":645,"type":478,"category":30,"slug":655,"_id":656,"_type":32,"title":646,"_source":33,"_file":657,"_stem":658,"_extension":36,"date":647,"description":648,"timeToRead":649,"heroImage":644,"keyTakeaways":650,"articleBody":654},"/de-de/the-source/security/enterprise-scale-security-and-compliance-policy-management-in-the-ai-era",{"layout":5,"template":461,"articleType":462,"author":640,"featured":6,"isHighlighted":6,"authorName":440},"grant-hickman",{"title":642,"description":643,"ogImage":644},"KI-Sicherheits- und Compliance-Richtlinien verwalten","Erfahre, wie du mit GitLab Sicherheitsrichtlinien verwalten und so deine Sicherheit und Compliance mit der Softwareentwicklung Schritt halten können.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1751464499/qriml3qncnibzphitcax.png",{"title":646,"date":647,"description":648,"timeToRead":649,"heroImage":644,"keyTakeaways":650,"articleBody":654},"Verwaltung von Sicherheits- und Compliance-Richtlinien auf Unternehmensebene im Zeitalter der künstlichen Intelligenz","2023-10-17","Ein Überblick darüber, wie die Verwaltung von Sicherheitsrichtlinien von GitLab dazu beitragen kann, dass deine Sicherheit und Compliance mit der Softwareentwicklung Schritt halten können.","Lesezeit: 8 Min.",[651,652,653],"Sicherheitsteams haben Mühe, mit der rasanten Softwareentwicklung Schritt zu halten, die durch den Einsatz von KI noch beschleunigt wird. Ein effektives Management von Sicherheitslücken ist entscheidend, um robuste Sicherheit zu gewährleisten.","Mit den Sicherheitsrichtlinien von GitLab kannst du die Einhaltung von Richtlinien automatisieren und die Zusammenarbeit zwischen AppSec- und Entwicklungsteams fördern, um Sicherheitslücken effizient zu erkennen und zu beheben.","Priorisierungstechniken wie CVSS und das risikobasierte Scoring helfen bei der Bewältigung von Sicherheitslücken und stellen sicher, dass der Fokus auf kritische Probleme gelegt wird, da immer mehr Sicherheitslücken durch KI generiert werden.","Sicherheitsteams stehen vor der Herausforderung, mit der Softwareentwicklung Schritt zu halten. Und sie sehen sich weiterhin mit Hindernissen konfrontiert, z. B. mit Führungskräften, die irrtümlicherweise die Bedeutung der Sicherheit im Entwicklungsprozess verkennen, oder mit dem Ungleichgewicht zwischen Entwickler(inne)n und Sicherheitspersonal. Jetzt, da die KI dazukommt, nimmt das Tempo noch mehr zu. Die Entwicklungsgeschwindigkeit wird nur zunehmen, wenn die Unternehmen auf Enterprise-Niveau skalieren. Daher müssen auch die Sicherheitstools, die zur Steuerung der Entwicklungsprozesse eingesetzt werden, mit diesem Wachstum Schritt halten können.\n\nAnwendungssicherheitsteams müssen Sicherheitslücken effektiv verwalten und priorisieren. Mit den [Sicherheitsrichtlinien von GitLab](https://docs.gitlab.com/ee/user/application_security/policies/) (nur in englischer Sprache verfügbar) und unseren Sicherheitstools können Unternehmen die Zusammenarbeit zwischen AppSec- und Entwicklungsteams fördern, um Sicherheitslücken effizient zu erkennen, einzugrenzen und zu beheben. Mit Sicherheitsrichtlinien lässt sich auch die Einhaltung von Sicherheitsvorschriften automatisieren und auf Unternehmensebene verwalten.\n\nDas Scannen einer größeren Anzahl potenzieller Sicherheitslücken bietet zwar bessere Möglichkeiten zur frühzeitigen Erkennung und Behebung von Problemen, aber die schiere Menge der Ergebnisse kann AppSec-Teams überfordern. Je mehr Einblicke wir durch zusätzliche Scans in Sicherheitslücken gewinnen, desto schwieriger wird es, herauszufinden, welche Maßnahmen sinnvoll sind.\n\n## Prozesse für die Verwaltung von Sicherheitslücken (Triage) \nGegenwärtig gibt es einige gängige Ansätze für die Triage von Sicherheitslücken:\n\n- **Common Vulnerability Scoring System:** CVSS bietet eine standardisierte Methode zur Bewertung des Schweregrads von Sicherheitslücken. Mithilfe der CVSS-Scores können Unternehmen Sicherheitslücken auf der Grundlage ihrer potenziellen Auswirkungen priorisieren und ihre Ressourcen entsprechend zuweisen.\n\n- **Risikobasiertes Scoring:** Mit dem risikobasierten Scoring können Unternehmen Sicherheitslücken auf der Grundlage der Wahrscheinlichkeit ihrer Ausnutzung und der potenziellen Auswirkungen auf das Geschäft bewerten. Durch die Berücksichtigung von Kontextfaktoren wie dem Wert der Ressourcen, den Fähigkeiten der Bedrohungsakteure und der Verbreitung von Sicherheitslücken können Unternehmen diese effektiv priorisieren.\n\n- **Bedrohungsmodellierung:** Bei der Bedrohungsmodellierung geht es darum, potenzielle Bedrohungen für eine Anwendung oder ein System zu identifizieren und zu bewerten. Durch eine umfassende Analyse der Systemarchitektur, des Datenflusses und der potenziellen Angriffsvektoren können Unternehmen Sicherheitslücken auf der Grundlage ihrer Relevanz für wahrscheinliche Bedrohungen priorisieren. Dieser Ansatz hilft dabei, Ressourcen effektiv zu verteilen, indem er sich auf Sicherheitslücken konzentriert, die mit größerer Wahrscheinlichkeit ausgenutzt werden.\n\n- **Business Impact Analysis (BIA):** Mit dieser Technik werden die potenziellen Auswirkungen von Sicherheitslücken auf die Geschäftsvorgänge und -ziele bewertet. Dabei werden kritische Ressourcen identifiziert, ihre Bedeutung für das Unternehmen bewertet und die möglichen Folgen eines erfolgreichen Angriffs abgeschätzt. Durch die Berücksichtigung der potenziellen finanziellen, rufschädigenden und betrieblichen Auswirkungen können Unternehmen die Sicherheitslücken priorisieren, die das größte Risiko für ihre Kerngeschäftsfunktionen darstellen.\n\nMit der zunehmenden Verbreitung von KI-generiertem Code steigt auch die Zahl der Sicherheitslücken, die unbeabsichtigt eingeführt werden. Techniken wie diese sind wichtig, um Unternehmen dabei zu helfen, Prioritäten zu setzen und diesen Prozess zu verstehen. Wie können wir also diese konzeptionellen Frameworks in der realen Welt anwenden? Sehen wir uns an, wie wir die Techniken in die Praxis umsetzen können.\n\n## Verwaltung von Sicherheitsrichtlinien\n[Sicherheitsrichtlinien](https://docs.gitlab.com/ee/user/application_security/policies/) (nur in englischer Sprache verfügbar) sind die Antwort auf die Umsetzung von Unternehmensrichtlinien und Compliance-Anforderungen in konkrete Betriebsanweisungen, die in deine DevSecOps-Praktiken und den Software-Entwicklungsprozess integriert werden. Durch die Festlegung von Regeln in den Sicherheitsrichtlinien von GitLab können Unternehmen granulare Kriterien für die Bewertung von Sicherheitslücken festlegen und so sicherstellen, dass nur umsetzbare Lösungen zur weiteren Bearbeitung markiert werden.\n\nMit Sicherheitsrichtlinien kannst du deine Sicherheits- und Compliance-Anforderungen und bewährten Methoden umsetzen, indem du sie im Code implementierst. [Scan-Ausführungsrichtlinien](https://docs.gitlab.com/ee/user/application_security/policies/scan-execution-policies.html) (nur in englischer Sprache verfügbar) erzwingen die Ausführung von Scans in bestimmten Projekten auf der Grundlage deiner Bedürfnisse und Anforderungen und stellen sicher, dass Sicherheitslücken und Gefährdungen entdeckt werden, bevor der Code in die Produktion überführt wird.\n\nDu kannst auch [Merge-Request-Approvalrichtlinien](https://docs.gitlab.com/ee/user/application_security/policies/scan-result-policies.html) nutzen, um individuelle Workflows zur Behebung von Sicherheitslücken zu erstellen. Die Richtlinien werten die Ergebnisse von Sicherheits- und Compliance-Scannern aus, um die Zusammenführung von Merge Requests zu verhindern oder zu blockieren, wenn sie nicht gründlich geprüft und nach den von dir festgelegten Regeln genehmigt wurden.\n\nDurch die Verwendung von Merge-Request-Approvalrichtlinien und Scan-Ausführungsrichtlinien kannst du eine zusätzliche Kontrollebene in den Entwicklungsprozess einbauen. So kannst du sicherstellen, dass von Menschen geschriebener – oder anderweitig erstellter – Code automatisch gescannt wurde und dass Richtlinienverstöße die Zusammenarbeit zwischen Technik und AppSec fördern, wo sie am sinnvollsten ist.\n\n### Granulare Regeln in den Merge-Request-Approvalrichtlinien definieren \nUm noch einen Schritt weiter zu gehen, kannst du in den Merge-Request-Approvalrichtlinien granulare Regeln definieren, die auf den unten aufgeführten Filtern und Attributen basieren. Diese Regeln helfen dir dabei, herauszufinden, welche Sicherheitslücken am ehesten zu beheben sind und die Nadel im Heuhaufen zu finden:\n\n- **Status der Sicherheitslücke:** Sicherheitsrichtlinien können auf der Grundlage des Status einer Sicherheitslücke gezielt eingesetzt werden, wobei der Schwerpunkt oft auf neu entdeckten Sicherheitslücken liegt, die einer Triage bedürfen. Es ist auch möglich, Regeln zu erstellen, die auf zuvor entdeckten Sicherheitslücken mit einem bestimmten Schweregrad basieren, oder Sicherheitslücken einzuschließen/auszuschließen, wenn sie abgelehnt wurden.\n\n- **Branch:** Du kannst die Durchsetzung der Regeln auf bestimmte Branches beschränken, z. B. indem du die Durchsetzung auf den Standard-Branch kritischer Projekte oder auf alle geschützten Branches ausrichtest.\n\n- **Fix verfügbar:** Filtere die Ergebnisse von Abhängigkeitssuche und Container-Scanning heraus, für die kein Fix verfügbar ist. Diese hängen oft von Upstream-Änderungen durch Dritte ab und sind noch nicht verwertbar. Aus den Sicherheitslücken können Tickets erstellt und mit einem Fälligkeitsdatum versehen werden, damit sie behoben werden, sobald ein Fix verfügbar ist.\n\n- **Falsch positiv:** Wenn unsere GitLab-Scanner einen Fund als falsch positiv einstufen (bei Container-Scanning und Abhängigkeitssuche), markieren wir den Zustand der Sicherheitslücke. Die Sicherheitsrichtlinien können dies dann nutzen, um falsch positive Funde aus der Übersicht der Sicherheitsrichtlinien herauszufiltern, so dass die AppSec- und Entwicklungsteams diese ignorieren und den Code ungehindert zusammenführen können. Die Sicherheitslücken stehen weiterhin im Schwachstellenbericht zur Verfügung und können bei Bedarf genauer analysiert werden.\n\n- **Alter oder Service Level Agreement (SLA):** Manchmal können Sicherheitslücken mit geringerem Schweregrad von Unternehmen eine Zeit lang toleriert werden, sollten aber im Rahmen eines angemessenen SLA geplant und behoben werden. Mit Sicherheitsrichtlinien kannst du ein SLA auf der Grundlage des Schweregrads einer entdeckten Sicherheitslücke festlegen, z. B. dass mittelschwere Sicherheitslücken ohne Approvalpflicht für ein SLA von 60 Tagen zusammengeführt werden können (was in einem Follow-up-Ticket mit einem Fälligkeitsdatum behandelt werden kann). Wird jedoch eine Sicherheitslücke entdeckt, die das 60-Tage-SLA überschreitet, werden Merge Requests blockiert, bis die Sicherheitslücke behoben ist.\n\n![security-policies-rules-ds-all-filters](https://res.cloudinary.com/about-gitlab-com/image/upload/v1752175811/Blog/k0bror5vmcosg8jm4zi1.png)\n\n### Kritische Funde unternehmensweit priorisieren\nEin gängiger Ansatz zur Bewältigung großer Mengen von Sicherheitslücken ist es, klein anzufangen und die kritischsten Funde in deinem Unternehmen nach Prioritäten zu ordnen. Ein SLA für die Triage von Sicherheitslücken kann dir dabei helfen, indem du Regeln definierst, um Sicherheitslücken innerhalb eines bestimmten SLAs auf der Grundlage des Schweregrads der Schwachstelle zu beheben. Hier ein kurzes Beispiel für den Einsatz von Merge-Request-Approvalrichtlinien in GitLab, um für jeden Schweregrad einer Sicherheitslücke ein anderes SLA durchzusetzen. In diesem Fall werden Merge Requests bei einer schwerwiegenden Sicherheitslücke 30 Tage lang nicht blockiert, damit die Entwickler(innen) Zeit haben, das Problem innerhalb des SLA-Fensters zu beheben.\n\n\u003C!-- blank line -->\n\u003Cfigure class=\"video_container\">\n  \u003Ciframe src=\"https://www.youtube.com/embed/cOsAaLXdV2k\" frameborder=\"0\" allowfullscreen=\"true\"> \u003C/iframe>\n\u003C/figure>\n\u003C!-- blank line -->\n\n### Aufgabentrennung sicherstellen\n\nSicherheitsrichtlinien können auf verschiedene Weise verwaltet werden. Am besten ist es jedoch, wenn sie in einem isolierten GitLab-Projekt verwaltet werden, das eine Aufgabentrennung zwischen Sicherheitsexpert(inn)en und Entwicklungsteams gewährleistet. Die Richtlinien werden in YAML gespeichert. Dieser Richtlinien-als-Code-Ansatz stärkt dein Sicherheitsteam und bietet viele Vorteile. Dazu gehören ein Git-Verlauf aller Änderungen an den Richtlinien, um die Sichtbarkeit zu erhöhen, Versionskontrolle, um problematische Änderungen leichter rückgängig machen zu können, Kontrolle und die Pflicht, alle Richtlinienänderungen zu genehmigen (falls erforderlich), Überprüfbarkeit durch GitLab Audit Events und konkrete Kontrollen, die den Prüfer(inne)n als Nachweis vorgelegt werden können.\n\n![gitlab security-policies policy-yml](https://res.cloudinary.com/about-gitlab-com/image/upload/v1752175821/Blog/bqfig4ufupuitbarasuj.png)\n\n## Alles miteinander kombinieren\nDie Bewältigung der ständig wachsenden Zahl von Sicherheitslücken erfordert einen präzisen Ansatz, der ein ausgewogenes Verhältnis zwischen gründlichem Scannen und effizienter Priorisierung und Behebung herstellt. Die Sicherheitsrichtlinien von GitLab bieten eine leistungsstarke Lösung, die Zusammenarbeit ermöglicht, Flexibilität bei der Definition von benutzerdefinierten Regeln bietet und eine Möglichkeit zur präzisen Umsetzung von Geschäftsanforderungen und des Compliance Frameworks darstellt. Durch die Nutzung der Sicherheitstools von GitLab und die Anwendung von benutzerdefinierten Filtern und Attributen können Unternehmen die Verwaltung von Sicherheitslücken optimieren und ihre Bemühungen auf die kritischsten Risiken konzentrieren, um so ihre allgemeine Sicherheitslage zu verbessern und die Anforderungen externer Stellen zu erfüllen. Und auch wenn die Angst vor KI-generiertem Code wächst, bleiben die drei Säulen der Sicherheit (Menschen, Prozesse und Technologie) bestehen. Durch die Integration von Sicherheitsrichtlinien in deine Geschäftsprozesse kannst du dein Unternehmen vor solchen Risiken schützen.\n\nDie DevSecOps-Plattform von GitLab bietet nicht nur Sicherheitsrichtlinien zur Durchsetzung von Richtlinen als Code im großen Maßstab, sondern auch robuste Sicherheitstools. In unserem kürzlich erschienenen [Globalen DevSecOps-Bericht 2023](https://learn.gitlab.com/devsecops-survey-2023/) (nur in englischer Sprache verfügbar) gaben 57 % der Sicherheitsexpert(inn)en an, dass sie sechs oder mehr Tools für die Softwareentwicklung verwenden und 69 % gaben an, dass sie ihre Toolchain konsolidieren wollen. Die Konsolidierung von Tools ist für viele CISOs ein wichtiges Thema, und GitLab hilft dabei, den Toolchain-Wildwuchs zu reduzieren. Wir bieten die wichtigsten Lösungen für Sicherheitsscans an: statische Anwendungssicherheitstests (auch für Infrastructure as Code), Erkennung von Geheimnissen, dynamische Anwendungssicherheitstests (auch für APIs), Abhängigkeitssuche und API-Sicherheit. Außerdem ermöglichen wir AppSec-Teams die Verwaltung von Sicherheitslücken mit dynamischen Sicherheitslückenberichten. Und wir schließen den Kreis der Compliance mit Compliance Frameworks, Compliance-Berichten und Audit-Ereignissen.\n\nErfahre mehr darüber, wie du die [Anwendungssicherheit](https://docs.gitlab.com/ee/user/application_security/#use-security-scanning-tools-with-merge-request-pipelines) (nur in englischer Sprache verfügbar) mit GitLab verwalten kannst.\n\n> **Als Nächstes:** Josh Lemos, CISO von GitLab, erklärt, wie du [auf einige häufige Frustrationen im Bereich Sicherheit eingehst](https://about.gitlab.com/the-source/security/security-its-more-than-culture-addressing-the-root-cause-of-common-security/).\n","enterprise-scale-security-and-compliance-policy-management-in-the-ai-era","content:de-de:the-source:security:enterprise-scale-security-and-compliance-policy-management-in-the-ai-era:index.yml","de-de/the-source/security/enterprise-scale-security-and-compliance-policy-management-in-the-ai-era/index.yml","de-de/the-source/security/enterprise-scale-security-and-compliance-policy-management-in-the-ai-era/index",{"_path":660,"_dir":30,"_draft":6,"_partial":6,"_locale":7,"config":661,"seo":663,"content":668,"type":478,"category":30,"slug":676,"_id":677,"_type":32,"title":664,"_source":33,"_file":678,"_stem":679,"_extension":36,"date":669,"description":665,"timeToRead":670,"heroImage":666,"keyTakeaways":671,"articleBody":675},"/de-de/the-source/security/how-to-strengthen-security-by-applying-devsecops-principles",{"layout":5,"template":461,"articleType":462,"author":662,"featured":6,"isHighlighted":6,"authorName":449},"ncregan",{"title":664,"description":665,"ogImage":666,"config":667},"So erhöhst du die Sicherheit durch Anwendung der DevSecOps-Prinzipien","Erfahre, wie du die DevSecOps-Prinzipien noch heute anwenden kannst und entdecke die Leistungsfähigkeit von DevSecOps.","https://res.cloudinary.com/about-gitlab-com/image/upload/v1751464433/bdwagz0bt5bpgghjkout.png",{"ignoreTitleCharLimit":13},{"title":664,"date":669,"description":665,"timeToRead":670,"heroImage":666,"keyTakeaways":671,"articleBody":675},"2023-02-23","Lesezeit: 4 Min.",[672,673,674],"DevSecOps integriert Sicherheit in den SDLC und sorgt so für sichere Apps, ohne die Bereitstellung zu verzögern.","Die Automatisierung durch DevSecOps erhöht die Sicherheit und optimiert die Erkennung und Abwehr von Bedrohungen.","Die Zusammenarbeit durch DevSecOps fördert einen einheitlichen Ansatz für eine sichere und schnelle Softwareentwicklung.","Durch die Beachtung der DevSecOps-Prinzipien können Unternehmen sicherstellen, dass ihre Anwendungen vor böswilligen Akteuren sicher sind und gleichzeitig schnell und effizient Werte liefern. In diesem Artikel werfen wir einen detaillierten Blick auf die DevSecOps-Prinzipien und darauf, wie sie Unternehmen helfen können, in Sachen Sicherheit einen Schritt voraus zu sein. Legen wir los.\n\n## Was ist DevSecOps?\n[DevSecOps](/topics/devsecops/) ist ein Ansatz zur Softwareentwicklung, der die drei Prinzipien Entwicklung, Sicherheit und Betrieb kombiniert. Dadurch können Teams ein sicheres und zuverlässiges Produkt erstellen und gleichzeitig schnell und effizient einen Mehrwert liefern. Die erfolgreiche Umsetzung von DevSecOps beinhaltet kontinuierliche Integration, Automatisierung und Tests mit dem Ziel, die Markteinführungszeit zu verkürzen, ohne die Qualität oder Sicherheit zu beeinträchtigen.\n\n## DevSecOps-Prinzipien: Ein Überblick\nMithilfe der [DevSecOps-Prinzipien (Blogbeitrag nur in englischer Sprache verfügbar)](/blog/4-must-know-devops-principles/) kann ein Entwicklungsteam durch integrierte Sicherheitstests in kürzester Zeit sichere und zuverlässige Anwendungen entwickeln. Mit einem DevSecOps-Ansatz beziehen die Teams die Sicherheit in den Software-Entwicklungsprozess (SDLC) ein – vom ersten Entwurf bis zur kontinuierlichen Lieferung und Bereitstellung. Dadurch wird verhindert, dass böswillige Akteure Sicherheitslücken ausnutzen und das Gesamtrisiko von Cyberangriffen verringert.\n\nZu den DevSecOps-Prinzipien gehören:\n\n### Automatisierung und Integration\nAutomatisierung und Integration sind wesentliche Bestandteile von DevSecOps. Die Automatisierung von Sicherheitsprozessen hilft bei der Entwicklung sicherer und zuverlässiger Anwendungen und verringert gleichzeitig das Risiko zukünftiger böswilliger Angriffe. Du kannst Sicherheitsmaßnahmen an mehreren Punkten des Entwicklungszyklus einrichten und ausführen, um die Sicherheitspraktiken durch die Anwendung von kontinuierlicher Sicherheit zu vereinfachen und zu optimieren.\n\n### Kontinuierliche Lieferung und Bereitstellung\nDie kontinuierliche Lieferung und Bereitstellung ist ein weiterer Prozess, mit dem Teams schnell auf potenzielle Bedrohungen reagieren und ihre Software-Lieferkette vor böswilligen Akteuren schützen können. Die [kontinuierliche Bereitstellung von Anwendungen mithilfe automatisierter Prozesse (Blogbeitrag nur in englischer Sprache verfügbar)](/blog/cd-solution-overview/) ermöglicht es, neue Funktionen und Produkte schnell zu entwickeln und gleichzeitig die Sicherheit und hohe Qualität der Anwendungen zu gewährleisten.\n\n### Ein kollaborativer Sicherheitsansatz\nSicherheit ist ein grundlegender Bestandteil von DevSecOps. Um sicherzustellen, dass die Anwendungen sicher und zuverlässig bleiben, ist ein [hochgradig kooperativer Ansatz](/topics/version-control/software-team-collaboration/) mit kontinuierlichen und mehrfachen Sicherheitsprüfungen erforderlich. Alle am Entwicklungsprozess beteiligten Personen müssen in den Sicherheitsprozess einbezogen werden.\n\nSicherheitsteams müssen mit Entwickler(inne)n zusammenarbeiten, um sicherzustellen, dass Anwendungen mit [geeigneten Sicherheitskontrollen](/topics/devsecops/devsecops-security-checklist/) und minimalen Sicherheitslücken entwickelt werden. Gleichzeitig muss der Betrieb mit den Sicherheitsteams zusammenarbeiten, damit die Anwendungen sicher eingesetzt und überwacht werden können.\n\n### Sicherheit in jeder Phase des SDLC\nDie Einbeziehung von Sicherheitsaspekten in jede Phase des SDLC gewährleistet die effiziente Entwicklung sicherer Anwendungen, ohne die Qualität zu beeinträchtigen. Es ist wichtig, dass [jede Phase des Lebenszyklus (Blogbeitrag nur in englischer Sprache verfügbar)](/blog/top-10-gitlab-hacks/) abgedeckt wird, vom Entwurf über die Entwicklung bis hin zur Bereitstellung.\n\nDamit der Prozess effektiv ist, müssen Entwickler(innen) Anwendungen mit geeigneten Sicherheitskontrollen entwerfen, und die IT-Betriebsteams sollten sie sicher bereitstellen und überwachen.\n\n### Proaktive Überwachungs- und Reaktionsstrategien\nProaktive Überwachungs- und Reaktionsstrategien sind für die Sicherheit von Anwendungen während ihrer gesamten Lebensdauer unerlässlich. Die [Überwachung (Blogbeitrag nur in englischer Sprache verfügbar)](/blog/working-with-performance-metrics/) erfolgt durch den Einsatz automatischer Tools, die potenzielle Sicherheitslücken erkennen und die Teams warnen, wenn sie auftreten.\n\nAuf diese Weise werden Risiken minimiert und die Einheitlichkeit im gesamten Unternehmen sichergestellt. Durch den Einsatz einer umfassenden Reaktionsstrategie können Probleme erkannt und gelöst werden, bevor sie zu Sicherheitsrisiken werden.\n\n## Vorteile der Implementierung von DevSecOps\nDie Einführung von DevSecOps bietet Unternehmen zahlreiche Vorteile:\n1. Durch die Bereitstellung sicherer Anwendungen wird das Vertrauen der Kund(inn)en gestärkt. \n2. Es verhindert, dass böswillige Akteure Sicherheitslücken im System ausnutzen und verbessert die Sicherheit der Systeme.\n3. Mit der DevSecOps-Methode können Teams schnell Werte liefern und gleichzeitig ein Höchstmaß an Sicherheit gewährleisten.\n4. Durch die Integration von Sicherheitsaspekten in die Softwareentwicklungspipeline – vom Entwurf bis zur Bereitstellung – können Teams potenzielle Risiken frühzeitig erkennen und angehen und so das Risiko böswilliger Angriffe verringern.\n5. DevSecOps hilft Unternehmen, potenziellen Bedrohungen einen Schritt voraus zu sein und auf ihren Märkten wettbewerbsfähig zu bleiben.\n\nDie [Implementierung von DevSecOps (Blogbeitrag nur in englischer Sprache verfügbar)](/blog/whats-next-for-devsecops/) ist unerlässlich für Unternehmen, die ihre Systeme vor böswilligen Angriffen schützen und gleichzeitig schnell und effizient einen Mehrwert schaffen wollen. Außerdem wird durch die Integration der Sicherheit in den SDLC sichergestellt, dass alle neuen Anwendungen von Anfang an sicher sind. Die Einführung einer DevSecOps-Kultur und eines DevSecOps-Ansatzes maximiert die Gesamteffizienz und die Qualität des Software-Entwicklungsprozesses.","how-to-strengthen-security-by-applying-devsecops-principles","content:de-de:the-source:security:how-to-strengthen-security-by-applying-devsecops-principles:index.yml","de-de/the-source/security/how-to-strengthen-security-by-applying-devsecops-principles/index.yml","de-de/the-source/security/how-to-strengthen-security-by-applying-devsecops-principles/index",[458,483,521,541,561,581],{"ai":368,"platform":375,"security":10},1758521519168]