AppSec-ში ავტომატური შეკეთება არის დაუცველობების ავტომატური აღმოჩენისა და გამოსწორების პროცესი უშუალოდ შემუშავების სამუშაო პროცესში, ხელით ჩარევის გარეშე. თანამედროვე პროგრამული უზრუნველყოფის გუნდებისთვის ეს აშკარა შემდეგ ნაბიჯად ჟღერს. შეკვეთების დაგროვება იზრდება, გამოშვების ციკლები მცირდება და ცოტა ორგანიზაციას შეუძლია ყოველ ჯერზე რესურსების გადამუშავება. SAST აღმოჩენა, დამოკიდებულების პრობლემა, საიდუმლო გაჟონვა ან IaC არასწორი კონფიგურაცია სრულად ხელით გასწორების რიგში.
თუმცა, არსებობს ერთი ხაფანგი. გუნდებს სურთ დაუცველობის გამოსწორება უფრო სწრაფი, მაგრამ მათ არ სურთ ავტომატიზაცია, რომელიც ჩუმად შემოიტანს რეგრესიებს, არღვევს დამოკიდებულებებს ან ქმნის არასტაბილურობას CI/CDეს დაძაბულობა ახლა აპლიკაციების უსაფრთხოების ერთ-ერთ ცენტრალურ პრობლემას წარმოადგენს. OWASP აშკარად ეპყრობა CI/CD როგორც უსაფრთხოების სფერო საკუთარი ძირითადი რისკის კატეგორიებით, მაშინ როდესაც NIST-ის უსაფრთხო პროგრამული უზრუნველყოფის შემუშავების ჩარჩო ცხადყოფს, რომ უსაფრთხო განვითარების პრაქტიკები უნდა იყოს ინტეგრირებული SDLC ვიდრე ბოლოს ჭანჭიკით იყო მიმაგრებული.
Ამიტომაც ავტომატური შეკეთება ეს არ არის მხოლოდ პროდუქტის ფუნქცია. ეს არის ოპერაციული მოდელი. ცუდად შესრულებული, ის ქმნის ხმაურს, რისკს და არარეგულარულ ვერსიებს. კარგად შესრულებული, ის ამცირებს უფსკრულს აღმოჩენასა და გამოსწორებას შორის, ამცირებს გამოსწორების დროს და ეხმარება უსაფრთხოებას DevOps-ის სიჩქარესთან შესაბამისობაში მოყვანაში. ამ სახელმძღვანელოში განვიხილავთ, თუ რას ნიშნავს სინამდვილეში ავტომატური შეკეთება. AppSec, სად ვერ ხერხდება ის, როგორი უნდა იყოს უსაფრთხო ავტომატიზირებული გამოსწორება და როგორ განვახორციელოთ ის ისე, რომ დეველოპერები რეალურად ენდობოდნენ.
რა არის Autofix AppSec-ში?
საბაზო დონეზე ავტომატური შეკეთება ნიშნავს, რომ პროგრამული უზრუნველყოფა უსაფრთხოების პრობლემის იდენტიფიცირებას არ გულისხმობს. ის გვთავაზობს, ქმნის ან იყენებს გამოსასწორებელ ზომებს. სხვა სიტყვებით რომ ვთქვათ, ინსტრუმენტი „აი, პრობლემა“-დან „აი, გამოსავალი“-ზე გადადის.
ეს მარტივად ჟღერს, მაგრამ პრაქტიკაში ის მოიცავს რამდენიმე ძალიან განსხვავებულ სამუშაო პროცესს.
In SASTავტომატური შეკეთება, როგორც წესი, ნიშნავს კოდის დონის ცვლილებების გენერირებას ისეთი დაუცველობებისთვის, როგორიცაა SQL ინექცია, საიტებს შორის სკრიპტირება, დესერიალიზაციის არაუსაფრთხო ნიმუშები, შეყვანის სუსტი ვალიდაცია ან დაუცველი ავტორიზაციის ლოგიკა. SCA, ეს ჩვეულებრივ ნიშნავს დამოკიდებულების განახლებების რეკომენდაციას ან გამოყენებას, უფრო უსაფრთხო ვერსიების დამაგრებას ან შექმნას pull requests რომლებიც პაკეტებს გადააქვთ დაპატენტებულ ვერსიებში. საიდუმლოებები უსაფრთხოებაავტომატური შეკეთება შეიძლება ნიშნავდეს ავტორიზაციის მონაცემების გაუქმებას და მონაცვლეობას და არა მხოლოდ მათ მონიშვნას. IaC, ეს შეიძლება ნიშნავდეს დაუცველი Terraform-ის, Kubernetes-ის ან ღრუბლოვანი კონფიგურაციის შაბლონების უფრო უსაფრთხო ნაგულისხმევ პარამეტრებად გადაწერას.
მნიშვნელოვანი განსხვავება შემდეგია: ავტომატური შესწორება არ არის იგივე, რაც მინიშნება. ბევრ უსაფრთხოების ინსტრუმენტს შეუძლია ზოგადი კორექტირების შეთავაზება. უფრო ნაკლებს შეუძლია დეველოპერისთვის მზა ცვლილების გენერირება. კიდევ უფრო ნაკლებს შეუძლია ამ კორექტირების გაშვება ფაქტობრივი მიწოდების სამუშაო პროცესში, მისი დადასტურება და დეველოპერისთვის წყაროს კონტროლის გადახედვადი ცვლილების სახით წარდგენა.
ეს განსხვავება მნიშვნელოვანია, რადგან თანამედროვე საინჟინრო გუნდები არ მუშაობენ PDF ფაილებსა და ბილეთებში. ისინი მუშაობენ pull requests, პოლიტიკა, შემოწმებები და pipelines.
რატომ არ არის ტრადიციული რემედიაცია მასშტაბური
ავტომატური შეკეთების არგუმენტები მტკივნეული რეალობით იწყება: ტრადიციული გამოსწორების პროცესები თანამედროვე პროგრამული უზრუნველყოფის მიწოდებასთან შესაბამისობაში არ მოდის.
ორგანიზაციების უმეტესობას უკვე აქვს საკმარისი სკანირება. მათ არ აქვთ საკმარისი გარჩევადობა. სტატიკური ანალიზი, დამოკიდებულების სკანირება, საიდუმლოებების აღმოჩენა და ინფრასტრუქტურის შემოწმება მუდმივად იძლევა დასკვნებს. ამასობაში, საინჟინრო გუნდები ზეწოლის ქვეშ არიან, რათა უზრუნველყონ ფუნქციების მიწოდება, შეინარჩუნონ დაბალი ვადები და თავიდან აიცილონ წარმოების დესტაბილიზაცია.
შედეგად, აღმოჩენასა და მოქმედებას შორის უფსკრული ჩნდება.
პირველ რიგში, არსებობს მარტივი შეტყობინებების მოცულობა. რაც უფრო მოწიფული ხდება AppSec პროგრამა, მით უფრო მეტ აღმოჩენას წარმოქმნის ის. ეს ყოველთვის არ აუმჯობესებს უსაფრთხოებას. ბევრ გარემოში ეს უბრალოდ ქმნის დაგროვილ ინფორმაციას. Xygeni-ის პროდუქტის მასალები ამას ხმაურისა და პრიორიტეტულობის პრობლემად ასახელებს და ეს ჩარჩო უფრო ფართო ინდუსტრიულ რეალობას შეესაბამება: პრიორიტეტულობის და არა მხოლოდ აღმოჩენის პრობლემაა ის, რაც ბევრ პროგრამას უჭირს.
მეორეც, ხელით გამოსწორება თავისი დიზაინით ნელია. დეველოპერმა უნდა წაიკითხოს პრობლემა, გაანალიზოს სკანერის გამომავალი ინფორმაცია, საჭიროების შემთხვევაში, რეპროდუცირება მოახდინოს პრობლემაზე, შეიმუშაოს გამოსწორების გზა, დანერგოს იგი, ჩაატაროს ტესტები, გახსნას pull requestდა დაელოდეთ განხილვას. ეს შეიძლება მისაღები იყოს ერთი კრიტიკული პრობლემისთვის. ეს მიუღებელია ასობით საშუალო სიმძიმის აღმოჩენის, დამოკიდებულების განმეორებადი განახლებების ან მრავალ საცავში განმეორებითი საიდუმლო გაჟონვის შემთხვევაში.
მესამე, უსაფრთხოება და ინჟინერია ხშირად სხვადასხვა შედეგისთვის ოპტიმიზაციას ახდენს. უსაფრთხოება რისკის შემცირებას ითხოვს. ინჟინერია კი ცვლილებების უსაფრთხოდ და პროგნოზირებად დანერგვას ითხოვს. ეს განსხვავება მართვადია, როდესაც დასკვნების ნაკადი მცირეა. ის საზიანო ხდება, როდესაც გუნდები პრობლემებით ივსებიან და არ არსებობს მექანიზმი, რომელიც დადასტურებულ დასკვნებს უსაფრთხო, დაბალი ხახუნის მქონე გამოსწორებად აქცევს.
სწორედ აქ იწყება ავტომატიზაციის აუცილებლობის გამოჩენა. და მაინც, მხოლოდ აუცილებლობა ავტომატიზაციას უსაფრთხოს არ ხდის.
ნაივური ავტოფიქსის პრობლემა
ყველა ავტომატური შეკეთება კარგი ავტომატური შეკეთება არ არის. სინამდვილეში, უსაფრთხოების ავტომატიზაციის მიმართ დეველოპერების მიერ გამოთქმული მრავალი წინააღმდეგობა არ არის თავად ავტომატიზაციის წინააღმდეგი. ისინი ცუდი ავტომატიზაციის წინააღმდეგი არიან.
ნაივურ ავტოშეკეთების ძრავას, როგორც წესი, ოთხი პრობლემიდან ერთ-ერთი აქვს.
პირველი ის არის, რომ ის ყველა პრობლემას თანაბრად გამოსწორებადად მიიჩნევს. სკანერი ხედავს დაუცველ დამოკიდებულებას და უბრალოდ გვთავაზობს შემდეგ გასწორებულ ვერსიას. კოდის ძრავა ხედავს სახიფათო ნიმუშს და ცვლის მას ჩანაცვლებით. ეს შეიძლება იმუშაოს ზოგიერთ მარტივ შემთხვევაში. ის სწრაფად იშლება რეალურ სისტემებში, სადაც მნიშვნელოვანია კოდის ბაზა, არქიტექტურა, გაშვების დრო და დამოკიდებულების გრაფიკი.
მეორე ის არის, რომ ის უგულებელყოფს შესრულების კონტექსტს. გამოსწორება, რომელიც იზოლირებულად სწორად გამოიყურება, შეიძლება იყოს არარელევანტური, არასაკმარისი ან სარისკო, როდესაც გამოიყენება რეალური კოდის ბილიკებზე. ეს არის ერთ-ერთი მიზეზი, რის გამოც ექსპლუატაციის სიგნალები ასე მნიშვნელოვანია. FIRST-ის EPSS არსებობს წინასწარ.cisმხოლოდ იმიტომ, რომ მხოლოდ სიმძიმე არ არის სანდო მაჩვენებელი იმისა, სავარაუდოა თუ არა დაუცველობის ექსპლუატაცია უახლოეს მომავალში. EPSS უზრუნველყოფს CVE-ების ექსპლუატაციის აქტივობის ყოველდღიურ ალბათობის შეფასებას, რაც გუნდებს ეხმარება შეზღუდული გამოსწორების შესაძლებლობები ფოკუსირება მოახდინონ იმაზე, თუ რა უფრო სავარაუდოა თავდასხმის ქვეშ.
მესამე ის არის, რომ ნაივური ავტოფიქსი უგულებელყოფს ცვლილების რისკს. ეს განსაკუთრებით საშიშია SCAდამოკიდებულების განახლებამ შესაძლოა CVE აღმოფხვრას და მაინც გამოიწვიოს API შეუთავსებლობა, წაშლილი მეთოდები, კლასების სახელის შეცვლა, შეცვლილი კონტრაქტები ან გაშვების დროს ქცევის დახვეწილი ცვლილებები.
მეოთხე არის ზედმეტად ავტომატიზაცია. როდესაც ინსტრუმენტი ხსნის დაბალი ღირებულების მქონე ინფორმაციის ნაკადს pull requests, რომელთაგან ბევრი ვერ ახერხებს ტესტებს ან ქმნის შერწყმის ხახუნს, დეველოპერები სწავლობენ მის იგნორირებას. ეს არ არის გამოსწორების აჩქარება. ეს არის გამოსწორების სპამი.
ამგვარად, სწორი კითხვა არ არის, უნდა ავტომატიზირდეს თუ არა გუნდებმა რემედიაცია. სწორი კითხვაა, თუ როგორი ავტომატიზაცია ამცირებს რისკს ოპერაციული სირთულეების გაზრდის გარეშე.
ნდობის რეალური პრობლემაა გარდამტეხი ცვლილებები
როდესაც დეველოპერები ამბობენ, რომ არ ენდობიან ავტომატურ შეკეთებას, ისინი ხშირად ერთ ძალიან კონკრეტულ რამეს გულისხმობენ: ისინი არ ენდობიან მას, რომ რამე არ დააზიანოს.
ნდობის პრობლემა ყველაზე თვალსაჩინოა დამოკიდებულების აღმოფხვრაში.
შესაძლოა, დაუცველ პაკეტს ჰქონდეს პატჩირებული ვერსია, მაგრამ ეს არ ნიშნავს, რომ განახლება უსაფრთხოა. პატჩირებულმა ვერსიამ შეიძლება წაშალოს თქვენი აპლიკაციის მიერ გამოყენებული მეთოდი. შესაძლოა, API-ს სახელი შეეცვალოს. შესაძლოა, ტიპის კონტრაქტი გაამკაცროს. შესაძლოა, ქცევა ისე შეცვალოს, რომ ერთეულ ტესტებს წარმატებით გაიაროს, მაგრამ წარმოების რეგრესიები გამოიწვიოს. ბევრ გუნდში, გამოსწორების რეალური ღირებულება არ არის პატჩის გამოყენება. ის აფეთქების რადიუსის გამოკვლევაა.
განვიხილოთ Java-ს მარტივი მაგალითი. კოდის ბაზა დამოკიდებულია ბიბლიოთეკაზე, სადაც 1.x ვერსიაში არსებობს გავრცელებული მეთოდი, მაგრამ 2.x ვერსიაში ამოღებულია.
// Before upgrade
MyService service = new MyService();
service.foo();
განახლების შემდეგ, foo() აღარ არსებობს. დაუცველობა შეიძლება გაქრეს, მაგრამ კონსტრუქცია დაზიანებულია.
სწორედ ამიტომ, „უბრალოდ განახლება გამოსწორებულ ვერსიაზე“ არ არის საინჟინრო სტრატეგია. ეს არის რისკი.
OWASP-ები CI/CD ხელმძღვანელობა აქ აქტუალურია, რადგან თანამედროვე მიწოდების pipelines წარმოადგენს როგორც აჩქარების მექანიზმებს, ასევე შეტევის ზედაპირებს. უსაფრთხოების კონტროლი, რომელიც ქმნის არასტაბილურ ცვლილებებს ან უკონტროლო pipeline ქცევა ერთი პრობლემის გადაჭრას მეორის შექმნით. CI/CD დაცვას სჭირდება ნაკადის კონტროლი, ვალიდაცია და პოლიტიკის აღსრულება და არა მხოლოდ სწრაფი ცვლილებების ინექცია.
უსაფრთხო ავტომატურმა შეკეთებამ ეს რეალობა უნდა გაითვალისწინოს. მან არა მხოლოდ უნდა გაიგოს, გამოსწორებადია თუ არა დაუცველობა, არამედ შეიძლება თუ არა ამ შესწორების დანერგვა იმ პროგრამული უზრუნველყოფის სასიცოცხლო ციკლის დარღვევის გარეშე, რომლის დაცვაც მას სჭირდება.
როგორი უნდა იყოს უსაფრთხო ავტოშეკეთება
უსაფრთხო ავტოშეკეთება არ არის „ცვლილებების ავტომატური გენერირება“. უსაფრთხო ავტოშეკეთება არის კონტროლირებადი ავტომატური რემედიაცია.
ეს ხუთ რამეს ნიშნავს.
პირველ რიგში, შესწორებები კონტექსტიდან გამომდინარე უნდა იყოს. უსაფრთხოების შემოთავაზება, რომელიც უგულებელყოფს მიმდებარე კოდს, ჩარჩო კონვენციებს, მონაცემთა ნაკადს ან დამოკიდებულების ქცევას, საკმარისი არ არის. შესწორება უნდა შეესაბამებოდეს აპლიკაციას და არა მხოლოდ დაუცველობის კლასს.
მეორეც, შესწორებები რისკების გათვალისწინებით უნდა იყოს გათვალისწინებული. სწორედ აქ არის მნიშვნელოვანი გამოსწორების რისკების ანალიზი. კარგ ავტოშესწორების სისტემას ცვლილების შეთავაზებამდე უნდა შეეძლოს ძირითადი საინჟინრო კითხვაზე პასუხის გაცემა: რა არის ალბათობა, რომ ეს გამოსწორება შეიტანს? კრიტიკული ცვლილებები?
მესამე, გამოსწორებები პრიორიტეტულად უნდა იქნას მინიჭებული. საუკეთესო ავტომატური გამოსწორების პროგრამები ყველაფრის ერთდროულად გამოსწორებას არ ცდილობენ. ისინი გამოსწორებას ექსპლუატაციის შესაძლებლობასთან, ხელმისაწვდომობასთან და ოპერაციულ გავლენასთან აკავშირებენ. ეს შეესაბამება იმას, თუ როგორ ვითარდება უფრო ფართოდ განვითარებული AppSec პროგრამები. CISA-ს ცნობილი ექსპლუატირებული დაუცველობების კატალოგი წინასწარ არსებობსcisორგანიზაციებს, რათა დაეხმაროს ექსპლუატაციის მტკიცებულებების ჩართვას რემედიაციის პროცესშიcisიონები, არა მხოლოდ სიმძიმის შეფასება.
მეოთხე, ავტომატური შეკეთება უნდა შესრულდეს რეალური მიწოდების სამუშაო პროცესებში. თუ შესწორების მექანიზმი ვერ მუშაობს pull requests, შემოწმებები, პოლიტიკა და ტესტები, ეს არ შეესაბამება იმას, თუ როგორ აწვდიან თანამედროვე გუნდები პროგრამულ უზრუნველყოფას.
მეხუთე, დეველოპერებმა კონტროლი უნდა შეინარჩუნონ. დეველოპერის მიერ დამტკიცებული ცვლილებები ავტომატური შესწორების სისუსტე არ არის. ისინი წარმოადგენენ მექანიზმს, რომელიც ავტომატიზაციას სანდოს ხდის წარმოების ინჟინერიის გარემოში.
სხვა სიტყვებით რომ ვთქვათ, უსაფრთხო აღდგენა მოითხოვს კონტროლს და არა მხოლოდ ავტომატიზაციას.
ნაივური ავტოფიქსი უსაფრთხო ავტოფიქსის წინააღმდეგ
ქვემოთ მოცემულია პრაქტიკული განსხვავება სამუშაოს შემქმნელ ავტომატიზაციასა და სამუშაოს მოხსნის ავტომატიზაციას შორის.
| ასპექტის | ნაივური ავტოშესწორება | უსაფრთხო ავტოშეკეთება |
|---|---|---|
| გამოსწორების სტრატეგია | დაუცველობის აღმოჩენისთანავე იყენებს ზოგად შესწორებებს ან განახლებებს | კოდის, დამოკიდებულების ქცევისა და სამუშაო პროცესის ვალიდაციის საფუძველზე კონტექსტის გათვალისწინებით შექმნილი შესწორებების გენერირება. |
| დამოკიდებულების განახლებები | გირჩევთ შემდეგ პატჩირებულ ვერსიას ცვლილების გავლენის ანალიზის გარეშე | აფასებს განახლების გზებს და ამოწმებს შეცდომით გამოსწორების შეთავაზებამდე ცვლილებებს |
| პრიორიტეტების | მოქმედებს მხოლოდ სიმძიმეზე | აერთიანებს სიმძიმეს ექსპლუატაციასთან, ხელმისაწვდომობასთან და ოპერაციულ ზემოქმედებასთან |
| Pipeline უსაფრთხოება | შეიძლება გახსნას PR-ები, რომლებიც ვერ ახერხებენ აწყობას ან ტესტებს | ამოწმებს შესწორებებს CI/CD ჩეკები და მიმოხილვის კარიბჭეები |
| დეველოპერის როლი | დეველოპერები ავტომატიზაციის ნარჩენებს ასუფთავებენ | დეველოპერები განიხილავენ უსაფრთხო, გაერთიანებისთვის მზა გამოსწორების წინადადებებს |
| შედეგი | მეტი ხმაური, მეტი რეგრესია, დაბალი ნდობა | უფრო სწრაფი გამოსწორება, ნაკლები რეგრესიები, უფრო მაღალი ადაპტაცია |
თუ ამ მაგიდიდან ერთი რამის ამოხსნა გსურთ, ეს ასეთია: ავტომატური შესწორების ხარისხი განისაზღვრება მისი კონტექსტისა და მართვის საშუალებების ხარისხით..
როგორ მუშაობს ავტომატური შეკეთება თანამედროვე DevSecOps-ში Pipeline
ზრდასრულ გარემოში, ავტომატური შეკეთება არ არის ერთჯერადი მოქმედება. ეს არის სტრუქტურირებული გასწორების სამუშაო პროცესი, რომელიც ინტეგრირებულია CI/CD.
ხელით, გათიშული შესწორებების ნაცვლად, თანამედროვე pipelines მიჰყვება უწყვეტ ნაკადს:

