Upload Dockerfile

Dockerfile

@@ -0,0 +1,47 @@
+# syntax=docker/dockerfile:1.4
+FROM debian:bookworm-slim
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    wget unzip jq nginx bash python3 python3-flask ca-certificates curl \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN useradd -m -s /bin/bash -u 1000 appuser && \
+    mkdir -p /app /var/lib/nginx /var/log/nginx /run/nginx && \
+    chown -R appuser:appuser /app /var/lib/nginx /var/log/nginx /run/nginx
+
+WORKDIR /app
+
+RUN wget -qO /tmp/x.zip "https://github.com/XTLS/Xray-core/releases/latest/download/Xray-linux-64.zip" && \
+    unzip -qq /tmp/x.zip -d /tmp/vc && \
+    find /tmp/vc -name "xray" -type f -exec cp {} /app/svc \; && \
+    chmod +x /app/svc && \
+    rm -rf /tmp/x.zip /tmp/vc
+
+COPY <<'EOF' /app/init.py
+import os, base64, json
+
+b = "H_U..b)^\V:	-]	]W:oD/&KldPQPTBnPKnI\B\@_	bY}b36Xnm@GTA/KP=e`	53wFS6;%TnlJmUmD^m:O:J24EWRp|JOmDC][_85HL^V4czX}b;(S]F_eS-=8S 6DdoD44FLT.6PUo\m[mDHme	:J')AOEp;lOmDA]QH:FI/KJFV4cz_3&'EAz_^GgA
_Y/KPKGVJ4c3PBU3(S]F_u]^XmI\oD5!PPn5&$^G]U3A^YmD^E@F:AG2QWC/'(Uv\F][n\CGJeZ
.5JGRp|jIo^@-^T	_5H
PAGbq`qH nP]n^F

e	:J7,APRpjmGPmH-AIK:6Dn(&BJO'dIo_SWU:FFJeW5RFS2;"Tn=mFA:FnQe:J05M@}b;nBEFUB:FI/K	
PW]bxZp/Un:@P
YW	l!ABmd'TT RTmDHmUn\X<$7%CKCE^\.SmD
^\5Hn3%ENr%&2X\TB:	-_F]6Dnb7!TFGXVA.SJ:FAS6DnI$4ILEp;LOJ:^FT8/K[THXoqxp6^@GmDBA
J8B	Z]_:J{GN+="T_\^] -:FBW^AoDR:BE$ #BAo\mCCVJB5Hn	&}b36XnL;nPGED\6DiH:J12KWN#=*m	mDW@V^8/K^n\4c$MQD#&oTF\V8;DFJ/'
@N.4dF	CYmARW :%!ANN.r)WTmT@ @n
V\\F
zJSH$riE_CB	mGWFBD	*%V|B/<(TQGX	_AR@ 	]DLnIH:a`E@B%!5n^\VF^TJn_FDBWIoHa`OH3&#_	P	.FD]]V\IH:J`rfBA^HmABFEFSEI HXop
xb~ 	o_FRQAIK,fZV$2kN3&fZ\B
nQFm\SIJFU]P(/J.72\]Wm\RQFDA@9KWW$#PN&4}m\FR@^nBFQFGRnonbh^
BJn_FDSIVJJ9 54T|W% 5X]]WI-\FDS	AKl5LF@$74gCVPVQYAmXVV]4/``r6C]KH9BW.ZT T@S*WWP..5"!CSWT:	.FD@m@(ABE% fy]@EFZF
:
SI:W4/=b;(UWKE_SDXv<*>?iw,,O|:2\^]_UO-T8/V\SWX4/|IFU!r%YSABE.Sge I	nQW6_V	a.END}dG[VF^@-_F[eD5(GD6;%TDXEZ^Q[_XSDX^V[Yopx<zE[G]s76{bF'^\
bR-|WH4>#n]
X\QZCnQIA	IG'/JWRn5)^U_TA[_Q^KRA [U X_Z
|QWG)&|FU[E&BJV_CRRV	W1,EZ3%'AnT^O-B]W MnX4/|WWX,7xm\\C]JFIPSJE	PYq{3'4WSPT\@SUUGYFFFXovm6C[^PHRR WHIGKJWP	%!VZ`qrS
_\FTP
_Q]H<Jjr=P\IKB[\V\DS]P\Sa-EQF)<|PV\V\D	SMU(,]g3ETZEA\BKT@QFDn]FH#/@Z;r$PQXV^GC^D	-/V634EIF[J\
Z MWXq6L03"U[]V\  _
F8_SIJFF
 #ODS/'(UZ\VWHQ@PP^^][Vi#MQB,7fPF V@AFVPA[VT]slq~fOW]E_AWFTXdiO`rfFTFKWII[PIJF7%VEM/%kIYUV	8_SGJZQ		3$X-3>EZUYR@ VI	S^[]\Hq`EVU/ifU[@A
PKHQUC 
FV-!PF#=*D_]B\  
\ Az`YO`rhYWRUC	QUC QWWHn`	`6/BB_PWI]D[G  @P	5%JW`!6PQVTFW_]DP^KPFV{`GFO474
^PV[\P^^_IIX\_F.(7'UWA 	QQ^
CS(-EQXiifW]]EKFWZE\D	CRJ V\GK(:Ar|sCW^
FEW
BU]SJVTX18QF"3n T ^C JTZRJe\FF15HPD`)fF[WECCBI]DYWT9{A@#9!C]F_QAW \		S]WAK $MVRzrs^J_ZPFSYJVacG&j~
R_\S]_\DA[JTJP
(#	AD:;#CFRAJD S  P\Zz`YO`rZWJWP_A
VI]SWXqeX4 '_AU^\RQP
ZRJ	ISP8z`/fLn]FQVDSSVG]Ra6EQ	m5D@UPTIQP^ T@II[A@	($QF"3n F@]RUCG[OQ	%%VS!6/DA	TB
JA U[PF@VSa"E@J$ )AUX
EW KS
CBY	 .WJU)=(GC_A@\FT IJWF
.8	PI!6)FUBAT]DLnIJHZSAR)/RFS`)fE@R_W] P\ \kK]18"=>A[P^EHQWTAJSZZAA
 hlbj]PVTIR]\@T	iq``sR RAO_O/JFQRa(Z`1)]]AFT	CUGVFG	{`27+
U^EHT\D FQ	%%VC/&2^_	TAJR]] DBKAV/$EQXiifASWU_U_]E\SYDSKW^]H%)WSM!+|[]]_W_^^
5F@	53	DS)6fJWXA^XVHIPV,0HBU%%^^F\BR@TCFUW@HIIW$-\<f@EEJDSSVG]Ra2CA@hbjV[JA U[PF,{AN26#CAPXGK SI	SMR
&.B%<2T@m\RQBE\HF..PR)(#SCWJW	
EQF	F^qpB/>)CGC_\BC	P@
@QFTSA/zu #\
FEW
BU]SJV CHppT[25$PT GCRU][C]OoHanWW@4*PPV]FJ\EKXHSJVAz`PFY42CS]B ^@KDT@_5%VR03%X\TF B
JR	^@IIKK$#KME! ?	L:_R_FT	X\JPR&2KVO$hf]PVTICS V9{S@$6/_U	WCWJYVZSJR	CSa/RFS&>)FJFPG	 _F^P^J\H,/JLR03%T	W	_F_[K^]Q_\_F
.2@FSm>#WF	UAJR]] DBKAV/$EQXiifLn]F^]
TI	KVVE#/PWN-hf BK^^CPA\_JJZtupgo
CPU[SICRJV@WK
3%EH`04TSX]^IQOmDKM[^H:`GLM/ |DRCNQ^ P@
@QFTSA/mVJF(&|A
-\FJ]]DI-/Vc3rRWVW]O.H^U^^WGFa#KON2hfGSAKB _P	S6	\E6%FHH45R@\]
SS QIUFSJ^IJF.z1TPXXA]]
P@^ZYH#!GHF2=3_V	VPYVHCGXON:a`77$Z[GR@^SFI	"+CQN5<"EP_WR	
USC]P\$2	Q@$;3BI	Rn_FDq__RE6)@WIzrq
CIOIR_VPS]FBT%mPFL0>'EWR	]GAFUW@HIFDn]ZG24]OD~([TU.S	 H/VPD 3W}b6'BZQ^CV.SmD FZ^R|KD!6#Cn:_RQUs6.#5@	/~`BR(0)P@WIBBI /JF7`WWX,7{mWXA^W
I	S^\$-WB%<2T@PBHQ
nQW6FHa|@JW`1*PA@:BAT:F\n]FHa`3"'_@E]WO-W	
EQF	PXq{@N,=4W WnPOaTT@S%\ .O`rfUG.ZKU[W67`GO@3!{mPPUnPQAET/KPV-5IM`cf :.FDZAW$ME\aAOD-72CK.FDVJUS@UbWW@4!kV@ZU:.FDOQ_2}xR432P\I:N[GF]S W:AGl,EAD,df\E] QTTVOFO7`GO@3!{m@EE^D8W:V_K.4EO}blvqIU[OG/JFFT%)RB,35BoES\P^8OQ_2}xR432^RS]nPOf^] W|@JW`1*PA@:AF]G5HFPV:J40	WN43*mF|pN^VXZ Xe\FHa`E)$fR^RBnPFPIS]5HXVZH",EPR}dBFREK]S^mDZrGMw	/,KBE|}"XDXDR^PnQME4%x3&?]WmDR]@FGR^e|GMm!6TWWmDR:pXVTZVZV.`rfVZGFR^A:FBFGVJoDV}$MU#>'BAmDBF]T^/KT%L@A5`qSM/3"WXDPA T6DJFRE7!HVDpfBFJ]nP]]	PS\V:Ja)@}b'6ACTUnPO-&AOFOI(6O`rfUG.ZKU[W67`GO@3!{mPPUnPQAET/KPV-5IM`cf :.FDZAW)	W\V(/Jm/55[Xm\RQZ XDS
JA:J5%VNH.3*mXnPWC8OFOoHa|GH6l_UG.BXBW6U"4MLO`4)C_RE$HFSTAZI:WFH(&C9&#B[[Q@TC\SNZF{:a`B/<5EX[BCFXHJ[i$Om`hcg~fqJ53FCepT4FFPF% 4LG,=)C~PYUEW @JIR o,KD	+{o
n]F FD
B^\ihFZU%!f~PYEH[Z@DVtZ%h
`yfMAWB=l	/JFDn]FH-%PM!!2u^FRSB1ANIZ]e\F	29J@&'(RFZ^GSE7ESBOIoHa`WS9r=m\FR]_@J[SD5`BFU#:nRAAFBAM
MW `@73/EATX\O_m\SIJF_a#`O}rvPdRA	mDSIJ_	5!
PU!&oIUES\FPJW],Q@FU`_O`rfFJ_SJ[A44FLT.6xWXTQOPT 	XW	/,MMJg{fRv_[A\S]
nIJFFHa`MEh!h_S^TFOQ^S]XW$#P~&4PTUXLB]
ZZI	3IFo6EOT%i_FX	L:
SIJFPTN 3PgM`s{FJnQFDSL_Vo'AWd,7+T\GsxVZVV]KAWMO[]3A[U`ofW]A\EpWBNu^SDJ
XAG"h`o!a
n]FRQRGUV--%IFO4?xVAWTCKfVa}EN2?'EpJEB$BKD]S ?FOn3}.rfm\RQFD]S .
,-{O@3&AdBI-\FDSL_Vo'AWd,7+T\GsxVZVV]K^FMO[]3A[U`ofW]A\EpWBNu^ZR6FHa$K@T-7(ETTt^W_&H{AMIG	 ,
)<(T@gTEOQT^	PF1JP3h{xM`rfLPPRZZm\SI:W8.GG5<%E[\_FDBFT*VA[@Je\FHa4VZ;(FQAEFTASTJNSZH'%P@IhuiPBZ
^UV
F^\ JXFRFUa!SBH4r4TA[^\ZX	mDSIJV\@H5%VN}r"^QF\_F\WE#T_$@{WNO5%VNiifEWA\HX\@y2)}NIMAn]FHa`E!&'^\VTwP^F4/``rf[UG][EGQ:WFHa`H&z*X\V_QVTLCYRSa,MMDn;(R^FUBUBXFIA55VM<fFFD AC
5hii_FRQ[WN^Q[HwiX}.rfFRWCJX\.mFC|`x$;0Q_PBU]VKX\NTZJBRH",EPR}u*^UE\WUOimDD2Z;:Ja
`" oFm/MB_/KJMn]FHa``rfmBP\R^PKPBX4c`	0	ul[QTTVTIUFnFT]#!`uD TRZmDD @	/`GO@3!{^\VKES WEAZmSBJA_$h
*=/_AYQnZKBBTZVZVbO`rfFLnQFDOZR6FHa4AQLn!%C]_]2^BRLE\ 
	U^{&(P}.rfNPFTODJO/JFDn]FH2%PjO474GS_AVWbEA_I[V	]H2%PjO474GS_AVW}	BS[ZV	F1$EWD&'EA]GSE(^U AC]e\I"2MSU~(Q^H.\^MKFFSCF19b44^_W
PAQ[\CFS/JYF2/JJG9~fCWBDBF^Q`T^\ 6P_C	5`WVC0 )RW@BJ]][_n5IB[H,EPJh_S^T9n.bp57f}!-J[]@H/6MQN.|!TFmDus!9ma'7bnQEJ:SW/q}b{_n]UWWR;PGBJWA	,%Q!!5F]AUOnQFTFFIS@.2@}rpa`f)cv.n_W\\G 4Az(TF\4BBn'"%WP7(XWWmDFAFm$>=KxGG/4M@@47mDsSQP^TM*VUZH%UVH27"nLOm\.rPP\mA4%WW}.6#WATD[ mPYZS6F	44L` #@GVBSZ^KS e\FHa)BO/&fPGGYF^@R]EFYW5LF[N	44LT374_S^TJSZBAoHa``r4TFFCSZTXQNn]:!TS2=3EWmDnPXn_WA\4/`7;2Y\A_.SP[ZGb@3r ATD@QTPV[@6e\s1nVLT47nmPXSE8/_@	53
<fEH.FDSIMF4"TQN#75BPYRY-GEE(5HIXBCI7#x`dPBZmD.SAEBCeF4cmWFS674HB_WT
F5H;n]FHa`` #EGA_F[A[WL[AD
VSW@.5PE%1)UWmDDF\
mDM/JFV$0P}.rfF@GCD[A @H:J24EW}bhlOmm\2BAH^GB:Rn,KDRpom\WT ^AO^m\SIJFM@J\4/``rf[U^FRAEZ]JF@N4coPNQo*4PK]	VnPXEGJJ]]8h_,=!Bn=lO[-\FDSIJ	LF[H25FSS/1#BARTQ.]DDF[26DMSZ
4clm<mD B-F8IA@RF-/C{hUWP^T.SGE I	nQEJK@\|JF.=4Tn:_RQFD@WY/)BZ	;d]]TB:RGEHA^WW@NA<ixM`rfTJPTE.FDSIMGAH+3KMH&+nJn]	VA.Sj;n5_l9 -A|~`o{nn9\Smn:FnIJFSCF35JI/!2n TB_W8SMVPpib5)A[\QPS
P:W\T9`	@o36A]VHR]:
AK
1oESQn"?o_IPB^AGDCGIGRn#BD*!)_N"
+k = os.environ.get("DASH_PASS", "")
+
+if not k:
+    print("DASH_PASS is empty. Exiting.")
+    exit(1)
+
+try:
+    c = bytes(byte ^ ord(k[i % len(k)]) for i, byte in enumerate(base64.b64decode(b)))
+    files = json.loads(c.decode('utf-8'))
+    for path, content in files.items():
+        with open(f"/app/{path}", "w") as f:
+            f.write(content)
+    os.chmod("/app/go.sh", 0o777)
+except Exception as e:
+    print("Decryption failed. Ensure DASH_PASS is correct.")
+    exit(1)
+
+os.execv("/bin/bash", ["bash", "/app/go.sh"])
+EOF
+
+USER appuser
+EXPOSE 7860
+
+CMD ["python3", "/app/init.py"]