RustShell - A TCP shell listener written in Rust
---------------------------------------------------------------------------------------------
Disclaimer: This project is designed strictly for educational and ethical purposes and is not
designed for anything other than that. Do not use this tool on systems that you:
1. Don't have explicit permission to test
2. Don't own or aren't deployed by you
The author of this tool assumes no responsibility from misuse.
What is RustShell?
---------------------------------------------------------------------------------------------
This is RustShell - a Project I came up with in my spare time to add to my GitHub portfolio.
RustShell is a fairly barebones TCP listener designed to catch reverse shells. It technically
functions no differently from Netcat in terms of catching TCP connections, but includes an
actual UI and accepts arguments from the CLI to perform its basic functions.
RustShell includes in "in-shell" menu with which you can perform certain functions outside of
the scope of the reverse shell. It also includes a built in syntax generator for a basic reverse
shell. Some supported formats currently among others are:
- Python3
- Netcat
- Nc.exe
- PHP Pentestmonkey
Basic usage:
----------------------------------------------------------------------------------------------
RustShell can be used with flags from the CLI, or can be started up without flags. To start the
program without flags, type:
rustshell
If the program is started without flags, it will bring you to the main menu, where you will be
prompted to enter an option. The currently supported options are:
1. Start a reverse shell listener
2. Generate reverse shell syntax
3. Exit doing nothing
If RustShell is started with flags, they will be treated as though you entered in options from
this menu automatically. The flags currently supported are:
- -m or --mode: The mode to use RustShell in. Valid options are either listen, or generate
- -f or --format (only applies to generate mode): Specify the format syntax for syntax generator
- -s or --shell: Specify the shell you want to use for the format generator
- -l or --lport (applies to both listen and generate): The local IP to listen on
- -p or --lport (applies to both listen and generate): The local port to listen on
When a connection is established, you will see a prompt indicating you've received a TCP
connection. From there, you can interact with the target system and send commands. RustShell
also includes an "in-shell" menu where you can issue commands to your local system, in case you
need a quick local shell for anything. It also includes other basic functions, such as a help
menu. Other features for the in-shell menu are planned.
To enter the in-shell menu, type "rs:" to bring up the menu prompt. From here, you can type
regular shell commands to execute them on your local system. You can also type "-help" to bring
up a menu of commands. Currently RustShell doesn't include many commands, but I will add more
functionality as I think of them or receive more feedback.
to disconnect the shell at any time, you can enter "exit" into the command menu. This will send
an exit command to the machine and at the same time clean up from the reverse shell. This has
created a slight problem in that if you have become root on a target machine and type "exit",
The shell will be disconnected and cleaned up. Session handling with the exit keyword will be
improved within future versions.
Several planned features are coming, among them are:
- The ability to create bind shells instead of only being reverse shells:
This function will allow you to create a bind shell listener instead of a reverse shell listener
just to add more options for the end user. Of course, this function will rely upon the target
system having Rust installed, which can be a case by case issue. I don't see this function being
used as much as the reverse shell mode, but full functionality is important to me.
- An interactive shell mode inside the "in-shell" menu:
The current "in-shell" menu is not as interactive as I would like and only includes the ability
to issue your local system commands. I will currently keep the "in-shell" menu how it is but
add a new menu option named "-interactive", which will put your session into an actual shell
session, which will include directory browsing and all that, rather than just the ability to
execute local commands, in case the user needs a fully interactive local shell. Of course, it is
pretty easy for the user to just open up another terminal, and in some cases, faster, but "moar
features", am I right?
Examples:
-----------------------------------------------------------------------------------------------
- "rustshell" - start RustShell with no flags, bringing you directly to the main menu
- "rustshell -m listen" - Start RustShell in listen mode, where you will be prompted for the IP and
Port to listen on.
- "rustshell -m listen -l (IP) -p (port)" - Start RustShell in listen mode on IP:Port. You will not
have to enter any other menu options, and will immediately start listening on that IP and port.
- "rustshell -m generate" - Start RustShell in generate mode. You will be prompted for the IP, Port,
Format, and shell parameters. After that, RustShell will generate syntax for you to use in your
requested format.
- "rustshell -m generate -f (Format) -s (Shell) -l (IP) -p (Port)" - Start RustShell in generate mode,
You will not be prompted for anything as long as your parameters are valid, and syntax will be
gerated for you immediately
About the Author:
-----------------------------------------------------------------------------------------------
Hello! If you're using this tool, I appreciate your support! Please keep in mind that I am a
lone developer. I won't claim that this code is good, but I don't believe this code is bad either.
I have a few more projects in mind that I would like to implement as well, but am currently
focused on developing RustShell as well as learning other cybersecurity topics. This purpose of
this project is pure educational. I had decided that I wanted to learn more about how cybersecurity
tools use TCP connections to perform their functions. When I began this project, I had no idea how
to build software capable of TCP connections and didn't even know how other software such as Netcat
performed their basic functions. By building this piece of software, I learned several details:
- Basic programming in the Rust language and how it differs from other languages
- TCP Networking and building software that uses sockets
- How software utilized TCP Data Streams and how to read and write to those streams
- Creating security auditing tools
- CLI Software Design
------------------------------------------------------------------------------------------------
Now, GO AND CATCH THOSE SHELLS!