Uploading Executables when Uploading isnt an Option

Viewing 10 reply threads
  • Author
    Posts
    • #5002
      Dark_Knight
      Participant

      Sheer poetry  🙂 🙂 🙂
      http://www.i-hacked.com/content/view/288/42/

      Recently I needed a way of building an executable on a remote machine using only a keyboard. Basically I needed to “type out an executable” (think of it as I had a very basic “ah-hem” shell that I wanted to make more secure). Because my target host was Windows based, it is not as easy as uploading and compiling from source. I could of course simply use tricks found at http://commandlinekungfu.com  to download the file, however I wanted to find a solution where this system didn’t create any outgoing requests that resulted in the downloading of an executable. The technique described below is already being used by some very common cyber-security tools such as Fasttrack and sqlmap. It is an interesting solution, one that might help you out with a project in the future.

      The problem is that you cant simply type out an executable binary. There are multiple characters that are not printable ascii, so your binary will fail if you try. However there are some tools that will allow us to convert the already compiled binary into ascii printable debug scripts, which can be reassembled using the native debug command on windows machines. Thus creating a “portable” binary that is Ascii printable, therefore gives us the ability to “type out an executable”

      In order to do this we need a few things:

         *
           The Executable we want to transfer
         *
           UPX Packer (not needed but helpful)
         *
           dbgtool (Python / Windows)

      For this article we will be using the windows Ncat binary (http://nmap.org/ncat/) and since my machine is OSX, the python based tools in our example.

      Ncat

          Ncat is a feature-packed networking utility which will read and write data across a network from the command line.
          Ncat was written for the Nmap Project as a much-improved reimplementation of the venerable Netcat. It uses both TCP
          and UDP for communication and is designed to be a reliable back-end tool to instantly provide network connectivity to
          other applications and users. Ncat will not only work with IPv4 and IPv6 but provides the user with a virtually limitless
          number of potential uses.

      Because our target is a windows host, we need to download and unpack nmap for Windows (ncat now is packaged with nmap). Because we are going to communicating this executable via ?keyboard? or some other slow method, we would be smart to compress this file as much as possible before we convert it. We will need to use a packer that self decompresses and retains the ability to execute.

         UPX is a free, portable, extendable, high-performance executable packer for several different executable formats. It achieves an excellent compression ratio and offers very fast decompression. Your executables suffer no memory overhead or other drawbacks for most of the formats supported, because of in-place decompression.

      Install UPX on your system:

         *
           OSX: sudo port install upx
         *
           Debian: sudo apt-get install upx-nrv
         *
           Windows: Download

      As you can see below, ncat can be compressed over 32% – totally worth it. (be warned, UPX packing executables decreases the stealthyness)

         hevnsnt$ upx -9 -o ncat-upx.exe ncat.exe
                              Ultimate Packer for eXecutables
                                 Copyright (C) 1996 – 2009
         UPX 3.05w       Markus Oberhumer, Laszlo Molnar & John Reiser   Apr 27th 2010
               File size         Ratio      Format      Name
         


       


       


       


           175104 ->     57344   32.75%    win32/pe     ncat-upx.exe

      Next we need to convert the UPX packed binary into a ASCII debug script, using the dbtool listed above:

         python ./dbgtool.py -i ncat-upx.exe -o ncat-upx.scr

      Take a second and open the ncat-upx.scr in whatever your favorite text editor is. As you can see, you now have a portable executable that is in printable ASCII.

      Upload nc_upx.scr to the target Windows system (either by pasting in your shell, or however you need to do it) and then reconvert your binary to an executable with the following command: debugdebug    e df0c 4c 6f 61 64 4c 69 62 72 61 72 79 41
         e df1a 47 65 74 50 72 6f 63 41 64 64 72 65 73 73
         e df2a 56 69 72 74 75 61 6c 50 72 6f 74 65 63 74
         


      SNIP



      This debug script will write a new file named #TEMP#. Simply rename this file to ncat-upx.exe and execute. Better get your ncat-fu ready, because your super over complicated, slow, ninja file upload is complete!

    • #31686
      Ketchup
      Participant

      That’s pretty sweet!  I will have to try this out.

    • #31687
      Anquilas
      Participant

      Sounds sweet, thanks!

    • #31688
      Xen
      Participant

      Read it yesterday. It was a hit on twitter.
      Excellent article! Thanks for posting it at EH.

    • #31689
      caissyd
      Participant

      Ahhh! Great article Dark_Knight.

      We need more of these!!!

    • #31690
      bamed
      Participant

      FYI, I didn’t see it mentioned in the article, but if you browse to /pentest/windows-binaries/tools/nc.txt on the latest backtrack 4, you will find line for line how to do the above.  It’s basically a batch file that creates the .hex file, then compiles with debug.  You can just copy/paste into a CLI.  Pretty sweet stuff.

    • #31691
      SecMan
      Participant

      Nice article.  But there are two things that should be mentioned:

      1. The maximum file size is 64K since debug can’t handle anything bigger.

      2. Although he selected ncat.exe as the binary, I think it wasn’t a very good choice.  ncat.exe has quite a lot of dependencies including the Microsoft Visual C++ Redistributable Package (http://nmap.org/download.html) and I’d love to see how you can use it in a penetration test given its dependencies.  Any ideas?

      Thanks.

    • #31692
      Ketchup
      Participant

      I would think that you can just run the debug command multiple times and append the resulting files into a single file to overcome the 64K limit.  The same can be done for the vcrun libraries. 

    • #31693
      SecMan
      Participant

      Ketchup, did you successfully try it?  When I placed the vcrun libraries in the same directory, it still wouldn’t work.  Is there some command I have to run first for example?  Thanks.

    • #31694
      DaberMania
      Participant

      That is a very useful way to copy files.  After some research I found another way that this can be done without needed to use debug.  You also do not have a file size limit.  I have full detailed directions on my blog, however, here is a simple summary of what happens:

      Identify a executable that you wish to transfer
      Create the VBScript to encode the executable to Base64
      Transfer the ASCII text output to your victim computer
      Create a VBScript on the victim computer to decode the ASCII  text

      The full topic can be found here: http://dabermania.blogspot.com/2011/03/converting-any-file-to-ascii-for.html

    • #31695
      tturner
      Participant

      I seem to recall a trick using DNS text records and then build the exe with debug that could be used here as well. I forget where I heard about it though.

Viewing 10 reply threads
  • You must be logged in to reply to this topic.

Copyright ©2021 Caendra, Inc.

Contact Us

Thoughts, suggestions, issues? Send us an email, and we'll get back to you.

Sending

Sign in with Caendra

Forgot password?Sign up

Forgot your details?