როგორ მუშაობს ავტომატური შეკეთება თანამედროვე DevSecOps-ში Pipeline
ზრდასრულ გარემოში, ავტომატური შეკეთება არ არის ერთჯერადი მოქმედება. ეს არის სტრუქტურირებული გასწორების სამუშაო პროცესი, რომელიც ინტეგრირებულია CI/CD.
ხელით, გათიშული შესწორებების ნაცვლად, თანამედროვე pipelines მიჰყვება უწყვეტ ნაკადს:
ეტაპობრივი ავტომატური შესწორების სამუშაო პროცესი
- გამოვლენა
საცავები, pull requests, კონტეინერები, ან IaC არტეფაქტები სკანირდება გამოყენებით SAST, SCA, საიდუმლოებები ან ინფრასტრუქტურის შემოწმებები. - პრიორიტეტების
ყველა დაუცველობას თანაბრად არ ეპყრობიან. ავტომატური შეკეთების სისტემები პრიორიტეტს ანიჭებენ შემდეგს:- ხელმისაწვდომობის ანალიზი
- ექსპლუატაციის სიგნალები, როგორიცაა EPSS
- ცნობილი ექსპლუატირებული დაუცველობები (KEV)
- განლაგების კონტექსტი
- გენერაციის შესწორება
სისტემა პრობლემის ტიპის მიხედვით წარმოქმნის გამოსასწორებელ მოქმედებებს:- კოდის შესწორებები SAST მოწყვლადი
- დამოკიდებულების განახლებები SCA
- საიდუმლო გაუქმება და როტაცია
- IaC კონფიგურაციის კორექცია
- Pull Request შექმნა
შესწორებები შეფუთულია დეველოპერებისთვის განკუთვნილ სამუშაო პროცესებში, როგორც წესი, როგორც pull requests ერთად:- კოდის განსხვავებები
- კონტექსტი და დასაბუთება
- შემოთავაზებული ცვლილებები
- ვალიდაცია CI/CD
გაერთიანებამდე, შესწორებები ავტომატურად მოწმდება შემდეგი გზით:- განყოფილების და ინტეგრაციის ტესტები
- აწყობის ჩეკები
- უსაფრთხოების პოლიტიკა
- დეველოპერის დამტკიცება და შერწყმა
დეველოპერები განიხილავენ, ამტკიცებენ ან უარყოფენ ცვლილებებს წარმოებაში გაერთიანებამდე.
შედეგად, ავტომატური შეკეთება არ გვერდს უვლის განვითარების სასიცოცხლო ციკლს. ის მის შიგნით მუშაობს.
ის შეუფერხებლად ინტეგრირდება ისეთ პლატფორმებთან, როგორიცაა GitHub, GitLab და Azure DevOps, რაც უზრუნველყოფს, რომ დაუცველობის გამოსწორება მიწოდების სამუშაო პროცესის ნაწილი ხდება და არა ცალკე პროცესი.
სხვადასხვა დაუცველობის კლასების ავტომატური გამოსწორება
ავტომატურ შესწორებასთან დაკავშირებულ საუბარში ერთ-ერთი ყველაზე გავრცელებული შეცდომა ის არის, რომ ყველა შესწორებას ისე აღიქვამთ, თითქოს ისინი ერთნაირად იქცევიან. სინამდვილეში, ეს ასე არ არის.
ავტომატური შესწორება SAST
კოდის დონის ავტომატური შეკეთება არის ის, სადაც ბევრი ადამიანი პირველად ხვდება კონცეფციას. სკანერი პოულობს SQL ინექციას, ასახულ XSS ჩამკეტს ან დაუცველ ვალიდაციის ნიმუშს და გვთავაზობს უსაფრთხო ჩანაცვლებას. ეს ხშირად ავტომატური შეკეთების ყველაზე ინტუიციური ფორმაა, რადგან შესწორება ჩანს საწყის კოდში და მისი გადახედვა შესაძლებელია ნებისმიერი სხვა ცვლილების მსგავსად.
Xygeni-ის პროდუქტის მასალები ამ სივრცეში AI AutoFix-ს ათავსებს, როგორც კონტექსტზე ორიენტირებულ კორექტირებას, რომელიც დეველოპერისთვის მზა შესწორებებს წარმოქმნის და pull requests ისეთი პრობლემებისთვის, როგორიცაა XSS და SQL ინექცია. ძირითადი შეტყობინება მნიშვნელოვანია პროდუქტის პრეტენზიის მიღმაც კი: კარგი SAST ავტოშესწორება უნდა ითვალისწინებდეს კოდს და არა მხოლოდ წესებს.
ავტომატური შესწორება SCA
დამოკიდებულების ავტომატური შეკეთება, სავარაუდოდ, უფრო მნიშვნელოვანია ოპერაციულად, რადგან დაუცველი პაკეტები მუდმივად ჩნდება და დამოკიდებულების ხელით შენარჩუნება არ მასშტაბირდება. თუმცა, ეს ასევე ის ადგილია, სადაც ნდობის მოპოვება ყველაზე რთულია, რადგან დამოკიდებულების განახლებები ზუსტად ის ადგილია, სადაც კრიტიკული ცვლილებები ყველაზე მტკივნეული გახდეს.
სანდო SCA ამგვარად, ავტომატური შეკეთების შესაძლებლობას მხოლოდ განახლების უსაფრთხოების, აფეთქების რადიუსის და თავსებადობის შეფასება არ სჭირდება.
საიდუმლოებების ავტომატური შეკეთება
საიდუმლოებების გამოსწორება ნაკლებად ეხება კოდის გადაწერას და უფრო მეტად შეკავებას. თუ ცოცხალი საიდუმლო გამჟღავნდება, იდეალური პასუხი არ არის ბილეთი, რომელიც ვინმეს სთხოვს მის შემდეგ კვირას შეცვლას. იდეალური პასუხია დაუყოვნებელი გაუქმება, ჩანაცვლება და თვალყურის დევნების გასუფთავება. სწორედ ამიტომ, საიდუმლოებების უსაფრთხოებაში ავტომატური შეკეთება ხშირად განსხვავდება კოდის ავტომატური შეკეთებისგან. ღირებულება სისწრაფე და დარწმუნებულობაა.
ავტომატური შესწორება IaC
ინფრასტრუქტურის არასწორი კონფიგურაციები ხშირად ძალიან განმეორებადია. ეს მათ ავტომატიზაციის ძლიერ კანდიდატებად აქცევს. თუ გუნდებს შეუძლიათ standardTerraform-ის, Kubernetes-ის, ARM-ის ან CloudFormation-ისთვის უსაფრთხო შაბლონების შექმნა, შემდეგ ავტომატურ შესწორებას შეუძლია ამ შაბლონების გაცილებით ადრე ამოქმედება. pipelineNIST-ის SSDF-ის აქცენტი უსაფრთხო პრაქტიკების თითოეულ სისტემაში ინტეგრირებაზეა გაკეთებული SDLC იმპლემენტაცია პირდაპირ აქ ჯდება: უსაფრთხოება ყველაზე ძლიერია, როდესაც ის სამუშაო პროცესშია ჩადგმული და არა მოგვიანებით ეტაპებისთვის გადადებული.
როგორ ავიცილოთ თავიდან აწყობის შეცდომები ავტომატური ფიქსის გამოყენებით
ეს თემის მთავარი დაპირებაა და პირდაპირ განხილვას იმსახურებს.
ავტომატური შეკეთებით ბილდების ჩაშლის თავიდან ასაცილებლად, გუნდებმა უნდა დაადასტურონ შესწორება ისევე, როგორც ადასტურებენ ნებისმიერ სხვა წარმოებასთან დაკავშირებულ ცვლილებას. ეს ნიშნავს:
- ცვლილების გამოყენებამდე გააანალიზეთ დამოკიდებულება და კოდის გავლენა
- დაადასტურეთ შესწორება CI/CD ტესტებითა და პოლიტიკით
- შეზღუდეთ ავტომატური სამიზნე, სადაც აფეთქების რადიუსი მაღალია
- მოითხოვეთ დეველოპერის მიმოხილვა არსებითი ცვლილებებისთვის
- მაღალი ეფექტის მქონე განახლებებისთვის გამოიყენეთ ეტაპობრივი შესავალი
სწორედ ამიტომ არის გამოსწორების რისკების ანალიზი ასეთი ღირებული. ის კითხვას „არსებობს თუ არა გამოსწორება?“-დან „ეს არის თუ არა ყველაზე უსაფრთხო გამოსავალი?“-ზე ცვლის. ეს ბევრად უკეთესი საინჟინრო კითხვაა.
სწორედ ამ დროს ვერ ხერხდება ავტომატიზაციის მრავალი პროგრამის მუშაობა. ისინი ოპტიმიზირებენ გამტარუნარიანობას და უგულებელყოფენ ცვლილებების უსაფრთხოებას. დეველოპერები ამას მაშინვე ამჩნევენ.
ამის საპირისპიროდ, სანდო ავტომატური შესწორების სისტემა პატივს სცემს იმავე ცვლილებების მართვის დისციპლინას, რომელსაც ძლიერი საინჟინრო გუნდები უკვე იყენებენ ფუნქციების შემუშავებისას: მიმოხილვა, ტესტირება, ვალიდაცია, შერწყმა.
ავტოშესწორების დანერგვის საუკეთესო პრაქტიკა
თუ თქვენ ქმნით ან ავითარებთ ავტომატური შეკეთების პროგრამას, მიზანი უნდა იყოს დანერგვა და არა სიახლე. გუნდები ავტომატურ შეკეთებას გამოიყენებენ მაშინ, როდესაც ის მუდმივად ზოგავს დროს დასუფთავების სამუშაოს შექმნის გარეშე.
დაიწყეთ პოლიტიკით. ჯერ გადაწყვიტეთ, რომელი საკითხების კლასების ავტომატიზაციაა უსაფრთხო. SAST კარგად გააზრებული გადაწერების მქონე ნიმუშები, განსაზღვრული ვერსიის დიაპაზონების ფარგლებში დამოკიდებულების განახლებები ან საიდუმლო გაუქმების სამუშაო პროცესები ხშირად კარგი ადრეული კანდიდატებია.
შემდეგ შეამცირეთ მოქმედების სფერო. ნუ ეცდებით ყველაფრის ერთ ვერსიაში ავტომატიზაციას. პირველ რიგში, ყურადღება გაამახვილეთ ისეთ საკითხებზე, რომლებიც როგორც საერთოა, ასევე მაღალი სანდოობის. ეს, როგორც წესი, უკეთესი ნდობის დამყარების სტრატეგიაა, ვიდრე ფართომასშტაბიანი, მაგრამ ხმაურიანი გამოსწორების დანერგვა.
ინტეგრირეთ გამოსწორების მეთოდები დეველოპერების არსებულ სამუშაო პროცესებში. თუ თქვენი საინჟინრო გუნდები ცხოვრობენ pull requests და განშტოებების დაცვა, ავტომატური შეკეთებაც ასევე უნდა იყოს.
შედეგების გაზომვა. სწორი მეტრიკები არ არის მხოლოდ „გენერირებული შესწორებების რაოდენობა“. ესენია შერწყმის მაჩვენებელი, რეგრესიის მაჩვენებელი, დაზოგილი დრო, ცრუ დადებითი შედეგების შემცირება და გამოსწორებისთვის საჭირო დრო.
და ბოლოს, შეინარჩუნეთ ადამიანის მიერ დამტკიცების ფენა, სადაც ეს მნიშვნელოვანია. უსაფრთხო ავტომატური შეკეთება არ გამორიცხავს დეველოპერის შეფასებას. ის ამაღლებს მის დონეს განმეორებითი სამუშაოს მოხსნით და ყურადღების კონცენტრირებით უფრო მაღალი ღირებულების მქონე მიმოხილვაზე.
აღმოჩენიდან გამოსწორებამდე: ციკლის დახურვა
AppSec-ის მემკვიდრეობითი ინსტრუმენტების ერთ-ერთი ყველაზე დიდი სისუსტე ის არის, რომ პროცესი ძალიან ადრე მთავრდება. ჩნდება დასკვნა. იქმნება ბილეთი. შემდეგ სისტემა ელოდება.
ეს დახურული ციკლი არ არის. ეს გადაცემაა.
თანამედროვე AppSec პროგრამას უნდა შეეძლოს დეტექციიდან პრიორიტეტულობის მინიჭებაზე და შემდეგ გამოსწორებაზე გადასვლა რაც შეიძლება ნაკლები ხელით ორკესტრირებით. ეს არის ავტომატური შეკეთების ნამდვილი დაპირება. ის არა მხოლოდ აჩქარებს შეკეთებას. ის ცვლის შეკეთების ადგილს, მის დანერგვის წესს და ვის უწევს განმეორებითი სამუშაოს შესრულება.
სწორედ ამიტომ არის ეს თემა კომერციულად მნიშვნელოვანი და არა მხოლოდ ტექნიკური თვალსაზრისით. მყიდველებს აღარ სურთ მხოლოდ გამოვლენის ხარისხი. მათ სურთ დაგროვილი საქმეების გაზომვადი შემცირება და პრობლემების აღმოჩენიდან პრობლემის მოგვარებამდე უფრო სწრაფი გადასვლა.
როგორ უზრუნველყოფს Xygeni უსაფრთხო ავტომატურ შეკეთებას
Xygeni-ის მასალები ავტომატურ კორექტირების შესაძლებლობებს სამ თემაზე ათავსებს: კონტექსტი, ავტომატიზაცია და მიწოდების ინტეგრაცია.
კოდის მხრივ, Xygeni AI SAST AutoFix ქმნის დეველოპერისთვის მზა შესწორებებს, ცვლის სარისკო შაბლონებს უსაფრთხო ალტერნატივებით და ახორციელებს ამ შესწორებების მიწოდებას. pull requests აბსტრაქტული რეკომენდაციების ნაცვლად. ის მყისიერად ასწორებს ისეთ დაუცველობებს, როგორიცაა XSS ან SQL Injection და უსაფრთხო კოდირების საუკეთესო პრაქტიკას პირდაპირ დეველოპერის სამუშაო პროცესში იყენებს.
თუმცა, Xygeni-ში ავტომატური შეკეთება სცილდება SAST. იგი ასევე მოიცავს საიდუმლოებების ავტომატური შეკეთება, რომელიც აფიქსირებს გაჟონილ ავტორიზაციის მონაცემებს და ავტომატურად აუქმებს მათ წინასწარ აშენებული მონაცემების გამოყენებით. playbooks ისეთ პლატფორმებზე, როგორიცაა AWS, GCP ან GitLab. ეს საშუალებას იძლევა დაუყოვნებლივი შეკავების, ხელით რეაგირების შეფერხებების აღმოფხვრის და ავტორიზაციის ბოროტად გამოყენების რისკის შემცირების.
დამოკიდებულების მხრივ, ქსიგენი SCA ავტომატური შეკეთება დაუცველი დამოკიდებულებების შესწორებების გენერირებით და მათი მასშტაბური გამოყენებით, გუნდებს შეუძლიათ ავტომატური პატჩების გააქტიურება, შექმნა pull requests განახლებული ვერსიებით და ინტეგრირება მოახდინეთ გამოსწორებაზე პირდაპირ CI/CD pipelineმიწოდების შეფერხების გარეშე.
გარდა ამისა, ეს შესაძლებლობები ვრცელდება ინფრასტრუქტურა, როგორც კოდი (IaC) მდე pipeline კონფიგურაციები, რაც უზრუნველყოფს, რომ არასწორი კონფიგურაციები და სარისკო ინფრასტრუქტურის ნიმუშებიც გამოსწორდება იმავე ავტომატიზირებული სამუშაო პროცესის ფარგლებში.
ეს სტრატეგიული საკითხია. უსაფრთხო ავტოშეკეთება იზოლირებულად არ მუშაობს. ის მოიცავს კოდი (SAST), დამოკიდებულებები (SCA), საიდუმლოებები და ინფრასტრუქტურა (IaC), რაც უზრუნველყოფს თანმიმდევრულ გამოსწორებას მთელი პროგრამული უზრუნველყოფის მიწოდების ჯაჭვში. უფრო მეტიც, ის საუკეთესოდ მუშაობს ექსპლუატაციაზე დაფუძნებულ პრიორიტეტიზაციასთან, დამოკიდებულების გრაფიკის ანალიზთან და CI/CD ვალიდაცია, რათა შესწორებები იყოს არა მხოლოდ ავტომატიზირებული, არამედ უსაფრთხო, რელევანტური და წარმოებისთვის მზად.
სწრაფი პასუხი: როგორ გამოვასწოროთ დაუცველობები უსაფრთხოდ ავტომატური შეკეთების საშუალებით?
ავტომატური გამოსწორების საშუალებით დაუცველობების უსაფრთხოდ გამოსასწორებლად, გუნდებს სჭირდებათ კონტექსტის გათვალისწინებით გამოსწორებები, ექსპლუატაციის შესაძლებლობაზე დაფუძნებული პრიორიტეტიზაცია, გამოსწორების რისკების ანალიზი. CI/CD ვალიდაცია და დეველოპერის დამტკიცება გაერთიანებამდე.
ეს არის მოკლე პასუხი.
ამაზე ნაკლები რამ შეიძლება მაინც ავტომატიზაცია იყოს, მაგრამ ეს არ არის ისეთი ავტომატიზაციის სახეობა, რომელსაც დეველოპერები წარმოებაში ენდობიან.
კითხვა-პასუხი
რა არის ავტომატური შეკეთება AppSec-ში?
AppSec-ში ავტომატური შეკეთება არის უსაფრთხოების პრობლემების, როგორიცაა კოდის ხარვეზები, დაუცველი დამოკიდებულებები, გამოვლენილი საიდუმლოებები ან ინფრასტრუქტურის არასწორი კონფიგურაციები, გამოსწორების ცვლილებების ავტომატური გენერირება და მიწოდება.
შეუძლია თუ არა ავტომატურ შეკეთებას ბილდების დაშლა?
დიახ. ავტომატურმა შესწორებამ შეიძლება გამოიწვიოს ბილდების გაფუჭება, როდესაც დამოკიდებულების განახლებები შეუთავსებელ ცვლილებებს შეიტანს, როდესაც შესწორებები უგულებელყოფს აპლიკაციის კონტექსტს ან როდესაც ცვლილებები გამოიყენება ვალიდაციის გარეშე.
როგორ გამოვასწოროთ დაუცველობები ავტომატურად რეგრესიების შექმნის გარეშე?
გამოიყენეთ ავტომატური შეკეთება კონტროლირებად სამუშაო პროცესში: პრიორიტეტის მინიჭება ექსპლუატაციისა და ხელმისაწვდომობის მიხედვით, გამოსწორების რისკის ანალიზი, ცვლილებების დადასტურება. CI/CDდა შეინარჩუნეთ დეველოპერის დამტკიცების ეტაპი.
რით განსხვავდება უსაფრთხო ავტომატურ შეკეთება ნაირავე ავტომატურ შეკეთებისგან?
უსაფრთხო ავტოშესწორება ითვალისწინებს კონტექსტს, რისკებს და pipeline-aware. ნაივური ავტომატური შეკეთება უბრალოდ გვთავაზობს ან იყენებს ცვლილებებს თავსებადობის, გაშვების დროს ზემოქმედების ან საინჟინრო სამუშაო პროცესის გაგების გარეშე.
სანდოა თუ არა ხელოვნური ინტელექტის ავტომატური შეკეთება?
შეიძლება ასეც იყოს, მაგრამ სანდოობა დამოკიდებულია ვალიდაციასა და მმართველობაზე. Gartner-ი ცალსახად ურჩევს ორგანიზაციებს, რომლებიც იყენებენ ხელოვნურ ინტელექტზე დაფუძნებულ... code security ასისტენტები აგრძელებენ ტრადიციული AST-ისა და კოდის მიმოხილვის გამოყენებას, როგორც დამაბალანსებელი კონტროლის საშუალებას, რადგან ხელოვნური ინტელექტის ოპტიმიზატორებს შეუძლიათ ზედმეტად გამოასწორონ ან გამოტოვონ მუშაობასთან, საიმედოობასთან და კოდის ხარისხთან დაკავშირებული პრობლემები.
საბოლოო ტრეფიკი
ავტომატური შეკეთება AppSec-ში სიახლეს აღარ წარმოადგენს. ის პრაქტიკულ მოთხოვნად იქცევა იმ გუნდებისთვის, რომლებსაც შეკვეთების დაგროვების შემცირება სჭირდებათ თანამშრომლების რაოდენობის გაზრდის ან მიწოდების შენელების გარეშე.
რეალური გამოწვევა არ არის გამოსწორების ავტომატიზაცია, არამედ ის, ითვალისწინებს თუ არა ეს ავტომატიზაცია იმას, თუ როგორ იქმნება და მიეწოდება პროგრამული უზრუნველყოფა.
თუ თქვენი ავტომატური შესწორების სტრატეგია უგულებელყოფს კონტექსტს, პრიორიტეტების განსაზღვრასა და დადასტურებას, ის უფრო მეტ უთანხმოებას შექმნის, ვიდრე ღირებულებას. თუ ის შექმნილია დეველოპერის სამუშაო პროცესების, შესწორების რისკისა და CI/CD საკონტროლო წერტილებში, მას შეუძლია მნიშვნელოვნად გააუმჯობესოს როგორც უსაფრთხოების შედეგები, ასევე საინჟინრო სიჩქარე.
ეს არის ის standard ღირს მიზნის მიღწევა.
ავტორის შესახებ
თანადამფუძნებელი და ტექნიკური დირექტორი
ფატიმა Said სპეციალიზირებულია დეველოპერებისთვის პირველ რიგში განკუთვნილ კონტენტზე AppSec, DevSecOps და software supply chain securityის რთულ უსაფრთხოების სიგნალებს მკაფიო, ქმედით ინსტრუქციებად აქცევს, რაც გუნდებს ეხმარება პრიორიტეტების უფრო სწრაფად განსაზღვრაში, ხმაურის შემცირებასა და კოდის უფრო უსაფრთხოდ გაგზავნაში.







