Coffee break #35. Paano sumunod sa mga panuntunan sa seguridad ng GitHub. Mga kapaki-pakinabang na tip para sa mabilis na pag-debug ng Java code

Paano manatiling secure sa GitHub

Pinagmulan: Ang DZone GitHub ay nararapat na ituring na pinakasikat na platform ng pagbuo ng koponan. Ayon sa data mula noong nakaraang taglagas, higit sa 40 milyong programmer ang gumamit ng serbisyong ito. At dahil karamihan sa kanila ay gumagamit ng open source upang lumikha ng software, ang seguridad kapag nagtatrabaho sa Github ay dapat ang iyong pangunahing priyoridad. Ang muling paggamit ng code ay nagpapataas ng panganib ng pagkalat ng mga kahinaan. Nangangahulugan ito na ang bawat gumagamit ng GitHub ay dapat magbayad ng maximum na pansin sa paglikha ng isang ligtas na kapaligiran sa pag-unlad. Mayroong 8 panuntunan na kailangan mong sundin para mapanatiling secure ang iyong GitHub code.

Magbigay ng kontrol sa pag-access

Ang kontrol sa pag-access ay isa sa mga pinakamahusay na paraan upang mapabuti ang seguridad hindi lamang sa GitHub, ngunit sa anumang iba pang kapaligiran kung saan kinakailangan ang proteksyon ng code. Nag-aalok ang GitHub ng ilang paraan para mabawasan ang mga panganib sa iyong trabaho. Una, gawing kasanayan ang pagbibigay ng hindi bababa sa pribilehiyo—ibigay lang sa mga user ng repository ang mga pahintulot na kailangan nila para gawin ang kanilang trabaho. Mayroong iba pang mga paraan ng kontrol sa pag-access na dapat mong sundin:

• limitahan ang paglikha ng mga repositoryo upang maiwasan ang mga user na magbunyag ng impormasyon tungkol sa organisasyon sa mga pampublikong repositoryo;
• paganahin ang proteksyon ng sangay at mga pagsusuri ng estado upang mapagsama ng mga user ang mga commit o pamahalaan nang ligtas ang mga sangay;
• Pahintulutan o huwag paganahin ang pag-forking ng mga pribadong repositoryo upang matiyak na ang mga user ay hindi magbubunyag o magbahagi ng iyong code sa iba;
• bawiin ang access para sa lahat ng hindi aktibong user na hindi na miyembro ng iyong komunidad o mga empleyado ng kumpanya;
• Pana-panahong suriin ang mga karapatan sa pag-access sa iyong mga proyekto sa GitHub;
• Tiyaking hindi ibinabahagi ng mga user ang access o password sa GitHub account sa iba;
• siguraduhin na ang bawat gumagamit ng repositoryo ay gumagamit ng dalawang-factor na pagpapatotoo sa kanilang account;
• Baguhin ang mga personal na token sa pag-access at mga SSH key sa pana-panahon.

Huwag kailanman mag-imbak ng data ng access sa iyong mga GitHub file

Ang pagtagas ng impormasyon sa pag-access sa iyong GitHub repository sa pamamagitan ng code, configuration file, o commit na mga mensahe ay maaaring gamitin para sa mga pag-atake. Upang maiwasang maidagdag ang sensitibong data sa iyong repository, gumamit ng mga access control tool tulad ng git-secrets o vault . Ini-scan ng mga tool na ito ang iyong code base at binabago ang access sa tuwing may makikitang sensitibong impormasyon sa iyong code o mga configuration file. Kung makakita ka ng sensitibong impormasyon sa iyong GitHub repository, dapat mo itong i-delete kaagad. Ngunit dahil pinapanatili ng GitHub ang isang kasaysayan ng lahat ng mga commit sa iyong repositoryo, hindi sapat ang pagtanggal ng data lamang. Kakailanganin mong tanggalin ang mga file mula sa iyong kasaysayan ng imbakan ng GitHub. Ang isang mahalagang hakbang upang mapabuti ang seguridad ay ang pagpapalit ng lahat ng mga password at token na dating available sa publiko.

