self-hosted/teleport
self-hosted/teleport
1
0
Fork 0
mirror of https://github.com/gravitational/teleport synced 2024-10-20 17:23:22 +00:00
Code Issues Packages Projects Releases Wiki Activity
teleport/lib/srv/desktop/rdp/rdpclient/Cargo.lock

1116 lines
28 KiB
Plaintext
Raw Normal View History

RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
Add Rust to buildbox - Ensure Rust is installed in the buildbox image - Install Rust toolchains for each arch we support - Use openssl's vendor feature to ensure we always link a static lib - Automatically include RDP client if Rust is detected
2021-10-26 15:22:13 +00:00
version = 3
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
[[package]]
name = "aho-corasick"
version = "0.7.18"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1e37cfd5e7657ada45f742d6e99ca5788580b5c529dc78faf11ece6dc702656f"
dependencies = [
"memchr",
]
[[package]]
name = "arrayvec"
version = "0.5.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "23b62fc65de8e4e7f52534fb52b0f3ed04746ae267519eef2a83941e8085068b"
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
[[package]]
name = "atomic-polyfill"
TDP: add mouse scroll support
2021-10-01 22:08:22 +00:00
version = "0.1.4"
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
TDP: add mouse scroll support
2021-10-01 22:08:22 +00:00
checksum = "053f1ab4712fe8c55de46932b46ecc774ae7906278ddf7fc2fbaaaa663b84392"
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
dependencies = [
TDP: add mouse scroll support
2021-10-01 22:08:22 +00:00
"critical-section",
"riscv-target",
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
]
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
[[package]]
name = "atty"
version = "0.2.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
dependencies = [
"hermit-abi",
"libc",
"winapi",
]
[[package]]
name = "autocfg"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
[[package]]
name = "bare-metal"
version = "0.2.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5deb64efa5bd81e31fcd1938615a6d98c82eafcbcd787162b6f63b91d6bac5b3"
dependencies = [
"rustc_version",
]
TDP: add mouse scroll support
2021-10-01 22:08:22 +00:00
[[package]]
name = "bare-metal"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f8fe8f5a8a398345e52358e18ff07cc17a568fbca5c6f73873d3a62056309603"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
[[package]]
name = "base64"
version = "0.11.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b41b7ea54a0c9d92199de89e20e58d49f02f8e699814ef3fdf266f6f748d15c7"
TDP: add mouse scroll support
2021-10-01 22:08:22 +00:00
[[package]]
name = "bit_field"
version = "0.10.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dcb6dd1c2376d2e096796e234a70e17e94cc2d5d54ff8ce42b28cef1d0d359a4"
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
[[package]]
name = "bitfield"
version = "0.13.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "46afbd2983a5d5a7bd740ccb198caf5b82f45c40c09c0eed36052d91cb92e719"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
[[package]]
name = "bitflags"
RDPDR virtual channel implementation for smartcards (#8282) * RDPDR virtual channel implementation for smartcards RDPDR stands for "RDP device redirection channel", used to forward smartcard operations from server to client. Establish the channel, register a smartcard device and implement smartcard operations up to actually handling the commands. The implementation ends at SCARD_IOCTL_TRANSMIT, where we will implement an emulator for a PC/SC smartcard with a Teleport certificate. * Address review feedback
2021-09-22 21:30:13 +00:00
version = "1.3.2"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
RDPDR virtual channel implementation for smartcards (#8282) * RDPDR virtual channel implementation for smartcards RDPDR stands for "RDP device redirection channel", used to forward smartcard operations from server to client. Establish the channel, register a smartcard device and implement smartcard operations up to actually handling the commands. The implementation ends at SCARD_IOCTL_TRANSMIT, where we will implement an emulator for a PC/SC smartcard with a Teleport certificate. * Address review feedback
2021-09-22 21:30:13 +00:00
checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
[[package]]
name = "block-buffer"
version = "0.7.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c0940dc441f31689269e10ac70eb1002a3a1d3ad1390e030043662eb7fe4688b"
dependencies = [
"block-padding",
"byte-tools",
"byteorder",
"generic-array",
]
[[package]]
name = "block-padding"
version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fa79dedbb091f449f1f39e53edf88d5dbe95f895dae6135a8d7b881fb5af73f5"
dependencies = [
"byte-tools",
]
[[package]]
name = "bufstream"
version = "0.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "40e38929add23cdf8a366df9b0e088953150724bcbe5fc330b0d8eb3b328eec8"
[[package]]
name = "byte-tools"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e3b5ca7a04898ad4bcd41c90c5285445ff5b791899bb1b0abdd2a2aa791211d7"
[[package]]
name = "byteorder"
version = "1.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
[[package]]
name = "cc"
Rust & Desktop Access fixes (#8822) * update deps in manifest and lockfile * fixes and updates to docker and profiles * lint rust * fix typo * resolve clippy lints * fix typo * mark risk functions unsafe * fmt + clean up the last lints# * verify lockfile up to date * disable lto since it doesn't work with two rust libs * merge lock check and lint * Add missing license header to Rust files And update Makefile to ensure they are checked Co-authored-by: Zac Bergquist <zac.bergquist@goteleport.com>
2021-11-05 19:35:20 +00:00
version = "1.0.71"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Rust & Desktop Access fixes (#8822) * update deps in manifest and lockfile * fixes and updates to docker and profiles * lint rust * fix typo * resolve clippy lints * fix typo * mark risk functions unsafe * fmt + clean up the last lints# * verify lockfile up to date * disable lto since it doesn't work with two rust libs * merge lock check and lint * Add missing license header to Rust files And update Makefile to ensure they are checked Co-authored-by: Zac Bergquist <zac.bergquist@goteleport.com>
2021-11-05 19:35:20 +00:00
checksum = "79c2681d6594606957bbb8631c4b90a7fcaaa72cdb714743a437b156d6a7eedd"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
[[package]]
name = "cfg-if"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
[[package]]
name = "core-foundation"
Rust & Desktop Access fixes (#8822) * update deps in manifest and lockfile * fixes and updates to docker and profiles * lint rust * fix typo * resolve clippy lints * fix typo * mark risk functions unsafe * fmt + clean up the last lints# * verify lockfile up to date * disable lto since it doesn't work with two rust libs * merge lock check and lint * Add missing license header to Rust files And update Makefile to ensure they are checked Co-authored-by: Zac Bergquist <zac.bergquist@goteleport.com>
2021-11-05 19:35:20 +00:00
version = "0.9.2"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Rust & Desktop Access fixes (#8822) * update deps in manifest and lockfile * fixes and updates to docker and profiles * lint rust * fix typo * resolve clippy lints * fix typo * mark risk functions unsafe * fmt + clean up the last lints# * verify lockfile up to date * disable lto since it doesn't work with two rust libs * merge lock check and lint * Add missing license header to Rust files And update Makefile to ensure they are checked Co-authored-by: Zac Bergquist <zac.bergquist@goteleport.com>
2021-11-05 19:35:20 +00:00
checksum = "6888e10551bb93e424d8df1d07f1a8b4fceb0001a3a4b048bfc47554946f47b3"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
dependencies = [
"core-foundation-sys",
"libc",
]
[[package]]
name = "core-foundation-sys"
Rust & Desktop Access fixes (#8822) * update deps in manifest and lockfile * fixes and updates to docker and profiles * lint rust * fix typo * resolve clippy lints * fix typo * mark risk functions unsafe * fmt + clean up the last lints# * verify lockfile up to date * disable lto since it doesn't work with two rust libs * merge lock check and lint * Add missing license header to Rust files And update Makefile to ensure they are checked Co-authored-by: Zac Bergquist <zac.bergquist@goteleport.com>
2021-11-05 19:35:20 +00:00
version = "0.8.3"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Rust & Desktop Access fixes (#8822) * update deps in manifest and lockfile * fixes and updates to docker and profiles * lint rust * fix typo * resolve clippy lints * fix typo * mark risk functions unsafe * fmt + clean up the last lints# * verify lockfile up to date * disable lto since it doesn't work with two rust libs * merge lock check and lint * Add missing license header to Rust files And update Makefile to ensure they are checked Co-authored-by: Zac Bergquist <zac.bergquist@goteleport.com>
2021-11-05 19:35:20 +00:00
checksum = "5827cebf4670468b8772dd191856768aedcb1b0278a04f989f7766351917b9dc"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
[[package]]
name = "cortex-m"
version = "0.7.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2ac919ef424449ec8c08d515590ce15d9262c0ca5f0da5b0c901e971a3b783b3"
dependencies = [
TDP: add mouse scroll support
2021-10-01 22:08:22 +00:00
"bare-metal 0.2.5",
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
"bitfield",
"embedded-hal",
"volatile-register",
]
TDP: add mouse scroll support
2021-10-01 22:08:22 +00:00
[[package]]
name = "critical-section"
version = "0.2.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "673b836c1c5a73bd981805236f46dfddbe1092a6a829b22464bd40d7ceefd2f9"
dependencies = [
"bare-metal 1.0.0",
"cfg-if",
"cortex-m",
"riscv",
]
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
[[package]]
name = "crypto-mac"
version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4434400df11d95d556bac068ddfedd482915eb18fe8bea89bc80b6e4b1c179e5"
dependencies = [
"generic-array",
"subtle",
]
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
[[package]]
name = "delog"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1abe705f4932cb84b67569a7e05cda7ffc9b8847980b2e1cf290f41045eea73b"
dependencies = [
"log",
]
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
[[package]]
name = "der-parser"
version = "3.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f51f64dcdf1cdc550d21d73dc959726c7dbeeab4a01481d08084a7736956464e"
dependencies = [
"nom",
"num-bigint",
"rusticata-macros",
]
[[package]]
name = "derivative"
version = "2.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fcc3dd5e9e9c0b295d6e1e4d811fb6f157d5ffd784b8d202fc62eac8035a770b"
dependencies = [
"proc-macro2",
"quote",
"syn",
]
[[package]]
name = "digest"
version = "0.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f3d0c8c8752312f9713efd397ff63acb9f85585afbf179282e720e7704954dd5"
dependencies = [
"generic-array",
]
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
[[package]]
name = "embedded-hal"
version = "0.2.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e36cfb62ff156596c892272f3015ef952fe1525e85261fa3a7f327bd6b384ab9"
dependencies = [
"nb 0.1.3",
"void",
]
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
[[package]]
name = "env_logger"
version = "0.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0b2cf0344971ee6c64c31be0d530793fba457d322dfec2810c453d0ef228f9c3"
dependencies = [
"atty",
"humantime",
"log",
"regex",
"termcolor",
]
[[package]]
name = "fake-simd"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e88a8acf291dafb59c2d96e8f59828f3838bb1a70398823ade51a84de6a6deed"
[[package]]
name = "foreign-types"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
dependencies = [
"foreign-types-shared",
]
[[package]]
name = "foreign-types-shared"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
[[package]]
name = "generic-array"
version = "0.12.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ffdf9f34f1447443d37393cc6c2b8313aebddcd96906caf34e54c68d8e57d7bd"
dependencies = [
"typenum",
]
[[package]]
name = "getrandom"
version = "0.1.16"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce"
dependencies = [
"cfg-if",
"libc",
"wasi 0.9.0+wasi-snapshot-preview1",
]
[[package]]
name = "getrandom"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7fcd999463524c52659517fe2cea98493cfe485d10565e7b0fb07dbba7ad2753"
dependencies = [
"cfg-if",
"libc",
"wasi 0.10.2+wasi-snapshot-preview1",
]
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
[[package]]
name = "hash32"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b0c35f58762feb77d74ebe43bdbc3210f09be9fe6742234d573bacc26ed92b67"
dependencies = [
"byteorder",
]
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
[[package]]
name = "hashbrown"
version = "0.11.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
[[package]]
name = "heapless"
version = "0.7.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fe65ef062f1af5b1b189842b0bc45bd671c38e1d22c6aa22e6ada03d01026d53"
dependencies = [
"atomic-polyfill",
"hash32",
"spin",
"stable_deref_trait",
]
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
[[package]]
name = "hermit-abi"
version = "0.1.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
dependencies = [
"libc",
]
[[package]]
name = "hmac"
version = "0.7.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5dcb5e64cda4c23119ab41ba960d1e170a774c8e4b9d9e6a9bc18aabf5e59695"
dependencies = [
"crypto-mac",
"digest",
]
[[package]]
name = "humantime"
version = "2.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
[[package]]
name = "indexmap"
version = "1.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bc633605454125dec4b66843673f01c7df2b89479b32e0ed634e43a91cff62a5"
dependencies = [
"autocfg",
"hashbrown",
]
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
[[package]]
name = "iso7816"
version = "0.1.0-alpha.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d5ac1acebaf539ceb318fe516ba0da2bb0bb1285bcf91199fa89ae1cefbfa315"
dependencies = [
"delog",
"heapless",
]
[[package]]
name = "iso7816-tlv"
TDP: add mouse scroll support
2021-10-01 22:08:22 +00:00
version = "0.4.2"
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
TDP: add mouse scroll support
2021-10-01 22:08:22 +00:00
checksum = "395d8e0ae63eb5016fbcf4a72864155880e34bce0158206fcfa7218efdd52e82"
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
dependencies = [
"untrusted",
]
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
[[package]]
name = "lazy_static"
version = "1.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
[[package]]
name = "lexical-core"
version = "0.7.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6607c62aa161d23d17a9072cc5da0be67cdfc89d3afb1e8d9c842bebc2525ffe"
dependencies = [
"arrayvec",
"bitflags",
"cfg-if",
"ryu",
"static_assertions",
]
[[package]]
name = "libc"
Update rdp-rs (#9344) This includes gravitational/rdp-rs#5 which will show a better error message for protocol negotiation failures. Also bump the libc dependency while we're at it. All other crates are still up to date.
2021-12-21 19:14:06 +00:00
version = "0.2.110"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Update rdp-rs (#9344) This includes gravitational/rdp-rs#5 which will show a better error message for protocol negotiation failures. Also bump the libc dependency while we're at it. All other crates are still up to date.
2021-12-21 19:14:06 +00:00
checksum = "b58a4469763e4e3a906c4ed786e1c70512d16aa88f84dded826da42640fc6a1c"
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
[[package]]
name = "lock_api"
version = "0.4.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "712a4d093c9976e24e7dbca41db895dabcbac38eb5f4045393d17a95bdfb1109"
dependencies = [
"scopeguard",
]
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
[[package]]
name = "log"
version = "0.4.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
dependencies = [
"cfg-if",
]
[[package]]
name = "md-5"
version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a18af3dcaf2b0219366cdb4e2af65a6101457b415c3d1a5c71dd9c2b7c77b9c8"
dependencies = [
"block-buffer",
"digest",
"opaque-debug",
]
[[package]]
name = "md4"
version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a4030c65cf2aab7ada769cae7d1e7159f8d034d6ded4f39afba037f094bfd9a1"
dependencies = [
"block-buffer",
"digest",
"fake-simd",
"opaque-debug",
]
[[package]]
name = "memchr"
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
version = "2.4.1"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
checksum = "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
[[package]]
name = "native-tls"
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
version = "0.2.8"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
checksum = "48ba9f7719b5a0f42f338907614285fb5fd70e53858141f69898a1fb7203b24d"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
dependencies = [
"lazy_static",
"libc",
"log",
"openssl",
"openssl-probe",
"openssl-sys",
"schannel",
"security-framework",
"security-framework-sys",
"tempfile",
]
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
[[package]]
name = "nb"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "801d31da0513b6ec5214e9bf433a77966320625a37860f910be265be6e18d06f"
dependencies = [
"nb 1.0.0",
]
[[package]]
name = "nb"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "546c37ac5d9e56f55e73b677106873d9d9f5190605e41a856503623648488cae"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
[[package]]
name = "nom"
version = "5.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ffb4262d26ed83a1c0a33a38fe2bb15797329c85770da05e6b828ddb782627af"
dependencies = [
"lexical-core",
"memchr",
"version_check",
]
[[package]]
name = "num-bigint"
version = "0.2.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "090c7f9998ee0ff65aa5b723e4009f7b217707f1fb5ea551329cc4d6231fb304"
dependencies = [
"autocfg",
"num-integer",
"num-traits",
]
RDPDR virtual channel implementation for smartcards (#8282) * RDPDR virtual channel implementation for smartcards RDPDR stands for "RDP device redirection channel", used to forward smartcard operations from server to client. Establish the channel, register a smartcard device and implement smartcard operations up to actually handling the commands. The implementation ends at SCARD_IOCTL_TRANSMIT, where we will implement an emulator for a PC/SC smartcard with a Teleport certificate. * Address review feedback
2021-09-22 21:30:13 +00:00
[[package]]
name = "num-derive"
version = "0.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "876a53fff98e03a936a674b29568b0e605f06b29372c2489ff4de23f1949743d"
dependencies = [
"proc-macro2",
"quote",
"syn",
]
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
[[package]]
name = "num-integer"
version = "0.1.44"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d2cc698a63b549a70bc047073d2949cce27cd1c7b0a4a862d08a8031bc2801db"
dependencies = [
"autocfg",
"num-traits",
]
[[package]]
name = "num-traits"
version = "0.2.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9a64b1ec5cda2586e284722486d802acf1f7dbdc623e2bfc57e65ca1cd099290"
dependencies = [
"autocfg",
]
[[package]]
name = "num_enum"
version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ca565a7df06f3d4b485494f25ba05da1435950f4dc263440eda7a6fa9b8e36e4"
dependencies = [
"derivative",
"num_enum_derive",
]
[[package]]
name = "num_enum_derive"
version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ffa5a33ddddfee04c0283a7653987d634e880347e96b5b2ed64de07efb59db9d"
dependencies = [
"proc-macro-crate",
"proc-macro2",
"quote",
"syn",
]
[[package]]
name = "once_cell"
version = "1.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "692fcb63b64b1758029e0a96ee63e049ce8c5948587f2f7208df04625e5f6b56"
[[package]]
name = "opaque-debug"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2839e79665f131bdb5782e51f2c6c9599c133c6098982a54c794358bf432529c"
[[package]]
name = "openssl"
Rust & Desktop Access fixes (#8822) * update deps in manifest and lockfile * fixes and updates to docker and profiles * lint rust * fix typo * resolve clippy lints * fix typo * mark risk functions unsafe * fmt + clean up the last lints# * verify lockfile up to date * disable lto since it doesn't work with two rust libs * merge lock check and lint * Add missing license header to Rust files And update Makefile to ensure they are checked Co-authored-by: Zac Bergquist <zac.bergquist@goteleport.com>
2021-11-05 19:35:20 +00:00
version = "0.10.38"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Rust & Desktop Access fixes (#8822) * update deps in manifest and lockfile * fixes and updates to docker and profiles * lint rust * fix typo * resolve clippy lints * fix typo * mark risk functions unsafe * fmt + clean up the last lints# * verify lockfile up to date * disable lto since it doesn't work with two rust libs * merge lock check and lint * Add missing license header to Rust files And update Makefile to ensure they are checked Co-authored-by: Zac Bergquist <zac.bergquist@goteleport.com>
2021-11-05 19:35:20 +00:00
checksum = "0c7ae222234c30df141154f159066c5093ff73b63204dcda7121eb082fc56a95"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
dependencies = [
"bitflags",
"cfg-if",
"foreign-types",
"libc",
"once_cell",
"openssl-sys",
]
[[package]]
name = "openssl-probe"
version = "0.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "28988d872ab76095a6e6ac88d99b54fd267702734fd7ffe610ca27f533ddb95a"
Add Rust to buildbox - Ensure Rust is installed in the buildbox image - Install Rust toolchains for each arch we support - Use openssl's vendor feature to ensure we always link a static lib - Automatically include RDP client if Rust is detected
2021-10-26 15:22:13 +00:00
[[package]]
name = "openssl-src"
Rust & Desktop Access fixes (#8822) * update deps in manifest and lockfile * fixes and updates to docker and profiles * lint rust * fix typo * resolve clippy lints * fix typo * mark risk functions unsafe * fmt + clean up the last lints# * verify lockfile up to date * disable lto since it doesn't work with two rust libs * merge lock check and lint * Add missing license header to Rust files And update Makefile to ensure they are checked Co-authored-by: Zac Bergquist <zac.bergquist@goteleport.com>
2021-11-05 19:35:20 +00:00
version = "300.0.2+3.0.0"
Add Rust to buildbox - Ensure Rust is installed in the buildbox image - Install Rust toolchains for each arch we support - Use openssl's vendor feature to ensure we always link a static lib - Automatically include RDP client if Rust is detected
2021-10-26 15:22:13 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Rust & Desktop Access fixes (#8822) * update deps in manifest and lockfile * fixes and updates to docker and profiles * lint rust * fix typo * resolve clippy lints * fix typo * mark risk functions unsafe * fmt + clean up the last lints# * verify lockfile up to date * disable lto since it doesn't work with two rust libs * merge lock check and lint * Add missing license header to Rust files And update Makefile to ensure they are checked Co-authored-by: Zac Bergquist <zac.bergquist@goteleport.com>
2021-11-05 19:35:20 +00:00
checksum = "14a760a11390b1a5daf72074d4f6ff1a6e772534ae191f999f57e9ee8146d1fb"
Add Rust to buildbox - Ensure Rust is installed in the buildbox image - Install Rust toolchains for each arch we support - Use openssl's vendor feature to ensure we always link a static lib - Automatically include RDP client if Rust is detected
2021-10-26 15:22:13 +00:00
dependencies = [
"cc",
]
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
[[package]]
name = "openssl-sys"
Rust & Desktop Access fixes (#8822) * update deps in manifest and lockfile * fixes and updates to docker and profiles * lint rust * fix typo * resolve clippy lints * fix typo * mark risk functions unsafe * fmt + clean up the last lints# * verify lockfile up to date * disable lto since it doesn't work with two rust libs * merge lock check and lint * Add missing license header to Rust files And update Makefile to ensure they are checked Co-authored-by: Zac Bergquist <zac.bergquist@goteleport.com>
2021-11-05 19:35:20 +00:00
version = "0.9.70"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Rust & Desktop Access fixes (#8822) * update deps in manifest and lockfile * fixes and updates to docker and profiles * lint rust * fix typo * resolve clippy lints * fix typo * mark risk functions unsafe * fmt + clean up the last lints# * verify lockfile up to date * disable lto since it doesn't work with two rust libs * merge lock check and lint * Add missing license header to Rust files And update Makefile to ensure they are checked Co-authored-by: Zac Bergquist <zac.bergquist@goteleport.com>
2021-11-05 19:35:20 +00:00
checksum = "c6517987b3f8226b5da3661dad65ff7f300cc59fb5ea8333ca191fc65fde3edf"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
dependencies = [
"autocfg",
"cc",
"libc",
Add Rust to buildbox - Ensure Rust is installed in the buildbox image - Install Rust toolchains for each arch we support - Use openssl's vendor feature to ensure we always link a static lib - Automatically include RDP client if Rust is detected
2021-10-26 15:22:13 +00:00
"openssl-src",
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
"pkg-config",
"vcpkg",
]
[[package]]
name = "pkg-config"
Rust & Desktop Access fixes (#8822) * update deps in manifest and lockfile * fixes and updates to docker and profiles * lint rust * fix typo * resolve clippy lints * fix typo * mark risk functions unsafe * fmt + clean up the last lints# * verify lockfile up to date * disable lto since it doesn't work with two rust libs * merge lock check and lint * Add missing license header to Rust files And update Makefile to ensure they are checked Co-authored-by: Zac Bergquist <zac.bergquist@goteleport.com>
2021-11-05 19:35:20 +00:00
version = "0.3.22"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Rust & Desktop Access fixes (#8822) * update deps in manifest and lockfile * fixes and updates to docker and profiles * lint rust * fix typo * resolve clippy lints * fix typo * mark risk functions unsafe * fmt + clean up the last lints# * verify lockfile up to date * disable lto since it doesn't work with two rust libs * merge lock check and lint * Add missing license header to Rust files And update Makefile to ensure they are checked Co-authored-by: Zac Bergquist <zac.bergquist@goteleport.com>
2021-11-05 19:35:20 +00:00
checksum = "12295df4f294471248581bc09bef3c38a5e46f1e36d6a37353621a0c6c357e1f"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
[[package]]
name = "ppv-lite86"
Rust & Desktop Access fixes (#8822) * update deps in manifest and lockfile * fixes and updates to docker and profiles * lint rust * fix typo * resolve clippy lints * fix typo * mark risk functions unsafe * fmt + clean up the last lints# * verify lockfile up to date * disable lto since it doesn't work with two rust libs * merge lock check and lint * Add missing license header to Rust files And update Makefile to ensure they are checked Co-authored-by: Zac Bergquist <zac.bergquist@goteleport.com>
2021-11-05 19:35:20 +00:00
version = "0.2.15"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Rust & Desktop Access fixes (#8822) * update deps in manifest and lockfile * fixes and updates to docker and profiles * lint rust * fix typo * resolve clippy lints * fix typo * mark risk functions unsafe * fmt + clean up the last lints# * verify lockfile up to date * disable lto since it doesn't work with two rust libs * merge lock check and lint * Add missing license header to Rust files And update Makefile to ensure they are checked Co-authored-by: Zac Bergquist <zac.bergquist@goteleport.com>
2021-11-05 19:35:20 +00:00
checksum = "ed0cfbc8191465bed66e1718596ee0b0b35d5ee1f41c5df2189d0fe8bde535ba"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
[[package]]
name = "proc-macro-crate"
version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1d6ea3c4595b96363c13943497db34af4460fb474a95c43f4446ad341b8c9785"
dependencies = [
"toml",
]
[[package]]
name = "proc-macro2"
Rust & Desktop Access fixes (#8822) * update deps in manifest and lockfile * fixes and updates to docker and profiles * lint rust * fix typo * resolve clippy lints * fix typo * mark risk functions unsafe * fmt + clean up the last lints# * verify lockfile up to date * disable lto since it doesn't work with two rust libs * merge lock check and lint * Add missing license header to Rust files And update Makefile to ensure they are checked Co-authored-by: Zac Bergquist <zac.bergquist@goteleport.com>
2021-11-05 19:35:20 +00:00
version = "1.0.32"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Rust & Desktop Access fixes (#8822) * update deps in manifest and lockfile * fixes and updates to docker and profiles * lint rust * fix typo * resolve clippy lints * fix typo * mark risk functions unsafe * fmt + clean up the last lints# * verify lockfile up to date * disable lto since it doesn't work with two rust libs * merge lock check and lint * Add missing license header to Rust files And update Makefile to ensure they are checked Co-authored-by: Zac Bergquist <zac.bergquist@goteleport.com>
2021-11-05 19:35:20 +00:00
checksum = "ba508cc11742c0dc5c1659771673afbab7a0efab23aa17e854cbab0837ed0b43"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
dependencies = [
"unicode-xid",
]
[[package]]
name = "quote"
Rust & Desktop Access fixes (#8822) * update deps in manifest and lockfile * fixes and updates to docker and profiles * lint rust * fix typo * resolve clippy lints * fix typo * mark risk functions unsafe * fmt + clean up the last lints# * verify lockfile up to date * disable lto since it doesn't work with two rust libs * merge lock check and lint * Add missing license header to Rust files And update Makefile to ensure they are checked Co-authored-by: Zac Bergquist <zac.bergquist@goteleport.com>
2021-11-05 19:35:20 +00:00
version = "1.0.10"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Rust & Desktop Access fixes (#8822) * update deps in manifest and lockfile * fixes and updates to docker and profiles * lint rust * fix typo * resolve clippy lints * fix typo * mark risk functions unsafe * fmt + clean up the last lints# * verify lockfile up to date * disable lto since it doesn't work with two rust libs * merge lock check and lint * Add missing license header to Rust files And update Makefile to ensure they are checked Co-authored-by: Zac Bergquist <zac.bergquist@goteleport.com>
2021-11-05 19:35:20 +00:00
checksum = "38bc8cc6a5f2e3655e0899c1b848643b2562f853f114bfec7be120678e3ace05"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
dependencies = [
"proc-macro2",
]
[[package]]
name = "rand"
version = "0.7.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03"
dependencies = [
"getrandom 0.1.16",
"libc",
"rand_chacha 0.2.2",
"rand_core 0.5.1",
"rand_hc 0.2.0",
]
[[package]]
name = "rand"
version = "0.8.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2e7573632e6454cf6b99d7aac4ccca54be06da05aca2ef7423d22d27d4d4bcd8"
dependencies = [
"libc",
"rand_chacha 0.3.1",
"rand_core 0.6.3",
"rand_hc 0.3.1",
]
[[package]]
name = "rand_chacha"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402"
dependencies = [
"ppv-lite86",
"rand_core 0.5.1",
]
[[package]]
name = "rand_chacha"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
dependencies = [
"ppv-lite86",
"rand_core 0.6.3",
]
[[package]]
name = "rand_core"
version = "0.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19"
dependencies = [
"getrandom 0.1.16",
]
[[package]]
name = "rand_core"
version = "0.6.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
dependencies = [
"getrandom 0.2.3",
]
[[package]]
name = "rand_hc"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c"
dependencies = [
"rand_core 0.5.1",
]
[[package]]
name = "rand_hc"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d51e9f596de227fda2ea6c84607f5558e196eeaf43c986b724ba4fb8fdf497e7"
dependencies = [
"rand_core 0.6.3",
]
[[package]]
name = "rdp-client"
version = "0.1.0"
dependencies = [
RDPDR virtual channel implementation for smartcards (#8282) * RDPDR virtual channel implementation for smartcards RDPDR stands for "RDP device redirection channel", used to forward smartcard operations from server to client. Establish the channel, register a smartcard device and implement smartcard operations up to actually handling the commands. The implementation ends at SCARD_IOCTL_TRANSMIT, where we will implement an emulator for a PC/SC smartcard with a Teleport certificate. * Address review feedback
2021-09-22 21:30:13 +00:00
"bitflags",
"byteorder",
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
"env_logger",
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
"iso7816",
"iso7816-tlv",
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
"libc",
"log",
RDPDR virtual channel implementation for smartcards (#8282) * RDPDR virtual channel implementation for smartcards RDPDR stands for "RDP device redirection channel", used to forward smartcard operations from server to client. Establish the channel, register a smartcard device and implement smartcard operations up to actually handling the commands. The implementation ends at SCARD_IOCTL_TRANSMIT, where we will implement an emulator for a PC/SC smartcard with a Teleport certificate. * Address review feedback
2021-09-22 21:30:13 +00:00
"num-derive",
"num-traits",
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
"openssl",
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
"rdp-rs",
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
"uuid",
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
]
[[package]]
name = "rdp-rs"
version = "0.1.0"
Update rdp-rs (#9344) This includes gravitational/rdp-rs#5 which will show a better error message for protocol negotiation failures. Also bump the libc dependency while we're at it. All other crates are still up to date.
2021-12-21 19:14:06 +00:00
source = "git+https://github.com/gravitational/rdp-rs?rev=cb61119d2803f647b60e6c9b2ef05ab587cc1966#cb61119d2803f647b60e6c9b2ef05ab587cc1966"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
dependencies = [
"bufstream",
"byteorder",
"hmac",
"indexmap",
"md-5",
"md4",
"native-tls",
"num-bigint",
"num_enum",
"rand 0.7.3",
"x509-parser",
"yasna",
]
[[package]]
name = "redox_syscall"
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
version = "0.2.10"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
checksum = "8383f39639269cde97d255a32bdb68c047337295414940c68bdd30c2e13203ff"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
dependencies = [
"bitflags",
]
[[package]]
name = "regex"
version = "1.5.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d07a8629359eb56f1e2fb1652bb04212c072a87ba68546a04065d525673ac461"
dependencies = [
"aho-corasick",
"memchr",
"regex-syntax",
]
[[package]]
name = "regex-syntax"
version = "0.6.25"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f497285884f3fcff424ffc933e56d7cbca511def0c9831a7f9b5f6153e3cc89b"
[[package]]
name = "remove_dir_all"
version = "0.5.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"
dependencies = [
"winapi",
]
TDP: add mouse scroll support
2021-10-01 22:08:22 +00:00
[[package]]
name = "riscv"
version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6907ccdd7a31012b70faf2af85cd9e5ba97657cc3987c4f13f8e4d2c2a088aba"
dependencies = [
"bare-metal 1.0.0",
"bit_field",
"riscv-target",
]
[[package]]
name = "riscv-target"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "88aa938cda42a0cf62a20cfe8d139ff1af20c2e681212b5b34adb5a58333f222"
dependencies = [
"lazy_static",
"regex",
]
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
[[package]]
name = "rustc_version"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a"
dependencies = [
"semver",
]
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
[[package]]
name = "rusticata-macros"
version = "2.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f8a9050636e8a1b487ba1fbe99114021cd7594dde3ce6ed95bfc1691e5b5367b"
dependencies = [
"nom",
]
[[package]]
name = "ryu"
version = "1.0.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "71d301d4193d031abdd79ff7e3dd721168a9572ef3fe51a1517aba235bd8f86e"
[[package]]
name = "schannel"
version = "0.1.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8f05ba609c234e60bee0d547fe94a4c7e9da733d1c962cf6e59efa4cd9c8bc75"
dependencies = [
"lazy_static",
"winapi",
]
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
[[package]]
name = "scopeguard"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
[[package]]
name = "security-framework"
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
version = "2.4.2"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
checksum = "525bc1abfda2e1998d152c45cf13e696f76d0a4972310b22fac1658b05df7c87"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
dependencies = [
"bitflags",
"core-foundation",
"core-foundation-sys",
"libc",
"security-framework-sys",
]
[[package]]
name = "security-framework-sys"
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
version = "2.4.2"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
checksum = "a9dd14d83160b528b7bfd66439110573efcfbe281b17fc2ca9f39f550d619c7e"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
dependencies = [
"core-foundation-sys",
"libc",
]
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
[[package]]
name = "semver"
version = "0.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1d7eb9ef2c18661902cc47e535f9bc51b78acd254da71d375c2f6720d9a40403"
dependencies = [
"semver-parser",
]
[[package]]
name = "semver-parser"
version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
[[package]]
name = "serde"
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
version = "1.0.130"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
checksum = "f12d06de37cf59146fbdecab66aa99f9fe4f78722e3607577a5375d66bd0c913"
[[package]]
name = "spin"
version = "0.9.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "511254be0c5bcf062b019a6c89c01a664aa359ded62f78aa72c6fc137c0590e5"
dependencies = [
"lock_api",
]
[[package]]
name = "stable_deref_trait"
version = "1.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
[[package]]
name = "static_assertions"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
[[package]]
name = "subtle"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2d67a5a62ba6e01cb2192ff309324cb4875d0c451d55fe2319433abe7a05a8ee"
[[package]]
name = "syn"
Rust & Desktop Access fixes (#8822) * update deps in manifest and lockfile * fixes and updates to docker and profiles * lint rust * fix typo * resolve clippy lints * fix typo * mark risk functions unsafe * fmt + clean up the last lints# * verify lockfile up to date * disable lto since it doesn't work with two rust libs * merge lock check and lint * Add missing license header to Rust files And update Makefile to ensure they are checked Co-authored-by: Zac Bergquist <zac.bergquist@goteleport.com>
2021-11-05 19:35:20 +00:00
version = "1.0.81"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Rust & Desktop Access fixes (#8822) * update deps in manifest and lockfile * fixes and updates to docker and profiles * lint rust * fix typo * resolve clippy lints * fix typo * mark risk functions unsafe * fmt + clean up the last lints# * verify lockfile up to date * disable lto since it doesn't work with two rust libs * merge lock check and lint * Add missing license header to Rust files And update Makefile to ensure they are checked Co-authored-by: Zac Bergquist <zac.bergquist@goteleport.com>
2021-11-05 19:35:20 +00:00
checksum = "f2afee18b8beb5a596ecb4a2dce128c719b4ba399d34126b9e4396e3f9860966"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
dependencies = [
"proc-macro2",
"quote",
"unicode-xid",
]
[[package]]
name = "tempfile"
version = "3.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dac1c663cfc93810f88aed9b8941d48cabf856a1b111c29a40439018d870eb22"
dependencies = [
"cfg-if",
"libc",
"rand 0.8.4",
"redox_syscall",
"remove_dir_all",
"winapi",
]
[[package]]
name = "termcolor"
version = "1.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2dfed899f0eb03f32ee8c6a0aabdb8a7949659e3466561fc0adf54e26d88c5f4"
dependencies = [
"winapi-util",
]
[[package]]
name = "time"
version = "0.1.43"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ca8a50ef2360fbd1eeb0ecd46795a87a19024eb4b53c5dc916ca1fd95fe62438"
dependencies = [
"libc",
"winapi",
]
[[package]]
name = "toml"
version = "0.5.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a31142970826733df8241ef35dc040ef98c679ab14d7c3e54d827099b3acecaa"
dependencies = [
"serde",
]
[[package]]
name = "typenum"
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
version = "1.14.0"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
checksum = "b63708a265f51345575b27fe43f9500ad611579e764c79edbc2037b1121959ec"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
[[package]]
name = "unicode-xid"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
[[package]]
name = "untrusted"
TDP: add mouse scroll support
2021-10-01 22:08:22 +00:00
version = "0.9.0"
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
TDP: add mouse scroll support
2021-10-01 22:08:22 +00:00
checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
[[package]]
name = "uuid"
version = "0.8.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bc5cf98d8186244414c848017f0e2676b3fcb46807f6668a97dfe67359a3c4b7"
dependencies = [
"getrandom 0.2.3",
]
[[package]]
name = "vcell"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "77439c1b53d2303b20d9459b1ade71a83c716e3f9c34f3228c00e6f185d6c002"
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
[[package]]
name = "vcpkg"
version = "0.2.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
[[package]]
name = "version_check"
version = "0.9.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5fecdca9a5291cc2b8dcf7dc02453fee791a280f3743cb0905f8822ae463b3fe"
PIV authentication for RDP (#8408) * PIV authentication for RDP This uncomfortably large change fully implements smartcard PIV authentication for RDP clients using the Teleport CA: - PIV applet implementation in emulated RDP smartcard - generating Windows-compatible certificates using Teleport CA with a dedicated RPC - generating dummy CRLs for Teleport CA and publishing it via LDAP The CRLs are required by Windows for any smartcard login certificate, we can't avoid that. But we can avoid making it public: the CRL can live in ActiveDirectory instead of a public endpoint of a Teleport service. Here, we use LDAP to publish the CRL on startup, valid for a year. There are a few unhandled cases in the current implementation: - LDAP server certificate is not validated when upgrading to TLS - multiple active CAs (with HSMs) are not supported, only one CRL is published - CA rotation is not supported, CRL is not re-published on rotation All of the above issues will be handled in future PRs as this one is already too large. * Address review feedback * Fix linter errors
2021-10-01 22:01:17 +00:00
[[package]]
name = "void"
version = "1.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d"
[[package]]
name = "volatile-register"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9ee8f19f9d74293faf70901bc20ad067dc1ad390d2cbf1e3f75f721ffee908b6"
dependencies = [
"vcell",
]
RDP client implementation (#7824) * RDP client implementation This is a minimal RDP client on top of the rdp-rs Rust crate. The crate is wrapped with an FFI Rust adapter, statically compiled and called from Go via CGO. This PR also has toy web client to test the RDP code, and just enough of the desktop wire protocol implementation to make it work. I excluded the RDP client from the build via tags for now to avoid bloating the teleport binaries. Many more things missing that will come in later PRs, to keep this one reviewable. * flag tweaks and updated readme for macos * Switch to C-style strings between Go and Rust * Use regular top-level C function instead ofthe cgo jump function * Fix bitmap buffer memory leak * Consistent naming for CGO types * Pass rust object reference to Go * Clean up FFI error string management * Extract a thin C wrapper for read_rdp_output * Use the log crate in rust * Small rust cleanups * Fix shellcheck nit in run.sh * Fix RDP client memory release * Allow Rust code to compile on any unix * Force Alpha channel to 100% always For some reason, on Windows 10 with bitmap decompression the Alpha always ends up as 0. This makes everything transparent. * Implement screen size and credential negotiation * desktop protocol: remove password prompt It was decided that supporting passwords natively is a bad product decision. We will only support certificate-based authn and only in ActiveDirectory environments. Until we implement certificate support, passwords can be injected via an environment variable for testing. It will be removed before the beta release. * Address review feedback Co-authored-by: Isaiah Becker-Mayer <isaiah@goteleport.com>
2021-08-23 21:03:52 +00:00
[[package]]
name = "wasi"
version = "0.9.0+wasi-snapshot-preview1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519"
[[package]]
name = "wasi"
version = "0.10.2+wasi-snapshot-preview1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fd6fbd9a79829dd1ad0cc20627bf1ed606756a7f77edff7b66b7064f9cb327c6"
[[package]]
name = "winapi"
version = "0.3.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
dependencies = [
"winapi-i686-pc-windows-gnu",
"winapi-x86_64-pc-windows-gnu",
]
[[package]]
name = "winapi-i686-pc-windows-gnu"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
[[package]]
name = "winapi-util"
version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
dependencies = [
"winapi",
]
[[package]]
name = "winapi-x86_64-pc-windows-gnu"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
[[package]]
name = "x509-parser"
version = "0.6.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "99bbe736dd2b422d66e4830f4a06f34387c9814c027efcbda5c2f86463e8e5b0"
dependencies = [
"base64",
"der-parser",
"nom",
"num-bigint",
"rusticata-macros",
"time",
]
[[package]]
name = "yasna"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0de7bff972b4f2a06c85f6d8454b09df153af7e3a4ec2aac81db1b105b684ddb"
Reference in a new issue Copy permalink