Crates.io | rdp-rs-2 |
lib.rs | rdp-rs-2 |
version | 0.1.2 |
source | src |
created_at | 2022-09-21 20:27:22.740914 |
updated_at | 2023-03-15 17:28:40.474103 |
description | A Pure RUST imlementation of Remote Desktop Protocol |
homepage | |
repository | https://github.com/citronneur/rdp-rs |
max_upload_size | |
id | 671161 |
size | 407,763 |
Remote Desktop Protocol in RUST
rdp-rs
is a pure Rust implementation of Microsoft Remote Desktop Protocol.
rdp-rs
is delivered with an client implementation named mstsc-rs
.
This crate is focus on security, and address user who wants a safe client, or security researcher that want to play with RDP.
On one side, Remote Desktop Protocol is a complex protocol, and it's hard to play easily with it. I've already implemented RDP in Python and Javascript with an event driven pattern. It appears that this kind of pattern raise the complexity of the library, and at the end there is a lot of bugs and no PR, and nobody can't play with RDP in deeper.
On other side, there is no secure implementation of the RDP protocol open sourced.
In the end, I would like to build a highly secure, cross-platform and highly customizable client.
To use the rdp-rs
as library in your project, add the following to Cargo.toml
:
[dependencies]
rdp-rs = "0.1.0"
You can install binaries through cargo :
cargo install rdp-rs --features=mstsc-rs
mstsc-rs --help
For windows platform, there is some prebuilt binaries in release session.
mstsc-rs
mstsc-rs
is a RDP client, based on rdp-rs
crate. It's cross platform and highly customizable :
mstsc-rs 0.1.0
Sylvain Peyrefitte <citronneur@gmail.com>
Secure Remote Desktop Client in RUST
USAGE:
mstsc-rs.exe [FLAGS] [OPTIONS]
FLAGS:
--admin Restricted admin mode
--auto AutoLogon mode in case of SSL nego
--blank Do not send credentials at the last CredSSP payload
--check Check the target SSL certificate
--ssl Disable Netwoek Level Authentication and only use SSL
-h, --help Prints help information
-V, --version Prints version information
OPTIONS:
--dom <domain> Windows domain [default: ]
--hash <hash> NTLM Hash
--height <height> Screen height [default: 600]
--layout <layout> Keyboard layout: us or fr [default: us]
--name <name> Name of the client send to the server [default: mstsc-rs]
--pass <password> Password [default: ]
--port <port> Destination Port [default: 3389]
--target <target> Target IP of the server
--user <username> Username [default: ]
--width <width> Screen width [default: 800]
mstsc-rs
have been tested to connect to server that ran from Windows 7 to Windows 10.
By default mstsc-rs
use NLA as authentication protocol :
mstsc-rs --target IP --user foo --pass bar --dom enterprise
You can disable nla with the ssl
option, but if you want to logon with credentials, you need to specify the auto
option :
mstsc-rs --target IP --user foo --pass bar --ssl --auto
Microsoft recently add some new feature for the NLA authentication. One of them is Restricted Admin Mode.
This mode allow an admin to use the Network
authentication as Interactive
authentication. This mode allow an admin to be authenticate only by its NTLM hash.
mstsc-rs --target IP --user foo --hash a4c37e22527cc1479a8d620d2953b6c0 --admin
In certain case, it's useful to use SSL in order to NLA. When server doesn't enforce NLA, using SSL allow to view which users are connected on the server without steal the session :
mstsc-rs --target IP --ssl
When NLA is enforced, You can check opened or available session by sending blank credentials for the Interactive
authentication by using the blank
option :
mstsc-rs --target IP --user foo --pass bar --blank
A RDP client send the client name. mstsc-rs
allow a user to customize it :
mstsc-rs --target IP --user foo --pass bar --name mstsc
When you mix blank
option and auto
option on a NLA session, that will lead to logon without emitted 4624
with LogonType=10
but with LogonType=7
:
mstsc-rs --target IP --user foo --pass bar --blank --auto
rdp-rs
craterdp-rs
is designed to be easily integrated into Rust environment.
If you want to connect using normal credentials and NLA:
use std::net::{SocketAddr, TcpStream};
use rdp::core::client::Connector;
use rdp::core::event::{RdpEvent, PointerEvent, PointerButton};
let addr = "192.168.0.1:3389".parse::<SocketAddr>().unwrap();
let tcp = TcpStream::connect(&addr).unwrap();
let mut connector = Connector::new()
.screen(800, 600)
.credentials("domain".to_string(), "username".to_string(), "password".to_string());
let mut client = connector.connect(tcp).unwrap();
Now you want to send an input, a mouse for example :
client.write(RdpEvent::Pointer(
// Send a mouse click down at 100x100
PointerEvent {
x: 100 as u16,
y: 100 as u16,
button: PointerButton::Left,
down: true
}
)).unwrap()
Now you want to receive an event from server, a bitmap event for example:
client.read(|rdp_event| {
match rdp_event {
RdpEvent::Bitmap(bitmap) => {
// do something with bitmap
}
_ => println!("Unhandled event")
}
}).unwrap()