Paganahin ang mga alerto para sa mga mahihinang dependency

Habang nagtatrabaho ang mga user ng GitHub sa mas maraming proyekto, lalong nagiging mahirap na kontrolin ang dumaraming bilang ng mga umaasa na bagay. Sa kabutihang-palad, ang GitHub ay nagbibigay ng mga awtomatikong alerto para sa mga mahihinang dependency na matatagpuan sa repositoryo. Ang mga alertong ito ay nakabatay sa National Vulnerability Database (NVD), GitHub Security Advisories , at sa WhiteSource vulnerability database, na sumusuporta sa higit sa 200 programming language. Pinapadali at mas ligtas ng mga alerto sa GitHub ang paggamit ng mga open source na library.

Suriin ang mga app na idinagdag mula sa GitHub

Ang GitHub Marketplace ay naglalaman ng daan-daang application na isinulat ng mga third-party na developer at kumpanya. Samakatuwid, mahalagang suriing mabuti ang bawat application na idaragdag mo sa iyong repositoryo. Kapag nag-i-install ng mga application mula sa GitHub Marketplace, sundin ang mga alituntuning ito:

• Ipatupad ang prinsipyo ng hindi bababa sa pribilehiyo. Huwag kailanman bigyan ang mga application ng higit pang mga karapatan sa pag-access kaysa sa kinakailangan nila;
• Palaging tanungin ang mga karapatan sa pag-access o mga pahintulot na hinihiling ng isang application. Isipin ang pinsalang maaaring idulot nito sa antas ng pag-access na ito;
• I-verify na ang kumpanya o developer ng app ay talagang umiiral bago sila bigyan ng access sa iyong GitHub repository;
• Suriin ang pag-andar at seguridad ng application. Kung naglalaman ito ng mga kahinaan, maaari kang maging biktima ng pag-hack;

Ang seguridad ng isang aplikasyon ay hinuhusgahan ng pinakamahina nitong bahagi. Nalalapat din ito sa mga repositoryo ng GitHub. Kaya bago mo bigyan ang isang app ng access sa iyong storage, tiyaking pinagkakatiwalaan mo ito at tumutugma ito sa antas ng access na hinihiling nito.

Suriin ang lahat ng code na na-import mula sa GitHub

Madalas na ginagamit ng mga developer ang code ng ibang tao. Sa tuwing kumopya ka ng bahagi ng code ng ibang tao sa iyong proyekto, magsagawa ng buong pagsusuri nito. Ito ay maaaring mukhang isang pag-aaksaya ng oras, lalo na para sa mga maliliit na proyekto, ngunit may isang pagkakataon na sa pamamagitan ng pagpapabaya sa panuntunang ito ay magpapasok ka ng isang kahinaan sa iyong repositoryo. Ang isa pang panganib na nauugnay sa na-import na code ay maaaring naglalaman ito ng sensitibong impormasyon gaya ng data ng pag-access. Kung nakaimbak ang mga ito sa mga GitHub file, lumilikha ito ng isa pang panganib sa seguridad. Ang pag-audit sa code bago ito kopyahin ay nakakatulong upang matukoy ang mga naturang butas. Huwag ipagpalagay na ligtas ang code ng ibang tao dahil nasa pribadong repository ito. Maaari itong makapinsala sa iyong codebase.

Gumamit ng awtomatikong static source code analysis para sa iyong mga repository

Mayroong ilang mga tool ng third-party na magagamit mo upang suriin ang iyong repository para sa mga kahinaan. Ang isa sa mga ito ay ang WhiteSource Bolt , isang libreng tool mula sa GitHub Marketplace. Sinusuri ng WhiteSource Bolt ang iyong mga repositoryo para sa mga kahinaan sa lahat ng nakalantad na code. Nagbibigay din ito ng detalyadong impormasyon tungkol sa mga kahinaan at nagmumungkahi ng mga opsyon sa remediation.

Gamitin ang GitHub plan na nababagay sa iyong mga pangangailangan

Maraming mga kumpanya ang may mga patakaran na pumipigil sa mga developer na mag-post ng code sa mga platform tulad ng GitHub. Ang mga paghihigpit na ito ay karaniwan lalo na sa mga departamento ng gobyerno at mga institusyong pinansyal. Kung nagtatrabaho ka sa isang lubos na kinokontrol na kapaligiran, gamitin ang GitHub Enterprise , isang enterprise plan na nagbibigay-daan sa iyong mag-host ng mga repositoryo sa isang lokal na server. Nagbibigay ito ng mas mataas na antas ng seguridad dahil pinapayagan nito ang mga developer ng kumpanya na magkaroon ng access sa lahat ng mga proyekto nang hindi nababahala tungkol sa mga hindi awtorisadong user ng GitHub.

Sundin ang isang komprehensibong patakaran sa seguridad sa iyong mga proyekto

Ang kaligtasan ay isang kolektibong responsibilidad. Kung nagtatrabaho ka sa isang pangkat, mahalagang magtatag ng mga panuntunang pangkaligtasan na dapat sundin ng lahat ng stakeholder. Sa isip, dapat mong pagsamahin ang cybersecurity at development team sa yugto ng pagpaplano upang matiyak na gumagana ang mga ito nang naka-sync. Ito ay magiging mas madali upang matiyak ang proteksyon sa panahon ng proseso ng pag-unlad. Kung ang isa sa mga miyembro ng iyong koponan ay walang ingat sa pag-iimbak ng mga password o iba pang sensitibong impormasyon, maaari nitong ilagay sa panganib ang buong repositoryo. Upang maiwasan ito, malinaw na idokumento ang pamamaraang pangkaligtasan na dapat sundin ng lahat ng iyong mga kasamahan.

Konklusyon

Ang pag-secure ng iyong code sa GitHub ay madali. Kailangan mo lang tiyakin ang wastong kontrol sa pag-access, sinasamantala ang mga built-in na feature ng seguridad ng GitHub. Kung interesado ka sa maximum na proteksyon, isama ang mga karagdagang tool na magpapataas ng seguridad ng code sa lahat ng yugto ng pag-unlad. Inirerekomenda din namin ang pagsusuri sa mga seksyon ng GitHub Security para sa Negosyo at Mga Libreng User ng dokumentasyon . Sa ganitong paraan makakakuha ka ng karagdagang impormasyon tungkol sa seguridad at proteksyon ng code.

Mga kapaki-pakinabang na tip para sa mabilis na pag-debug ng Java code

Pinagmulan: Hackernoon Bukod sa pagsulat ng mahusay na code, ang pagiging mas mahusay sa pag-debug ay isa sa mga pinakakapaki-pakinabang na bagay na maaari mong gawin upang gawing mas madali ang iyong buhay bilang isang developer ng Java. Ito ay lalong mahalaga sa mga modernong kundisyon ng pagbuo ng software, kung saan ang mundo ng software ay aktibong kumikilos patungo sa mga distributed architecture at asynchronous na code. Bagama't hindi maiiwasan ang mga error sa software, lalong nagiging mahirap itong tuklasin at ayusin sa mga kumplikadong build. At kapag lumipat sa yugto ng paglabas ng produkto, ang proseso ng pag-debug ay nagiging mas seryosong problema. Sa kasamaang palad, walang paraan upang maiwasan ito - kailangan ang pag-debug. Upang matulungan ka, nagpasya akong magbahagi ng ilang kapaki-pakinabang na tip para sa pag-debug ng mga application ng Java sa iba't ibang yugto ng pag-unlad.

Gumamit ng mga control point

Magsimula tayo sa mga breakpoint, isang malinaw ngunit napakahalagang punto na sumasailalim sa anumang proseso ng pag-debug. Binibigyang-daan ka ng mga checkpoint na ihinto ang pagpapatupad ng isang application upang masuri mo ang estado ng programa at malaman kung bakit hindi gumagana nang tama ang code. Nag-aalok ang bawat debugger ng ilang opsyon sa breakpoint, kabilang ang mga kondisyonal na breakpoint, exception breakpoint, watchpoint, at tracepoint. Ang pag-aaral kung paano at kailan gagamit ng iba't ibang uri ng mga breakpoint ay maaaring gawing mas maayos ang proseso ng pag-debug. Ito ay nagkakahalaga ng pagbanggit na ang ilang mga modernong tool ay sumusuporta sa mga checkpoint nang hindi nakakaabala sa aplikasyon. Ginagawa nitong posible na magtakda ng mga punto sa iyong code at mangolekta ng data sa pag-debug nang hindi humihinto sa pagpapatupad ng programa.

Ipakita ang lohikal na istraktura

Ang tampok na ipakita ang lohikal na istraktura ay lubhang kapaki-pakinabang kapag sinusubaybayan ang nilalaman sa mga klase ng Java. Kung naka-enable ang feature na ito, magpapakita ang listahan ng variable ng array, na mas kapaki-pakinabang sa konteksto ng pag-debug. Ito ay napaka-maginhawa, lalo na kung ang iyong code ay walang mga toString() na pamamaraan para sa mga bagay. Nagbibigay-daan din sa iyo ang mga variable view na direktang baguhin ang mga value ng iyong mga variable habang nagde-debug. Makakatipid ito ng malaking tagal ng oras sa pamamagitan ng hindi kinakailangang i-restart ang session ng pag-debug gamit ang binagong data ng input.

Matutong mag-navigate sa codebase

Ang anumang Java debugger ay maaaring gumamit ng ilang function na nagbibigay-daan sa iyong mag-navigate sa iba't ibang seksyon ng code habang nagde-debug. Kabilang sa ilan sa mga ito ang "tumakbo sa linya", "step over", "step into" at "step into". Bilang karagdagan sa mga ito, isaalang-alang ang dalawa pang opsyon:

1. I-drop sa frame - Ang function na ito ay ginagamit upang bumalik sa isang punto sa iyong stack frame. Kung napalampas mo ang isang punto at kailangan mong bumalik, gamitin lang ang Drop to frame function.
2. Step filtering - nagbibigay-daan sa iyong laktawan ang ilang partikular na packet habang nagde-debug. Hindi mo kailangang mag-navigate sa lahat ng mga klase sa JDK system kapag maaari mo lamang i-filter ang mga uri na hindi mo kailangan.

Upang mapahusay ang iyong bilis ng pag-navigate sa code, kailangan mong makabisado ang mga kumbinasyon ng function key:

• F5 - para sa "pagpasok sa".
• F6 - para sa "step over".
• F7 - para sa "step return".
• F8 - upang tumakbo sa susunod na checkpoint.

Bagama't maaaring mag-iba ang mga hotkey sa pagitan ng mga IDE, kung maaalala mo ang mga ito, maililigtas ka nito mula sa paggamit ng mouse nang mas madalas.

Matutong Iwasan ang Deadlocks

Ang isang deadlock scenario ay nangyayari kapag dalawa o higit pang mga thread ang humarang pagkatapos bumuo ng isang circular dependency. Dahil ang isang hanay ng mga Java thread ay karaniwang naghihintay para sa isa pang mapagkukunan, maaari itong maging sanhi ng ganap na paghinto ng application. Ang pag-debug ng jstack deadlock ay maaaring maging mahirap dahil hindi sila nagpapakita ng mga tagapagpahiwatig ng problema tulad ng mga spike ng memorya, pag-load ng CPU, atbp. Mayroong iba't ibang mga diskarte upang i-troubleshoot ang isang jstack deadlock na sitwasyon. Una, maaari kang kumuha ng maraming thread dumps sa iyong JVM cluster upang maghinuha ng mga pattern ng thread. Sa kasong ito, maaaring hindi sapat ang pagsusuri sa isang static na thread dump. Depende sa laki ng kumpol ng JVM, maaaring kailanganin ang pag-trawl ng maraming file, na kadalasan ay isang prosesong matrabaho at matagal. Pinakamainam na gumamit ng solusyon sa pagsubaybay sa application na nagbibigay ng JV layer at code layer na kailangan upang ihiwalay ang mga deadlock ng thread. Sa kabutihang palad, may mga makabagong tool na makakatulong sa sitwasyong ito, kabilang ang ilang modernong debugger pati na rin ang mga komersyal na tool sa APM. Pinapataas ng mga tool na ito ang transparency ng iyong Java code habang kinikilala ang mga error.

Gamitin ang kapangyarihan ng mga debugger ng produksyon

Ang karaniwang proseso ng pag-debug na karaniwang sinusunod ng karamihan sa mga developer ay nagsasangkot ng pagkopya sa kapaligiran, pagbubukod ng error, at pagkatapos ay pag-aayos nito. Gayunpaman, hindi ito nalalapat sa lahat ng kaso. Kung ito ang sitwasyon, dapat gumamit ang developer ng makapangyarihang mga debugger sa produksyon. Ang Rookout ay isa sa gayong tool. Pinapayagan ka nitong mangolekta ng data sa pag-debug mula sa mga application nang hindi binabago ang estado o kontrol ng daloy nito. Sa Rookout, maaari kang magtakda ng mga hindi nakakasira na breakpoint para makakuha ng buong stack trace, makuha ang mga live na variable, o anumang data ng application na kailangan para sa pag-debug. Kaya, sa halip na gumamit ng mga high-overhead na solusyon sa pagsubaybay para sa pag-debug ng produksyon, gamitin lang ang Rookout, na nagbibigay ng lahat ng kailangan mo upang i-debug ang mga application nang hindi nagre-redeploy o sumusulat ng bagong code. Gumagawa ka man sa server-side o containerized na mga application, ang Rookout ay isang magandang karagdagan sa iyong arsenal sa pag-debug.

Huwag kalimutan ang tungkol sa malayuang pag-debug

Ang karamihan sa mga IDE, tulad ng NetBeans, Eclipse, IntelliJ IDEA, at Visual Studio, ay sumusuporta sa malayuang pag-debug, isang pamamaraan na nagbibigay-daan sa iyong ayusin ang Java code na matatagpuan sa ibang computer. Ito ay lalong mahalaga sa mga sitwasyon kung saan ang iyong system ay hindi sumusuporta sa lokal na pag-debug, o kapag ang iyong computer ay walang sapat na mapagkukunan upang magpatakbo ng mga debugger. Upang maisagawa ang malayuang pag-debug, dapat kang magbigay ng impormasyon sa pagsasaayos na gagamitin ng debugger upang kumonekta sa malayong port. Kapaki-pakinabang din ang malayuang pag-debug sa mga sitwasyon sa pag-troubleshoot kung saan kailangang kumonekta ang mga developer sa labas ng site sa application upang ayusin ang isang bug. Tandaan na kung minsan ang pag-debug ay maaaring magtagal kaysa sa aktwal na pagpapatupad. Habang hinahasa mo ang iyong mga kasanayan sa pag-debug ng Java, palaging magsikap na magsulat ng malinis, mahusay na code—nagpapabunga ito pagdating sa pag-aayos ng mga bug. Kung sa tingin mo ay nawawalan na ng kontrol ang mga bagay, palaging magandang ideya na magpahinga. Ang isang bug ay isang palaisipan sa programming, at maraming programmer ang nagawang lutasin ang problemang ito nang hindi malapit sa kanilang computer. Gamitin ang mga diskarte na inilarawan sa itaas upang maalis ang mga problema sa pag-debug ng Java. Maligayang coding!