mirror of
https://github.com/VallierDev/uu-remote-linux.git
synced 2026-11-16 08:50:40 +01:00
feat(viewer): secure type input that reuses the open desktop session (#70)
Co-authored-by: 212duo <[email protected]>
This commit is contained in:
1 parent
963875516a
commit
fa7606894f
7 files changed
+1711
-10
No files matched your search
@@ -546,6 +546,19 @@ GNOME-to-official-Mac bidirectional clipboard synchronization is still unverifie
|
||||
- CLI: `connect DEVICE false - echo legacy [--view-only]` (desktop), `files DEVICE ls|get|put …`, `terminal DEVICE [SESSION]`,
|
||||
`terminal-ui DEVICE NAME`, `portmap DEVICE LOCAL_PORT HOST PORT` (listens on 127.0.0.1 only), `power DEVICE reboot|shutdown`, `unbind DEVICE` (remove a device from the account; also under "More tools" in the launcher),
|
||||
`assist CONNECT_ID` (the code is read from one stdin line, never an argument). See `uuremote-viewer --help`.
|
||||
- **Secure `type` input** (inject keystrokes into an open desktop session — lock-screen PIN/password; never put secrets on argv):
|
||||
```sh
|
||||
# Preferred: open desktop via ui/connect first, then type (reuses the session; does not kick the live view)
|
||||
UU_INPUT_ENV=UU_SECRET UU_SECRET='…' \
|
||||
uuremote-viewer type DEVICE [--delay-ms 40] [--omit-last 1] [--snapshot /path/out.png]
|
||||
# Or: printf '%s' '…' | uuremote-viewer type DEVICE
|
||||
# Validate only, no network: uuremote-viewer type DEVICE --dry-run
|
||||
# If no desktop viewer is running you must pass --new-session (opens a new peer and replaces any already-open desktop window; upstream #30)
|
||||
```
|
||||
Brace tokens: `{Enter}` `{Tab}` `{Esc}` `{Backspace}` `{Ctrl+Alt+Del}` …; `{{` is a literal `{`.
|
||||
**Layout**: characters are mapped for **US QWERTY** only (non-US layouts may mistype symbols/letters).
|
||||
**Windows numeric PIN**: Windows often submits automatically once enough digits are entered — usually no `{Enter}` needed. Use `--omit-last N` to omit the last N characters when you want to fill without signing in.
|
||||
Logs and `--dry-run` report lengths/event counts only. When reusing a session, about one second after sending, a PNG frame is saved (default under `$XDG_RUNTIME_DIR/uu-viewer-type/`, mode 0600); the path is logged and printed as `snapshot=…`.
|
||||
- Ctrl+Alt+F in the desktop window opens the files window on the same connection. `UU_VIEWER_AUDIO=0` disables sound,
|
||||
`UU_VIEWER_CLIPBOARD=0` the clipboard, `UU_VIEWER_VIEW_ONLY=1` input; `UU_VIEWER_FFMPEG` selects the ffmpeg binary.
|
||||
- Desktop offers H.264 / H.265; the host chooses the codec. `UU_VIEWER_CODEC=h264` limits both SDP and decoder capabilities to H.264.
|
||||
|
||||
@@ -486,6 +486,19 @@ GNOME 与官方 Mac 被控端的双向剪贴板尚未验证通过;此修改不
|
||||
- 命令行:`connect DEVICE false - echo legacy [--view-only]`(桌面)、`files DEVICE ls|get|put …`、`terminal DEVICE [SESSION]`、
|
||||
`terminal-ui DEVICE NAME`、`portmap DEVICE LOCAL_PORT HOST PORT`(只监听 127.0.0.1)、`power DEVICE reboot|shutdown`、`unbind DEVICE`(从账号删除设备,启动窗口「更多工具」里也有)、
|
||||
`assist CONNECT_ID`(验证码从 stdin 读取一行,不能作为参数传入)。`uuremote-viewer --help` 查看全部参数。
|
||||
- **安全输入 `type`**(向已打开的桌面会话注入键盘,适合锁屏 PIN / 密码;文本永不进 argv):
|
||||
```sh
|
||||
# 推荐:先 ui/connect 打开桌面,再 type(复用会话,不顶掉当前画面)
|
||||
UU_INPUT_ENV=UU_SECRET UU_SECRET='……' \
|
||||
uuremote-viewer type DEVICE [--delay-ms 40] [--omit-last 1] [--snapshot /path/out.png]
|
||||
# 或:printf '%s' '……' | uuremote-viewer type DEVICE
|
||||
# 只检查、不连网:uuremote-viewer type DEVICE --dry-run
|
||||
# 没有正在运行的桌面会话时必须显式:--new-session(会新开连接,并顶掉已打开的桌面窗口,见上游 #30)
|
||||
```
|
||||
特殊键用花括号:`{Enter}` `{Tab}` `{Esc}` `{Backspace}` `{Ctrl+Alt+Del}` 等;`{{` 表示字面 `{`。
|
||||
**布局**:字符按 **US QWERTY** 物理键位映射(非美式布局的符号/字母可能对不上)。
|
||||
**Windows 数字 PIN**:输满位数后系统常会自动提交,一般不必再发 `{Enter}`;若只想填入、不登录,用 `--omit-last N` 省略最后 N 个字符。
|
||||
日志与 `--dry-run` 输出只含长度/事件数,不含明文。复用会话时,发送约 1 秒后会保存一帧 PNG(默认写在 `$XDG_RUNTIME_DIR/uu-viewer-type/`,权限 0600),路径打在日志并打印 `snapshot=…`。
|
||||
- 桌面窗口中按 Ctrl+Alt+F 打开文件窗口(复用同一连接)。`UU_VIEWER_AUDIO=0` 关闭声音,`UU_VIEWER_CLIPBOARD=0` 关闭剪贴板,
|
||||
`UU_VIEWER_VIEW_ONLY=1` 只看不控,`UU_VIEWER_FFMPEG` 指定 ffmpeg 路径。
|
||||
- 桌面同时提供 H.264 / H.265,由主机协商选择;`UU_VIEWER_CODEC=h264` 将 SDP 和解码能力限制为 H.264。
|
||||
|
||||
@@ -21,6 +21,8 @@ pub mod tools;
|
||||
|
||||
pub mod clipboard;
|
||||
pub mod power;
|
||||
pub mod secure_input;
|
||||
pub mod type_ipc;
|
||||
|
||||
fn device_label(name:Option<&str>)->&str{
|
||||
name.filter(|name|!name.is_empty()).unwrap_or("远端设备")
|
||||
|
||||
+216
-7
@@ -1,7 +1,9 @@
|
||||
use super::{desktop::{Frame,FrameSink},input::{Input,Viewport},session::Session};
|
||||
use sdl2::{event::{Event,WindowEvent},mouse::MouseButton,pixels::PixelFormatEnum,rect::Rect};
|
||||
#[derive(Debug)] enum Command { Files, Type }
|
||||
pub struct Window { canvas:sdl2::render::Canvas<sdl2::video::Window>, events:sdl2::EventPump, _sdl:sdl2::Sdl, frame:(u32,u32), focused:bool, files:bool, mac:bool,
|
||||
clipboard:sdl2::clipboard::ClipboardUtil, clipboard_dirty:bool, clipboard_tx:tokio::sync::mpsc::Sender<super::clipboard::ClipboardRequest>, clipboard_requests:tokio::sync::mpsc::Receiver<super::clipboard::ClipboardRequest> }
|
||||
clipboard:sdl2::clipboard::ClipboardUtil, clipboard_dirty:bool, clipboard_tx:tokio::sync::mpsc::Sender<super::clipboard::ClipboardRequest>, clipboard_requests:tokio::sync::mpsc::Receiver<super::clipboard::ClipboardRequest>,
|
||||
pub last_frame:Option<Frame> }
|
||||
impl Window {
|
||||
pub fn new()->Result<Self,String>{
|
||||
let sdl=sdl2::init()?;let video=sdl.video()?;
|
||||
@@ -9,7 +11,7 @@ impl Window {
|
||||
let canvas=window.into_canvas().build().map_err(|_|"Renderer creation failed")?;
|
||||
let events=sdl.event_pump()?;let clipboard=video.clipboard();
|
||||
let(clipboard_tx,clipboard_requests)=tokio::sync::mpsc::channel(16);
|
||||
Ok(Self{canvas,events,_sdl:sdl,frame:(1920,1080),focused:true,files:false,mac:false,clipboard,clipboard_dirty:true,clipboard_tx,clipboard_requests})
|
||||
Ok(Self{canvas,events,_sdl:sdl,frame:(1920,1080),focused:true,files:false,mac:false,clipboard,clipboard_dirty:true,clipboard_tx,clipboard_requests,last_frame:None})
|
||||
}
|
||||
pub fn clipboard_bridge(&self)->super::clipboard::Bridge{super::clipboard::Bridge::sdl(self.clipboard_tx.clone())}
|
||||
pub fn set_mac(&mut self,mac:bool){self.mac=mac;}
|
||||
@@ -87,6 +89,7 @@ fn translate_actions(events:impl IntoIterator<Item=Event>,input:&mut Input,viewp
|
||||
fn button(b:MouseButton)->Option<i32>{match b{MouseButton::Left=>Some(1),MouseButton::Right=>Some(2),MouseButton::Middle=>Some(4),_=>None}}
|
||||
impl FrameSink for Window {
|
||||
fn present(&mut self,frame:&Frame)->Result<(),String>{
|
||||
self.last_frame=Some(Frame{width:frame.width,height:frame.height,rgb:frame.rgb.clone()});
|
||||
self.frame=(frame.width,frame.height);let v=self.viewport();let creator=self.canvas.texture_creator();
|
||||
let mut texture=creator.create_texture_streaming(PixelFormatEnum::RGB24,frame.width,frame.height).map_err(|_|"Texture creation failed")?;
|
||||
texture.update(None,&frame.rgb,frame.width as usize*3).map_err(|_|"Texture update failed")?;
|
||||
@@ -94,21 +97,34 @@ impl FrameSink for Window {
|
||||
self.canvas.copy(&texture,None,Some(Rect::new(v.x as i32,v.y as i32,v.width as u32,v.height as u32)))?;self.canvas.present();Ok(())
|
||||
}
|
||||
}
|
||||
pub async fn run(session:&mut Session,window:&mut Window,decoder:&mut dyn super::desktop::Decoder,view_only:bool)->Result<(),String>{
|
||||
pub async fn run(session:&mut Session,window:&mut Window,decoder:&mut dyn super::desktop::Decoder,view_only:bool,device:&str)->Result<(),String>{
|
||||
#[cfg(uu_gtk)]
|
||||
let mut files:Option<tokio::task::JoinHandle<Result<(),String>>>=None;
|
||||
let(tx,mut commands)=tokio::sync::mpsc::channel(8);
|
||||
let(tx,mut commands)=tokio::sync::mpsc::channel::<Command>(8);
|
||||
if std::env::var("UU_VIEWER_COMMANDS").as_deref()==Ok("1") {
|
||||
std::thread::spawn(move||{
|
||||
use std::io::Read;
|
||||
let mut input=std::io::stdin().lock();let mut line=Vec::new();let mut byte=[0];
|
||||
while input.read(&mut byte).ok()==Some(1){
|
||||
if byte[0]==b'\n'{if line==b"files" && tx.blocking_send(()).is_err(){break}line.clear();}
|
||||
if byte[0]==b'\n'{
|
||||
let cmd=match line.as_slice(){b"files"=>Some(Command::Files),b"type"=>Some(Command::Type),_=>None};
|
||||
line.clear();
|
||||
if let Some(cmd)=cmd { if tx.blocking_send(cmd).is_err(){break} }
|
||||
}
|
||||
else if line.len()<32{line.push(byte[0]);}else{break}
|
||||
}
|
||||
});
|
||||
}else{drop(tx);}
|
||||
let mut command_open=true;let mut requested=false;
|
||||
let(type_tx,mut type_rx)=tokio::sync::mpsc::channel::<super::type_ipc::PendingType>(4);
|
||||
let type_ipc=match super::type_ipc::Server::bind(device).await {
|
||||
Ok(server)=>{
|
||||
log::info!("Type IPC ready for device key {}", &super::type_ipc::device_key(device)[..12]);
|
||||
Some(tokio::spawn(async move { server.run(type_tx).await; }))
|
||||
}
|
||||
Err(e)=>{ log::warn!("Type IPC not started: {e}"); None }
|
||||
};
|
||||
let mut command_open=true;let mut requested=false;let mut type_requested=false;
|
||||
let mut type_job:Option<TypeJob>=None;
|
||||
let mut terminate=tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate()).map_err(|_|"Cannot watch termination")?;
|
||||
let mut audio=super::audio::Playback::new(&window._sdl,session.peer.audio.clone());
|
||||
let mut input=Input::new(view_only);input.set_mac(window.mac);let mut tick=tokio::time::interval(std::time::Duration::from_millis(8));
|
||||
@@ -116,7 +132,32 @@ pub async fn run(session:&mut Session,window:&mut Window,decoder:&mut dyn super:
|
||||
let deadline=tokio::time::sleep(std::time::Duration::from_secs(30));tokio::pin!(deadline);
|
||||
let result=async {
|
||||
loop {tokio::select!{
|
||||
command=commands.recv(),if command_open=>{if command.is_some(){requested=true}else{command_open=false}},
|
||||
command=commands.recv(),if command_open=>{
|
||||
match command {
|
||||
Some(Command::Files)=>{requested=true},
|
||||
Some(Command::Type)=>{type_requested=true},
|
||||
None=>{command_open=false},
|
||||
}
|
||||
},
|
||||
pending=type_rx.recv()=>{
|
||||
if let Some(mut pending)=pending {
|
||||
if type_job.is_some() {
|
||||
let _=pending.reply.send(super::type_ipc::TypeResponse{ok:false,events:0,chars:0,snapshot:None,error:Some("Secure input busy".into())});
|
||||
} else {
|
||||
let mut snapshot_create_new=false;
|
||||
if pending.request.snapshot.as_ref().map_or(true, |s| s.is_empty()) {
|
||||
if let Ok(path)=super::type_ipc::default_snapshot_path(device) {
|
||||
pending.request.snapshot=Some(path.display().to_string());
|
||||
snapshot_create_new=true;
|
||||
}
|
||||
}
|
||||
match start_type_job(pending, window.mac, input.enabled(), snapshot_create_new) {
|
||||
Ok(job)=>type_job=Some(job),
|
||||
Err(())=>{},
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
_=terminate.recv()=>return Ok(()),
|
||||
_=tokio::signal::ctrl_c()=>return Ok(()),
|
||||
result=session.step()=>result?,
|
||||
@@ -145,6 +186,34 @@ pub async fn run(session:&mut Session,window:&mut Window,decoder:&mut dyn super:
|
||||
}
|
||||
}
|
||||
#[cfg(not(uu_gtk))] {if requested{log::warn!("File window requires GTK3");requested=false;}}
|
||||
if type_requested {
|
||||
type_requested=false;
|
||||
if type_job.is_some() {
|
||||
log::warn!("Secure type command ignored: busy");
|
||||
} else if !input.enabled() {
|
||||
log::warn!("Secure type command ignored: view-only session");
|
||||
} else if std::env::var_os("UU_INPUT_ENV").is_none() {
|
||||
log::warn!("Secure type command ignored: set UU_INPUT_ENV (stdin is the command channel)");
|
||||
} else {
|
||||
match super::secure_input::load_secret(std::io::Cursor::new([] as [u8;0])) {
|
||||
Ok(mut secret)=>{
|
||||
match enqueue_local_type(&mut type_job, &mut secret, window.mac, None, 0, std::time::Duration::ZERO, None) {
|
||||
Ok(())=>{},
|
||||
Err(e)=>log::warn!("Secure type failed: {e}"),
|
||||
}
|
||||
}
|
||||
Err(e)=>log::warn!("Secure type load failed: {e}"),
|
||||
}
|
||||
}
|
||||
}
|
||||
if let Some(job)=type_job.as_mut() {
|
||||
if let Err(e)=pump_type_job(job, session, window).await {
|
||||
log::warn!("Secure type job failed: {e}");
|
||||
type_job=None;
|
||||
} else if job.done {
|
||||
type_job=None;
|
||||
}
|
||||
}
|
||||
if session.peer.ready(super::rtc::ReadyPolicy::EchoOnly,false){for m in messages{session.peer.send_input(&m).await?;}}
|
||||
else {input.release_all();}
|
||||
if quit{return Ok(())}
|
||||
@@ -157,10 +226,150 @@ pub async fn run(session:&mut Session,window:&mut Window,decoder:&mut dyn super:
|
||||
}}
|
||||
}.await;
|
||||
#[cfg(uu_gtk)] if let Some(f)=files {f.abort();let _=f.await;super::tools_ui::hide();session.peer.tools.lock().unwrap().take();}
|
||||
if let Some(t)=type_ipc {t.abort();let _=t.await;}
|
||||
for m in input.release_all(){let _=session.peer.send_input(&m).await;}
|
||||
result
|
||||
}
|
||||
|
||||
struct TypeJob {
|
||||
actions: super::secure_input::ActionList,
|
||||
index: usize,
|
||||
delay: std::time::Duration,
|
||||
next_at: tokio::time::Instant,
|
||||
chars: usize,
|
||||
snapshot_path: Option<std::path::PathBuf>,
|
||||
snapshot_create_new: bool,
|
||||
phase: TypePhase,
|
||||
reply: Option<tokio::sync::oneshot::Sender<super::type_ipc::TypeResponse>>,
|
||||
done: bool,
|
||||
}
|
||||
enum TypePhase { Sending, WaitSnap(tokio::time::Instant) }
|
||||
|
||||
fn start_type_job(mut pending: super::type_ipc::PendingType, mac: bool, enabled: bool, snapshot_create_new: bool) -> Result<TypeJob, ()> {
|
||||
let reply = pending.reply;
|
||||
let respond_err = |reply: tokio::sync::oneshot::Sender<super::type_ipc::TypeResponse>, msg: String| {
|
||||
let _ = reply.send(super::type_ipc::TypeResponse{ok:false,events:0,chars:0,snapshot:None,error:Some(msg)});
|
||||
};
|
||||
if !enabled {
|
||||
respond_err(reply, "view-only session".into());
|
||||
return Err(());
|
||||
}
|
||||
let mut secret = super::secure_input::Secret::new(std::mem::take(&mut pending.request.secret));
|
||||
if let Err(e) = secret.omit_last_chars(pending.request.omit_last) {
|
||||
respond_err(reply, e);
|
||||
return Err(());
|
||||
}
|
||||
let chars = secret.chars_count();
|
||||
let actions = match super::secure_input::expand(secret.as_str(), mac) {
|
||||
Ok(a) => a,
|
||||
Err(e) => { respond_err(reply, e); return Err(()); }
|
||||
};
|
||||
drop(secret);
|
||||
log::info!("Secure input prepared: chars={} events={} delay_ms={}", chars, actions.len(), pending.request.delay_ms);
|
||||
let snapshot_path = pending.request.snapshot.as_ref().filter(|s| !s.is_empty()).map(std::path::PathBuf::from);
|
||||
Ok(TypeJob {
|
||||
actions,
|
||||
index: 0,
|
||||
delay: std::time::Duration::from_millis(pending.request.delay_ms.min(5_000)),
|
||||
next_at: tokio::time::Instant::now(),
|
||||
chars,
|
||||
snapshot_path,
|
||||
snapshot_create_new,
|
||||
phase: TypePhase::Sending,
|
||||
reply: Some(reply),
|
||||
done: false,
|
||||
})
|
||||
}
|
||||
|
||||
fn enqueue_local_type(
|
||||
slot: &mut Option<TypeJob>,
|
||||
secret: &mut super::secure_input::Secret,
|
||||
mac: bool,
|
||||
snapshot: Option<std::path::PathBuf>,
|
||||
omit_last: usize,
|
||||
delay: std::time::Duration,
|
||||
reply: Option<tokio::sync::oneshot::Sender<super::type_ipc::TypeResponse>>,
|
||||
) -> Result<(), String> {
|
||||
secret.omit_last_chars(omit_last)?;
|
||||
let chars = secret.chars_count();
|
||||
let actions = super::secure_input::expand(secret.as_str(), mac)?;
|
||||
drop(std::mem::replace(secret, super::secure_input::Secret::new(String::new())));
|
||||
log::info!("Secure input prepared: chars={} events={}", chars, actions.len());
|
||||
*slot = Some(TypeJob {
|
||||
actions,
|
||||
index: 0,
|
||||
delay,
|
||||
next_at: tokio::time::Instant::now(),
|
||||
chars,
|
||||
snapshot_path: snapshot,
|
||||
snapshot_create_new: false,
|
||||
phase: TypePhase::Sending,
|
||||
reply,
|
||||
done: false,
|
||||
});
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn pump_type_job(job: &mut TypeJob, session: &mut Session, window: &mut Window) -> Result<(), String> {
|
||||
use super::type_ipc::TypeResponse;
|
||||
match job.phase {
|
||||
TypePhase::Sending => {
|
||||
if !session.peer.ready(super::rtc::ReadyPolicy::EchoOnly, false) {
|
||||
return Ok(());
|
||||
}
|
||||
if tokio::time::Instant::now() < job.next_at {
|
||||
return Ok(());
|
||||
}
|
||||
if job.index >= job.actions.len() {
|
||||
let wait = tokio::time::Instant::now() + std::time::Duration::from_secs(1);
|
||||
job.phase = TypePhase::WaitSnap(wait);
|
||||
return Ok(());
|
||||
}
|
||||
let action = &job.actions[job.index];
|
||||
session.peer.send_input(&action.to_json()).await?;
|
||||
job.index += 1;
|
||||
if !job.delay.is_zero() {
|
||||
job.next_at = tokio::time::Instant::now() + job.delay;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
TypePhase::WaitSnap(deadline) => {
|
||||
if tokio::time::Instant::now() < deadline {
|
||||
return Ok(());
|
||||
}
|
||||
let mut snap = None;
|
||||
if let Some(path) = job.snapshot_path.clone() {
|
||||
if let Some(frame) = window.last_frame.as_ref() {
|
||||
match super::type_ipc::write_png_rgb(&path, frame.width, frame.height, &frame.rgb, job.snapshot_create_new) {
|
||||
Ok(()) => {
|
||||
log::info!("Secure input snapshot written: {}", path.display());
|
||||
snap = Some(path.display().to_string());
|
||||
}
|
||||
Err(e) => log::warn!("Secure input snapshot failed: {e}"),
|
||||
}
|
||||
} else {
|
||||
log::warn!("Secure input snapshot skipped: no decoded frame yet");
|
||||
}
|
||||
}
|
||||
let events = job.actions.len();
|
||||
let chars = job.chars;
|
||||
if let Some(reply) = job.reply.take() {
|
||||
let _ = reply.send(TypeResponse {
|
||||
ok: true,
|
||||
events,
|
||||
chars,
|
||||
snapshot: snap,
|
||||
error: None,
|
||||
});
|
||||
} else {
|
||||
log::info!("Secure input finished: chars={} events={}", chars, events);
|
||||
}
|
||||
job.done = true;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)] mod tests {
|
||||
use super::*;
|
||||
// macOS: SDL video must start on the main thread, which the test harness does not use; CI runs it on Linux.
|
||||
|
||||
@@ -0,0 +1,731 @@
|
||||
//! Compose CONTROL keyboard JSON for scripted typing. Secrets never appear in logs or Debug.
|
||||
use serde_json::{json, Value};
|
||||
use std::fmt;
|
||||
use std::io::{BufRead, Read};
|
||||
use std::ops::{Deref, DerefMut};
|
||||
#[cfg(test)]
|
||||
use std::sync::Mutex;
|
||||
use std::time::Duration;
|
||||
|
||||
/// Serializes tests that mutate process environment.
|
||||
#[cfg(test)]
|
||||
pub static ENV_LOCK: Mutex<()> = Mutex::new(());
|
||||
|
||||
/// Holds secret text; Debug/Display only show length.
|
||||
pub struct Secret(String);
|
||||
|
||||
impl Secret {
|
||||
pub fn new(value: String) -> Self {
|
||||
Self(value)
|
||||
}
|
||||
pub fn as_str(&self) -> &str {
|
||||
&self.0
|
||||
}
|
||||
pub fn len(&self) -> usize {
|
||||
self.0.len()
|
||||
}
|
||||
pub fn is_empty(&self) -> bool {
|
||||
self.0.is_empty()
|
||||
}
|
||||
pub fn chars_count(&self) -> usize {
|
||||
self.0.chars().count()
|
||||
}
|
||||
/// Drop the last `n` Unicode scalars (fill-without-submit for Windows PIN).
|
||||
pub fn omit_last_chars(&mut self, n: usize) -> Result<(), String> {
|
||||
let count = self.0.chars().count();
|
||||
if n > count {
|
||||
return Err("omit-last exceeds secret length".into());
|
||||
}
|
||||
if n == 0 {
|
||||
return Ok(());
|
||||
}
|
||||
let keep = count - n;
|
||||
let truncated: String = self.0.chars().take(keep).collect();
|
||||
zeroize_str(&mut self.0);
|
||||
self.0 = truncated;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Debug for Secret {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
write!(f, "Secret(len={})", self.0.len())
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Display for Secret {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
write!(f, "*** ({} bytes)", self.0.len())
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for Secret {
|
||||
fn drop(&mut self) {
|
||||
zeroize_str(&mut self.0);
|
||||
}
|
||||
}
|
||||
|
||||
fn zeroize_str(s: &mut String) {
|
||||
let bytes = unsafe { s.as_bytes_mut() };
|
||||
for b in bytes.iter_mut() {
|
||||
*b = 0;
|
||||
}
|
||||
s.clear();
|
||||
}
|
||||
|
||||
/// One CONTROL keyboard action (Windows VK or Mac keycode in `key`).
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub enum KeyAction {
|
||||
Press(i32),
|
||||
Release(i32),
|
||||
}
|
||||
|
||||
impl KeyAction {
|
||||
pub fn to_json(&self) -> Value {
|
||||
match self {
|
||||
Self::Press(k) => json!({"action":"kbd_press","key":k}),
|
||||
Self::Release(k) => json!({"action":"kbd_release","key":k}),
|
||||
}
|
||||
}
|
||||
fn zeroize(&mut self) {
|
||||
match self {
|
||||
Self::Press(k) | Self::Release(k) => *k = 0,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Key event list that wipes key codes on drop.
|
||||
pub struct ActionList(Vec<KeyAction>);
|
||||
|
||||
impl std::fmt::Debug for ActionList {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
write!(f, "ActionList(len={})", self.0.len())
|
||||
}
|
||||
}
|
||||
|
||||
impl ActionList {
|
||||
pub fn new(actions: Vec<KeyAction>) -> Self {
|
||||
Self(actions)
|
||||
}
|
||||
pub fn len(&self) -> usize {
|
||||
self.0.len()
|
||||
}
|
||||
pub fn is_empty(&self) -> bool {
|
||||
self.0.is_empty()
|
||||
}
|
||||
pub fn as_slice(&self) -> &[KeyAction] {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
|
||||
impl Deref for ActionList {
|
||||
type Target = [KeyAction];
|
||||
fn deref(&self) -> &Self::Target {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
|
||||
impl DerefMut for ActionList {
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
&mut self.0
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for ActionList {
|
||||
fn drop(&mut self) {
|
||||
for a in &mut self.0 {
|
||||
a.zeroize();
|
||||
}
|
||||
self.0.clear();
|
||||
}
|
||||
}
|
||||
|
||||
pub fn parse_delay_ms(raw: Option<&str>) -> Result<Duration, String> {
|
||||
let Some(raw) = raw else {
|
||||
return Ok(Duration::ZERO);
|
||||
};
|
||||
let ms: u64 = raw
|
||||
.parse()
|
||||
.map_err(|_| String::from("delay must be a non-negative integer (milliseconds)"))?;
|
||||
if ms > 5_000 {
|
||||
return Err("delay must be at most 5000 ms".into());
|
||||
}
|
||||
Ok(Duration::from_millis(ms))
|
||||
}
|
||||
|
||||
pub fn parse_omit_last(raw: Option<&str>) -> Result<usize, String> {
|
||||
let Some(raw) = raw else {
|
||||
return Ok(0);
|
||||
};
|
||||
let n: usize = raw
|
||||
.parse()
|
||||
.map_err(|_| String::from("omit-last must be a non-negative integer"))?;
|
||||
if n > 64 {
|
||||
return Err("omit-last must be at most 64".into());
|
||||
}
|
||||
Ok(n)
|
||||
}
|
||||
|
||||
/// `UU_INPUT_ENV` names another variable that holds the secret; otherwise one stdin line.
|
||||
/// After reading a named secret variable, that variable is removed from the environment.
|
||||
pub fn load_secret(stdin: impl BufRead) -> Result<Secret, String> {
|
||||
if let Ok(name) = std::env::var("UU_INPUT_ENV") {
|
||||
validate_env_name(&name)?;
|
||||
let value = std::env::var(&name)
|
||||
.map_err(|_| "Environment variable named by UU_INPUT_ENV is not set".to_string())?;
|
||||
std::env::remove_var(&name);
|
||||
if value.is_empty() {
|
||||
return Err("Secret environment variable is empty".into());
|
||||
}
|
||||
if value.len() > 16 * 1024 {
|
||||
return Err("Secret exceeds 16 KiB".into());
|
||||
}
|
||||
return Ok(Secret::new(value));
|
||||
}
|
||||
let mut line = String::new();
|
||||
stdin
|
||||
.take(16 * 1024 + 1)
|
||||
.read_to_string(&mut line)
|
||||
.map_err(|_| "Cannot read secret from stdin")?;
|
||||
if line.len() > 16 * 1024 {
|
||||
return Err("Secret exceeds 16 KiB".into());
|
||||
}
|
||||
if line.ends_with('\n') {
|
||||
line.pop();
|
||||
if line.ends_with('\r') {
|
||||
line.pop();
|
||||
}
|
||||
}
|
||||
if line.is_empty() {
|
||||
return Err("Secret stdin is empty (set UU_INPUT_ENV or pipe text)".into());
|
||||
}
|
||||
Ok(Secret::new(line))
|
||||
}
|
||||
|
||||
fn validate_env_name(name: &str) -> Result<(), String> {
|
||||
if name.is_empty() || name.len() > 128 {
|
||||
return Err("UU_INPUT_ENV must be a non-empty variable name".into());
|
||||
}
|
||||
if !name.chars().all(|c| c.is_ascii_alphanumeric() || c == '_') {
|
||||
return Err("UU_INPUT_ENV must be an alphanumeric variable name".into());
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Expand template text into key actions. Brace tokens: `{Enter}`, `{Tab}`, `{Esc}`,
|
||||
/// `{Backspace}`, `{Delete}`, `{Space}`, `{Ctrl+Alt+Del}`, arrows, `{Home}`, `{End}`, `{F1}`…`{F12}`.
|
||||
/// Plain characters use a US QWERTY VK/Mac mapping (Shift for uppercase/symbols).
|
||||
/// Errors never include the offending character or token text — only a 0-based char index.
|
||||
pub fn expand(text: &str, mac: bool) -> Result<ActionList, String> {
|
||||
let mut out = Vec::new();
|
||||
let mut chars = text.chars().peekable();
|
||||
let mut index = 0usize;
|
||||
while let Some(c) = chars.next() {
|
||||
if c == '{' {
|
||||
if chars.peek() == Some(&'{') {
|
||||
chars.next();
|
||||
push_char(&mut out, '{', mac, index)?;
|
||||
index += 1;
|
||||
continue;
|
||||
}
|
||||
let start = index;
|
||||
let mut name = String::new();
|
||||
let mut closed = false;
|
||||
for n in chars.by_ref() {
|
||||
if n == '}' {
|
||||
closed = true;
|
||||
break;
|
||||
}
|
||||
if n == '{' || name.len() > 32 {
|
||||
zeroize_str(&mut name);
|
||||
return Err(format!("Invalid special-key token at index {start}"));
|
||||
}
|
||||
name.push(n);
|
||||
}
|
||||
if !closed {
|
||||
zeroize_str(&mut name);
|
||||
return Err(format!("Unclosed special-key token at index {start}"));
|
||||
}
|
||||
// Advance index past '{' + name + '}'
|
||||
index += 1 + name.chars().count() + 1;
|
||||
let result = push_special(&mut out, &name, mac, start);
|
||||
zeroize_str(&mut name);
|
||||
result?;
|
||||
continue;
|
||||
}
|
||||
if c.is_control() && c != '\t' && c != '\n' && c != '\r' {
|
||||
return Err(format!("Control character at index {index}"));
|
||||
}
|
||||
match c {
|
||||
'\n' | '\r' => push_special(&mut out, "Enter", mac, index)?,
|
||||
'\t' => push_special(&mut out, "Tab", mac, index)?,
|
||||
_ => push_char(&mut out, c, mac, index)?,
|
||||
}
|
||||
index += 1;
|
||||
}
|
||||
Ok(ActionList::new(out))
|
||||
}
|
||||
|
||||
fn push_special(
|
||||
out: &mut Vec<KeyAction>,
|
||||
name: &str,
|
||||
mac: bool,
|
||||
index: usize,
|
||||
) -> Result<(), String> {
|
||||
let key = match name {
|
||||
"Enter" | "Return" => Some(vk_or_mac(0x0d, 36, mac)),
|
||||
"Tab" => Some(vk_or_mac(0x09, 48, mac)),
|
||||
"Esc" | "Escape" => Some(vk_or_mac(0x1b, 53, mac)),
|
||||
"Backspace" => Some(vk_or_mac(0x08, 51, mac)),
|
||||
"Delete" | "Del" => Some(vk_or_mac(0x2e, 117, mac)),
|
||||
"Space" => Some(vk_or_mac(0x20, 49, mac)),
|
||||
"Up" => Some(vk_or_mac(0x26, 126, mac)),
|
||||
"Down" => Some(vk_or_mac(0x28, 125, mac)),
|
||||
"Left" => Some(vk_or_mac(0x25, 123, mac)),
|
||||
"Right" => Some(vk_or_mac(0x27, 124, mac)),
|
||||
"Home" => Some(vk_or_mac(0x24, 115, mac)),
|
||||
"End" => Some(vk_or_mac(0x23, 119, mac)),
|
||||
"Ctrl+Alt+Del" | "CAD" => {
|
||||
let ctrl = vk_or_mac(0xa2, 59, mac);
|
||||
let alt = vk_or_mac(0xa4, 58, mac);
|
||||
let del = vk_or_mac(0x2e, 117, mac);
|
||||
out.push(KeyAction::Press(ctrl));
|
||||
out.push(KeyAction::Press(alt));
|
||||
out.push(KeyAction::Press(del));
|
||||
out.push(KeyAction::Release(del));
|
||||
out.push(KeyAction::Release(alt));
|
||||
out.push(KeyAction::Release(ctrl));
|
||||
return Ok(());
|
||||
}
|
||||
other if other.len() >= 2 && other.as_bytes()[0] == b'F' => {
|
||||
let n: u32 = other[1..]
|
||||
.parse()
|
||||
.map_err(|_| format!("Unknown special key at index {index}"))?;
|
||||
if !(1..=12).contains(&n) {
|
||||
return Err(format!("Unknown special key at index {index}"));
|
||||
}
|
||||
let vk = 0x70 + (n as i32 - 1);
|
||||
let mac_code = match n {
|
||||
1 => 122,
|
||||
2 => 120,
|
||||
3 => 99,
|
||||
4 => 118,
|
||||
5 => 96,
|
||||
6 => 97,
|
||||
7 => 98,
|
||||
8 => 100,
|
||||
9 => 101,
|
||||
10 => 109,
|
||||
11 => 103,
|
||||
12 => 111,
|
||||
_ => unreachable!(),
|
||||
};
|
||||
Some(vk_or_mac(vk, mac_code, mac))
|
||||
}
|
||||
_ => return Err(format!("Unknown special key at index {index}")),
|
||||
};
|
||||
let Some(key) = key else {
|
||||
return Ok(());
|
||||
};
|
||||
out.push(KeyAction::Press(key));
|
||||
out.push(KeyAction::Release(key));
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn vk_or_mac(vk: i32, mac: i32, is_mac: bool) -> i32 {
|
||||
if is_mac {
|
||||
mac
|
||||
} else {
|
||||
vk
|
||||
}
|
||||
}
|
||||
|
||||
fn push_char(out: &mut Vec<KeyAction>, c: char, mac: bool, index: usize) -> Result<(), String> {
|
||||
let (vk, shift) = us_qwerty_vk(c)
|
||||
.ok_or_else(|| format!("Unsupported character at index {index}"))?;
|
||||
let key = if mac {
|
||||
mac_from_vk(vk).ok_or_else(|| format!("Unsupported character at index {index}"))?
|
||||
} else {
|
||||
vk
|
||||
};
|
||||
let shift_key = vk_or_mac(0xa0, 56, mac);
|
||||
if shift {
|
||||
out.push(KeyAction::Press(shift_key));
|
||||
}
|
||||
out.push(KeyAction::Press(key));
|
||||
out.push(KeyAction::Release(key));
|
||||
if shift {
|
||||
out.push(KeyAction::Release(shift_key));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn us_qwerty_vk(c: char) -> Option<(i32, bool)> {
|
||||
match c {
|
||||
'a'..='z' => Some((0x41 + (c as i32 - 'a' as i32), false)),
|
||||
'A'..='Z' => Some((0x41 + (c as i32 - 'A' as i32), true)),
|
||||
'0' => Some((0x30, false)),
|
||||
'1'..='9' => Some((0x30 + (c as i32 - '0' as i32), false)),
|
||||
' ' => Some((0x20, false)),
|
||||
'-' => Some((0xbd, false)),
|
||||
'_' => Some((0xbd, true)),
|
||||
'=' => Some((0xbb, false)),
|
||||
'+' => Some((0xbb, true)),
|
||||
'[' => Some((0xdb, false)),
|
||||
'{' => Some((0xdb, true)),
|
||||
']' => Some((0xdd, false)),
|
||||
'}' => Some((0xdd, true)),
|
||||
'\\' => Some((0xdc, false)),
|
||||
'|' => Some((0xdc, true)),
|
||||
';' => Some((0xba, false)),
|
||||
':' => Some((0xba, true)),
|
||||
'\'' => Some((0xde, false)),
|
||||
'"' => Some((0xde, true)),
|
||||
'`' => Some((0xc0, false)),
|
||||
'~' => Some((0xc0, true)),
|
||||
',' => Some((0xbc, false)),
|
||||
'<' => Some((0xbc, true)),
|
||||
'.' => Some((0xbe, false)),
|
||||
'>' => Some((0xbe, true)),
|
||||
'/' => Some((0xbf, false)),
|
||||
'?' => Some((0xbf, true)),
|
||||
'!' => Some((0x31, true)),
|
||||
'@' => Some((0x32, true)),
|
||||
'#' => Some((0x33, true)),
|
||||
'$' => Some((0x34, true)),
|
||||
'%' => Some((0x35, true)),
|
||||
'^' => Some((0x36, true)),
|
||||
'&' => Some((0x37, true)),
|
||||
'*' => Some((0x38, true)),
|
||||
'(' => Some((0x39, true)),
|
||||
')' => Some((0x30, true)),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
fn mac_from_vk(vk: i32) -> Option<i32> {
|
||||
let scan = match vk {
|
||||
0x41..=0x5a => 4 + (vk - 0x41),
|
||||
0x31..=0x39 => 30 + (vk - 0x31),
|
||||
0x30 => 39,
|
||||
0x0d => 40,
|
||||
0x1b => 41,
|
||||
0x08 => 42,
|
||||
0x09 => 43,
|
||||
0x20 => 44,
|
||||
0xbd => 45,
|
||||
0xbb => 46,
|
||||
0xdb => 47,
|
||||
0xdd => 48,
|
||||
0xdc => 49,
|
||||
0xba => 51,
|
||||
0xde => 52,
|
||||
0xc0 => 53,
|
||||
0xbc => 54,
|
||||
0xbe => 55,
|
||||
0xbf => 56,
|
||||
0xa0 => 225,
|
||||
_ => return None,
|
||||
};
|
||||
super::input::mac_keycode(scan)
|
||||
}
|
||||
|
||||
pub async fn send_actions(
|
||||
send: impl Fn(Value) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<(), String>> + Send>>,
|
||||
actions: &[KeyAction],
|
||||
delay: Duration,
|
||||
) -> Result<(), String> {
|
||||
for (i, action) in actions.iter().enumerate() {
|
||||
send(action.to_json()).await?;
|
||||
if !delay.is_zero() && i + 1 != actions.len() {
|
||||
tokio::time::sleep(delay).await;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Wait for CONTROL echo on an open desktop session, then send key actions.
|
||||
pub async fn run_session(
|
||||
session: &mut super::session::Session,
|
||||
actions: &[KeyAction],
|
||||
delay: Duration,
|
||||
) -> Result<(), String> {
|
||||
use std::sync::atomic::Ordering;
|
||||
let ready = async {
|
||||
loop {
|
||||
if session.peer.observed.control_open.load(Ordering::Acquire)
|
||||
&& session.peer.observed.echo_received.load(Ordering::Acquire)
|
||||
{
|
||||
return Ok::<_, String>(());
|
||||
}
|
||||
tokio::select! {
|
||||
r = session.step() => r?,
|
||||
_ = tokio::time::sleep(Duration::from_millis(20)) => {}
|
||||
}
|
||||
}
|
||||
};
|
||||
tokio::time::timeout(Duration::from_secs(30), ready)
|
||||
.await
|
||||
.map_err(|_| "CONTROL echo timed out")??;
|
||||
for (i, action) in actions.iter().enumerate() {
|
||||
session.peer.send_input(&action.to_json()).await?;
|
||||
if !delay.is_zero() && i + 1 != actions.len() {
|
||||
tokio::time::sleep(delay).await;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Dry-run summary: lengths only, never the secret or key codes.
|
||||
pub fn dry_run_report(secret: &Secret, omit_last: usize, mac: bool) -> Result<String, String> {
|
||||
let mut owned = Secret::new(secret.as_str().to_owned());
|
||||
owned.omit_last_chars(omit_last)?;
|
||||
let actions = expand(owned.as_str(), mac)?;
|
||||
Ok(format!(
|
||||
"dry-run: chars={} omit_last={} events={} mac={}",
|
||||
owned.chars_count(),
|
||||
omit_last,
|
||||
actions.len(),
|
||||
mac
|
||||
))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use std::io::Cursor;
|
||||
|
||||
#[test]
|
||||
fn secret_debug_and_display_never_leak() {
|
||||
let s = Secret::new("hunter2".into());
|
||||
let d = format!("{s:?}");
|
||||
let p = format!("{s}");
|
||||
assert!(d.contains("len=7"));
|
||||
assert!(!d.contains("hunter"));
|
||||
assert!(!p.contains("hunter"));
|
||||
assert!(p.contains("***"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn action_list_debug_shows_len_only() {
|
||||
let list = ActionList::new(vec![
|
||||
KeyAction::Press(0x41),
|
||||
KeyAction::Release(0x41),
|
||||
KeyAction::Press(0x42),
|
||||
KeyAction::Release(0x42),
|
||||
]);
|
||||
let d = format!("{list:?}");
|
||||
assert_eq!(d, "ActionList(len=4)");
|
||||
assert!(!d.contains("0x41"));
|
||||
assert!(!d.contains("Press"));
|
||||
assert!(!d.contains("41"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn letters_digits_and_shift_symbols_map_to_windows_vk() {
|
||||
let actions = expand("Ab1!", false).unwrap();
|
||||
assert_eq!(
|
||||
&actions[0..4],
|
||||
&[
|
||||
KeyAction::Press(0xa0),
|
||||
KeyAction::Press(0x41),
|
||||
KeyAction::Release(0x41),
|
||||
KeyAction::Release(0xa0),
|
||||
]
|
||||
);
|
||||
assert_eq!(
|
||||
&actions[4..6],
|
||||
&[KeyAction::Press(0x42), KeyAction::Release(0x42)]
|
||||
);
|
||||
assert_eq!(
|
||||
&actions[6..8],
|
||||
&[KeyAction::Press(0x31), KeyAction::Release(0x31)]
|
||||
);
|
||||
assert_eq!(
|
||||
&actions[8..12],
|
||||
&[
|
||||
KeyAction::Press(0xa0),
|
||||
KeyAction::Press(0x31),
|
||||
KeyAction::Release(0x31),
|
||||
KeyAction::Release(0xa0),
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn special_keys_and_ctrl_alt_del() {
|
||||
let a = expand("{Enter}{Tab}{Esc}{Backspace}{Ctrl+Alt+Del}", false).unwrap();
|
||||
assert!(a
|
||||
.windows(2)
|
||||
.any(|w| w == [KeyAction::Press(0x0d), KeyAction::Release(0x0d)]));
|
||||
let cad: Vec<_> = a.iter().rev().take(6).rev().cloned().collect();
|
||||
assert_eq!(
|
||||
cad,
|
||||
vec![
|
||||
KeyAction::Press(0xa2),
|
||||
KeyAction::Press(0xa4),
|
||||
KeyAction::Press(0x2e),
|
||||
KeyAction::Release(0x2e),
|
||||
KeyAction::Release(0xa4),
|
||||
KeyAction::Release(0xa2),
|
||||
]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unknown_special_key_errors_without_echoing_payload() {
|
||||
let err = expand("{NotAKey}", false).unwrap_err();
|
||||
assert!(err.contains("Unknown special key at index"));
|
||||
assert!(!err.contains("NotAKey"));
|
||||
assert!(!err.contains("password"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unsupported_char_errors_without_codepoint_or_char() {
|
||||
let err = expand("a中", false).unwrap_err();
|
||||
assert!(err.contains("Unsupported character at index 1"));
|
||||
assert!(!err.contains('中'));
|
||||
assert!(!err.contains("4E2D"));
|
||||
assert!(!err.contains("U+"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unclosed_token_and_control_char_rejected() {
|
||||
assert!(expand("{Enter", false).is_err());
|
||||
assert!(expand("a\u{0001}b", false).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn load_from_named_env_and_stdin() {
|
||||
let _g = ENV_LOCK.lock().unwrap();
|
||||
std::env::set_var("UU_INPUT_ENV", "UU_SECRET");
|
||||
std::env::set_var("UU_SECRET", "pin-value");
|
||||
let s = load_secret(Cursor::new(b"")).unwrap();
|
||||
assert_eq!(s.as_str(), "pin-value");
|
||||
assert!(!format!("{s:?}").contains("pin"));
|
||||
assert!(std::env::var("UU_SECRET").is_err());
|
||||
std::env::remove_var("UU_INPUT_ENV");
|
||||
let s = load_secret(Cursor::new(b"from-stdin\n")).unwrap();
|
||||
assert_eq!(s.as_str(), "from-stdin");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn invalid_env_name_and_empty_secret() {
|
||||
let _g = ENV_LOCK.lock().unwrap();
|
||||
std::env::set_var("UU_INPUT_ENV", "bad-name!");
|
||||
assert!(load_secret(Cursor::new(b"")).is_err());
|
||||
std::env::remove_var("UU_INPUT_ENV");
|
||||
std::env::set_var("UU_INPUT_ENV", "EMPTY_SECRET_TEST");
|
||||
std::env::set_var("EMPTY_SECRET_TEST", "");
|
||||
assert!(load_secret(Cursor::new(b"")).is_err());
|
||||
std::env::remove_var("UU_INPUT_ENV");
|
||||
std::env::remove_var("EMPTY_SECRET_TEST");
|
||||
assert!(load_secret(Cursor::new(b"\n")).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn delay_and_omit_bounds() {
|
||||
assert_eq!(parse_delay_ms(None).unwrap(), Duration::ZERO);
|
||||
assert_eq!(
|
||||
parse_delay_ms(Some("50")).unwrap(),
|
||||
Duration::from_millis(50)
|
||||
);
|
||||
assert!(parse_delay_ms(Some("-1")).is_err());
|
||||
assert!(parse_delay_ms(Some("5001")).is_err());
|
||||
assert_eq!(parse_omit_last(None).unwrap(), 0);
|
||||
assert_eq!(parse_omit_last(Some("2")).unwrap(), 2);
|
||||
assert!(parse_omit_last(Some("65")).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn omit_last_and_dry_run() {
|
||||
let mut s = Secret::new("1234567".into());
|
||||
s.omit_last_chars(1).unwrap();
|
||||
assert_eq!(s.as_str(), "123456");
|
||||
let report = dry_run_report(&Secret::new("1234567".into()), 1, false).unwrap();
|
||||
assert!(report.contains("chars=6"));
|
||||
assert!(report.contains("omit_last=1"));
|
||||
assert!(report.contains("events="));
|
||||
assert!(report.contains("omit_last=1"));
|
||||
assert!(!report.contains("123456"));
|
||||
assert!(!report.contains("1234567"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn brace_escape_types_literal_brace() {
|
||||
let a = expand("{{a", false).unwrap();
|
||||
assert_eq!(
|
||||
&a[0..4],
|
||||
&[
|
||||
KeyAction::Press(0xa0),
|
||||
KeyAction::Press(0xdb),
|
||||
KeyAction::Release(0xdb),
|
||||
KeyAction::Release(0xa0),
|
||||
]
|
||||
);
|
||||
assert_eq!(
|
||||
&a[4..6],
|
||||
&[KeyAction::Press(0x41), KeyAction::Release(0x41)]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn password_with_enter_suffix() {
|
||||
let a = expand("secret{Enter}", false).unwrap();
|
||||
assert_eq!(a.last(), Some(&KeyAction::Release(0x0d)));
|
||||
assert_eq!(a[a.len() - 2], KeyAction::Press(0x0d));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn action_list_zeroizes_on_drop() {
|
||||
let mut a = KeyAction::Press(0x41);
|
||||
a.zeroize();
|
||||
assert_eq!(a, KeyAction::Press(0));
|
||||
let list = ActionList::new(vec![KeyAction::Press(7), KeyAction::Release(7)]);
|
||||
assert_eq!(list.len(), 2);
|
||||
drop(list);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn send_actions_respects_delay_and_order() {
|
||||
use std::sync::{Arc, Mutex};
|
||||
let log = Arc::new(Mutex::new(Vec::new()));
|
||||
let recorded = log.clone();
|
||||
let actions = expand("a{Enter}", false).unwrap();
|
||||
let start = std::time::Instant::now();
|
||||
send_actions(
|
||||
|v| {
|
||||
let recorded = recorded.clone();
|
||||
Box::pin(async move {
|
||||
recorded.lock().unwrap().push(v);
|
||||
Ok(())
|
||||
})
|
||||
},
|
||||
actions.as_slice(),
|
||||
Duration::from_millis(20),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(start.elapsed() >= Duration::from_millis(50));
|
||||
let keys: Vec<_> = log
|
||||
.lock()
|
||||
.unwrap()
|
||||
.iter()
|
||||
.map(|v| {
|
||||
(
|
||||
v["action"].as_str().unwrap().to_owned(),
|
||||
v["key"].as_i64().unwrap(),
|
||||
)
|
||||
})
|
||||
.collect();
|
||||
assert_eq!(
|
||||
keys,
|
||||
vec![
|
||||
("kbd_press".into(), 0x41),
|
||||
("kbd_release".into(), 0x41),
|
||||
("kbd_press".into(), 0x0d),
|
||||
("kbd_release".into(), 0x0d),
|
||||
]
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,627 @@
|
||||
//! Local Unix-socket bridge: `uuremote-viewer type` hands secrets to a running desktop session.
|
||||
//! Frames are length-prefixed JSON; secrets never appear in logs. Peer UID must match.
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::{
|
||||
os::unix::fs::DirBuilderExt,
|
||||
path::{Path, PathBuf},
|
||||
};
|
||||
use tokio::{
|
||||
io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt},
|
||||
net::{UnixListener, UnixStream},
|
||||
sync::mpsc,
|
||||
};
|
||||
|
||||
/// Max JSON frame (header + secret). 16 KiB secret + margin.
|
||||
pub const MAX_FRAME: usize = 20 * 1024;
|
||||
|
||||
#[derive(Serialize, Deserialize)]
|
||||
pub struct TypeRequest {
|
||||
pub delay_ms: u64,
|
||||
pub omit_last: usize,
|
||||
pub snapshot: Option<String>,
|
||||
/// Secret text; Debug only exposes length.
|
||||
pub secret: String,
|
||||
}
|
||||
|
||||
impl std::fmt::Debug for TypeRequest {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
f.debug_struct("TypeRequest")
|
||||
.field("delay_ms", &self.delay_ms)
|
||||
.field("omit_last", &self.omit_last)
|
||||
.field(
|
||||
"snapshot",
|
||||
&self.snapshot.as_ref().map(|s| format!("len={}", s.len())),
|
||||
)
|
||||
.field("secret_len", &self.secret.len())
|
||||
.finish()
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for TypeRequest {
|
||||
fn drop(&mut self) {
|
||||
zeroize_string(&mut self.secret);
|
||||
if let Some(s) = self.snapshot.as_mut() {
|
||||
zeroize_string(s);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Serialize, Deserialize, Debug, Clone)]
|
||||
pub struct TypeResponse {
|
||||
pub ok: bool,
|
||||
pub events: usize,
|
||||
pub chars: usize,
|
||||
pub snapshot: Option<String>,
|
||||
pub error: Option<String>,
|
||||
}
|
||||
|
||||
fn zeroize_string(s: &mut String) {
|
||||
// Best-effort wipe before drop.
|
||||
let bytes = unsafe { s.as_bytes_mut() };
|
||||
for b in bytes.iter_mut() {
|
||||
*b = 0;
|
||||
}
|
||||
s.clear();
|
||||
}
|
||||
|
||||
/// Ensure `dir` is a real directory owned by us with mode & 0o077 == 0 (no symlink).
|
||||
pub fn validate_private_dir(dir: &Path) -> Result<(), String> {
|
||||
use std::os::unix::fs::{MetadataExt, PermissionsExt};
|
||||
let meta = std::fs::symlink_metadata(dir).map_err(|_| "Cannot inspect type-ipc directory")?;
|
||||
if meta.file_type().is_symlink() {
|
||||
return Err("Type-ipc path is a symlink".into());
|
||||
}
|
||||
if !meta.file_type().is_dir() {
|
||||
return Err("Type-ipc path is not a directory".into());
|
||||
}
|
||||
let me = unsafe { libc::getuid() };
|
||||
if meta.uid() != me {
|
||||
return Err("Type-ipc directory owner mismatch".into());
|
||||
}
|
||||
if meta.permissions().mode() & 0o077 != 0 {
|
||||
return Err("Type-ipc directory permissions too open".into());
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn runtime_dir() -> Result<PathBuf, String> {
|
||||
let base = std::env::var_os("XDG_RUNTIME_DIR")
|
||||
.map(PathBuf::from)
|
||||
.unwrap_or_else(|| {
|
||||
PathBuf::from(format!(
|
||||
"{}/uu-viewer-type-{}",
|
||||
std::env::temp_dir().display(),
|
||||
unsafe { libc::getuid() }
|
||||
))
|
||||
});
|
||||
let dir = if base.ends_with("uu-viewer-type") || base.file_name().is_some_and(|n| {
|
||||
n.to_string_lossy().starts_with("uu-viewer-type")
|
||||
}) {
|
||||
base
|
||||
} else {
|
||||
base.join("uu-viewer-type")
|
||||
};
|
||||
// Use symlink_metadata so a pre-planted symlink is not followed before we decide.
|
||||
match std::fs::symlink_metadata(&dir) {
|
||||
Ok(_) => {
|
||||
validate_private_dir(&dir)?;
|
||||
}
|
||||
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
|
||||
std::fs::DirBuilder::new()
|
||||
.recursive(true)
|
||||
.mode(0o700)
|
||||
.create(&dir)
|
||||
.map_err(|_| "Cannot create private type-ipc directory")?;
|
||||
validate_private_dir(&dir)?;
|
||||
}
|
||||
Err(_) => return Err("Cannot inspect type-ipc directory".into()),
|
||||
}
|
||||
Ok(dir)
|
||||
}
|
||||
|
||||
pub fn device_key(device: &str) -> String {
|
||||
use sha2::{Digest, Sha256};
|
||||
hex::encode(Sha256::digest(device.as_bytes()))
|
||||
}
|
||||
|
||||
pub fn socket_path(device: &str) -> Result<PathBuf, String> {
|
||||
Ok(runtime_dir()?.join(format!("{}.sock", device_key(device))))
|
||||
}
|
||||
|
||||
pub fn default_snapshot_path(device: &str) -> Result<PathBuf, String> {
|
||||
let ts = std::time::SystemTime::now()
|
||||
.duration_since(std::time::UNIX_EPOCH)
|
||||
.map(|d| d.as_millis())
|
||||
.unwrap_or(0);
|
||||
Ok(runtime_dir()?.join(format!("snap-{}-{ts}.png", &device_key(device)[..12])))
|
||||
}
|
||||
|
||||
pub async fn read_frame(r: &mut (impl AsyncRead + Unpin)) -> Result<Vec<u8>, String> {
|
||||
let n = r.read_u32().await.map_err(|_| "Type IPC closed")? as usize;
|
||||
if n > MAX_FRAME {
|
||||
return Err("Type IPC frame exceeds size limit".into());
|
||||
}
|
||||
let mut b = vec![0; n];
|
||||
r.read_exact(&mut b)
|
||||
.await
|
||||
.map_err(|_| "Type IPC closed")?;
|
||||
Ok(b)
|
||||
}
|
||||
|
||||
pub async fn write_frame(w: &mut (impl AsyncWrite + Unpin), body: &[u8]) -> Result<(), String> {
|
||||
if body.len() > MAX_FRAME {
|
||||
return Err("Type IPC frame exceeds size limit".into());
|
||||
}
|
||||
w.write_u32(body.len() as u32)
|
||||
.await
|
||||
.map_err(|_| "Type IPC closed")?;
|
||||
w.write_all(body).await.map_err(|_| "Type IPC closed")?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn check_peer(stream: &UnixStream) -> Result<(), String> {
|
||||
let cred = stream
|
||||
.peer_cred()
|
||||
.map_err(|_| "Type IPC peer credentials unavailable")?;
|
||||
let uid = cred.uid();
|
||||
let me = unsafe { libc::getuid() };
|
||||
if uid != me {
|
||||
return Err("Type IPC peer uid mismatch".into());
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub struct Server {
|
||||
pub path: PathBuf,
|
||||
listener: Option<UnixListener>,
|
||||
}
|
||||
|
||||
impl Drop for Server {
|
||||
fn drop(&mut self) {
|
||||
let _ = std::fs::remove_file(&self.path);
|
||||
}
|
||||
}
|
||||
|
||||
impl Server {
|
||||
pub async fn bind(device: &str) -> Result<Self, String> {
|
||||
let path = socket_path(device)?;
|
||||
if path.exists() {
|
||||
match UnixStream::connect(&path).await {
|
||||
Ok(_) => return Err("A desktop viewer is already listening for this device".into()),
|
||||
Err(_) => {
|
||||
let _ = std::fs::remove_file(&path);
|
||||
}
|
||||
}
|
||||
}
|
||||
let listener = UnixListener::bind(&path).map_err(|_| "Cannot bind type IPC socket")?;
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
let _ = std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o600));
|
||||
Ok(Self { path, listener: Some(listener) })
|
||||
}
|
||||
|
||||
/// Accept connections and forward validated TypeRequests to `tx`.
|
||||
pub async fn run(mut self, tx: mpsc::Sender<PendingType>) {
|
||||
let path = self.path.clone();
|
||||
let listener = self.listener.take().expect("type IPC listener");
|
||||
// Prevent Drop from removing the socket twice while we still hold `path` in a guard.
|
||||
self.path = PathBuf::new();
|
||||
struct Guard(PathBuf);
|
||||
impl Drop for Guard {
|
||||
fn drop(&mut self) {
|
||||
if !self.0.as_os_str().is_empty() {
|
||||
let _ = std::fs::remove_file(&self.0);
|
||||
}
|
||||
}
|
||||
}
|
||||
let _guard = Guard(path);
|
||||
loop {
|
||||
let accepted = listener.accept().await;
|
||||
let Ok((stream, _)) = accepted else { break };
|
||||
if check_peer(&stream).is_err() {
|
||||
continue;
|
||||
}
|
||||
let tx = tx.clone();
|
||||
tokio::spawn(async move {
|
||||
let _ = serve_client(stream, tx).await;
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct PendingType {
|
||||
pub request: TypeRequest,
|
||||
pub reply: tokio::sync::oneshot::Sender<TypeResponse>,
|
||||
}
|
||||
|
||||
async fn serve_client(mut stream: UnixStream, tx: mpsc::Sender<PendingType>) -> Result<(), String> {
|
||||
let body = read_frame(&mut stream).await?;
|
||||
let request: TypeRequest =
|
||||
serde_json::from_slice(&body).map_err(|_| "Invalid type IPC request")?;
|
||||
let mut body = body;
|
||||
for b in &mut body {
|
||||
*b = 0;
|
||||
}
|
||||
let (reply_tx, reply_rx) = tokio::sync::oneshot::channel();
|
||||
// Move request into PendingType; zeroize on drop if send fails.
|
||||
if tx
|
||||
.send(PendingType {
|
||||
request,
|
||||
reply: reply_tx,
|
||||
})
|
||||
.await
|
||||
.is_err()
|
||||
{
|
||||
return Err("Desktop session is gone".into());
|
||||
}
|
||||
let response = reply_rx.await.map_err(|_| "Desktop session is gone")?;
|
||||
let out = serde_json::to_vec(&response).map_err(|_| "Type IPC encode failed")?;
|
||||
write_frame(&mut stream, &out).await
|
||||
}
|
||||
|
||||
/// Client: deliver a type request to a running viewer. Returns response or connection error.
|
||||
pub async fn send_to_viewer(device: &str, mut request: TypeRequest) -> Result<TypeResponse, String> {
|
||||
let path = socket_path(device)?;
|
||||
let mut stream = UnixStream::connect(&path)
|
||||
.await
|
||||
.map_err(|_| "No running desktop viewer for this device")?;
|
||||
check_peer(&stream)?;
|
||||
let body = serde_json::to_vec(&request).map_err(|_| "Type IPC encode failed")?;
|
||||
// Clear serde copy in request early — response path still needs omit metadata only.
|
||||
zeroize_string(&mut request.secret);
|
||||
write_frame(&mut stream, &body).await?;
|
||||
// Wipe encoded body
|
||||
let mut body = body;
|
||||
for b in &mut body {
|
||||
*b = 0;
|
||||
}
|
||||
let resp_body = read_frame(&mut stream).await?;
|
||||
let response: TypeResponse =
|
||||
serde_json::from_slice(&resp_body).map_err(|_| "Invalid type IPC response")?;
|
||||
Ok(response)
|
||||
}
|
||||
|
||||
/// Encode an RGB24 frame as a minimal PNG (8-bit RGB, no filtering beyond None).
|
||||
/// Write RGB24 as PNG. Always uses O_NOFOLLOW + mode 0600.
|
||||
/// `create_new`: true for default runtime paths (refuse overwrite); false for user `--snapshot`.
|
||||
pub fn write_png_rgb(
|
||||
path: &Path,
|
||||
width: u32,
|
||||
height: u32,
|
||||
rgb: &[u8],
|
||||
create_new: bool,
|
||||
) -> Result<(), String> {
|
||||
let expected = width as usize * height as usize * 3;
|
||||
if rgb.len() != expected || width == 0 || height == 0 {
|
||||
return Err("Snapshot frame size mismatch".into());
|
||||
}
|
||||
use flate2::{write::ZlibEncoder, Compression};
|
||||
use std::io::Write;
|
||||
let mut raw = Vec::with_capacity((width as usize * 3 + 1) * height as usize);
|
||||
for row in 0..height as usize {
|
||||
raw.push(0); // filter None
|
||||
let start = row * width as usize * 3;
|
||||
raw.extend_from_slice(&rgb[start..start + width as usize * 3]);
|
||||
}
|
||||
let mut enc = ZlibEncoder::new(Vec::new(), Compression::fast());
|
||||
enc.write_all(&raw).map_err(|_| "Snapshot zlib failed")?;
|
||||
for b in &mut raw {
|
||||
*b = 0;
|
||||
}
|
||||
let compressed = enc.finish().map_err(|_| "Snapshot zlib failed")?;
|
||||
|
||||
fn chunk(tag: &[u8; 4], data: &[u8], out: &mut Vec<u8>) {
|
||||
out.extend_from_slice(&(data.len() as u32).to_be_bytes());
|
||||
out.extend_from_slice(tag);
|
||||
out.extend_from_slice(data);
|
||||
let mut crc = crc32_ieee_update(0xffff_ffff, tag);
|
||||
crc = crc32_ieee_update(crc, data);
|
||||
out.extend_from_slice(&(crc ^ 0xffff_ffff).to_be_bytes());
|
||||
}
|
||||
let mut png = Vec::with_capacity(compressed.len() + 128);
|
||||
png.extend_from_slice(&[137, 80, 78, 71, 13, 10, 26, 10]);
|
||||
let mut ihdr = Vec::with_capacity(13);
|
||||
ihdr.extend_from_slice(&width.to_be_bytes());
|
||||
ihdr.extend_from_slice(&height.to_be_bytes());
|
||||
ihdr.extend_from_slice(&[8, 2, 0, 0, 0]); // 8-bit RGB
|
||||
chunk(b"IHDR", &ihdr, &mut png);
|
||||
chunk(b"IDAT", &compressed, &mut png);
|
||||
chunk(b"IEND", &[], &mut png);
|
||||
|
||||
use std::os::unix::fs::OpenOptionsExt;
|
||||
let mut opts = std::fs::OpenOptions::new();
|
||||
opts.write(true).mode(0o600).custom_flags(libc::O_NOFOLLOW);
|
||||
if create_new {
|
||||
opts.create_new(true);
|
||||
} else {
|
||||
opts.create(true).truncate(true);
|
||||
}
|
||||
let mut file = opts
|
||||
.open(path)
|
||||
.map_err(|_| "Cannot write snapshot file")?;
|
||||
file.write_all(&png).map_err(|_| "Cannot write snapshot file")?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn crc32_ieee(data: &[u8]) -> u32 {
|
||||
crc32_ieee_update(0xffff_ffff, data) ^ 0xffff_ffff
|
||||
}
|
||||
fn crc32_ieee_update(mut crc: u32, data: &[u8]) -> u32 {
|
||||
for &b in data {
|
||||
crc ^= u32::from(b);
|
||||
for _ in 0..8 {
|
||||
let mask = (!(crc & 1)).wrapping_add(1); // 0 or 0xFFFFFFFF
|
||||
crc = (crc >> 1) ^ (0xEDB8_8320 & mask);
|
||||
}
|
||||
}
|
||||
crc
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn frame_limit_rejects_oversized_length() {
|
||||
// Unit-level: MAX_FRAME constant is the contract used by read_frame.
|
||||
assert!(MAX_FRAME >= 16 * 1024);
|
||||
assert!(MAX_FRAME < 1024 * 1024);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn device_key_is_stable_hex() {
|
||||
let a = device_key("device-1");
|
||||
let b = device_key("device-1");
|
||||
assert_eq!(a, b);
|
||||
assert_eq!(a.len(), 64);
|
||||
assert!(a.chars().all(|c| c.is_ascii_hexdigit()));
|
||||
assert_ne!(device_key("device-1"), device_key("device-2"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn png_roundtrip_header_and_mode() {
|
||||
let dir = tempfile_dir();
|
||||
let path = dir.join("t.png");
|
||||
write_png_rgb(&path, 2, 2, &[255, 0, 0, 0, 255, 0, 0, 0, 255, 255, 255, 255], true).unwrap();
|
||||
let meta = std::fs::metadata(&path).unwrap();
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
assert_eq!(meta.permissions().mode() & 0o777, 0o600);
|
||||
let bytes = std::fs::read(&path).unwrap();
|
||||
assert_eq!(&bytes[..8], &[137, 80, 78, 71, 13, 10, 26, 10]);
|
||||
let _ = std::fs::remove_dir_all(dir);
|
||||
}
|
||||
|
||||
fn tempfile_dir() -> PathBuf {
|
||||
use std::os::unix::fs::DirBuilderExt;
|
||||
let dir = std::env::temp_dir().join(format!("uu-type-ipc-test-{}", std::process::id()));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
std::fs::DirBuilder::new()
|
||||
.mode(0o700)
|
||||
.create(&dir)
|
||||
.unwrap();
|
||||
dir
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn server_client_roundtrip_and_uid_gate() {
|
||||
let device = format!("ipc-test-{}", uuidish());
|
||||
let server = Server::bind(&device).await.unwrap();
|
||||
let path = server.path.clone();
|
||||
let (tx, mut rx) = mpsc::channel::<PendingType>(4);
|
||||
let run = tokio::spawn(async move { server.run(tx).await });
|
||||
// Handle one request in background
|
||||
let worker = tokio::spawn(async move {
|
||||
if let Some(pending) = rx.recv().await {
|
||||
assert_eq!(pending.request.secret, "sentinel-SECRET-9f3a");
|
||||
assert_eq!(pending.request.delay_ms, 10);
|
||||
assert_eq!(pending.request.omit_last, 1);
|
||||
let _ = pending.reply.send(TypeResponse {
|
||||
ok: true,
|
||||
events: 12,
|
||||
chars: 6,
|
||||
snapshot: Some("/tmp/fake.png".into()),
|
||||
error: None,
|
||||
});
|
||||
}
|
||||
});
|
||||
let response = send_to_viewer(
|
||||
&device,
|
||||
TypeRequest {
|
||||
delay_ms: 10,
|
||||
omit_last: 1,
|
||||
snapshot: None,
|
||||
secret: "sentinel-SECRET-9f3a".into(),
|
||||
},
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(response.ok);
|
||||
assert_eq!(response.events, 12);
|
||||
assert_eq!(response.snapshot.as_deref(), Some("/tmp/fake.png"));
|
||||
worker.abort();
|
||||
run.abort();
|
||||
let _ = std::fs::remove_file(path);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn connect_without_server_errors_without_secret() {
|
||||
let device = format!("missing-{}", uuidish());
|
||||
let err = send_to_viewer(
|
||||
&device,
|
||||
TypeRequest {
|
||||
delay_ms: 0,
|
||||
omit_last: 0,
|
||||
snapshot: None,
|
||||
secret: "sentinel-SECRET-9f3a".into(),
|
||||
},
|
||||
)
|
||||
.await
|
||||
.unwrap_err();
|
||||
assert!(err.contains("No running desktop viewer"));
|
||||
assert!(!err.contains("sentinel"));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn oversized_frame_rejected() {
|
||||
let device = format!("oversize-{}", uuidish());
|
||||
let server = Server::bind(&device).await.unwrap();
|
||||
let path = server.path.clone();
|
||||
let (tx, mut rx) = mpsc::channel::<PendingType>(1);
|
||||
let run = tokio::spawn(async move { server.run(tx).await });
|
||||
// Drain so accept happens
|
||||
let _drain = tokio::spawn(async move { while rx.recv().await.is_some() {} });
|
||||
let mut stream = UnixStream::connect(&path).await.unwrap();
|
||||
let huge = vec![0u8; MAX_FRAME + 1];
|
||||
let result = write_frame(&mut stream, &huge).await;
|
||||
// Client-side write_frame rejects before send
|
||||
assert!(result.is_err());
|
||||
assert!(!format!("{result:?}").contains("sentinel"));
|
||||
run.abort();
|
||||
let _ = std::fs::remove_file(path);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn validate_private_dir_rejects_symlink_and_open_mode() {
|
||||
use std::os::unix::fs::{DirBuilderExt, PermissionsExt};
|
||||
let base = std::env::temp_dir().join(format!(
|
||||
"uu-type-ipc-val-{}-{}",
|
||||
std::process::id(),
|
||||
uuidish()
|
||||
));
|
||||
let _ = std::fs::remove_dir_all(&base);
|
||||
std::fs::DirBuilder::new().mode(0o700).create(&base).unwrap();
|
||||
|
||||
let open = base.join("open");
|
||||
std::fs::DirBuilder::new().mode(0o755).create(&open).unwrap();
|
||||
let err = validate_private_dir(&open).unwrap_err();
|
||||
assert!(err.contains("permissions"), "{err}");
|
||||
assert!(!err.contains("sentinel"));
|
||||
|
||||
let good = base.join("good");
|
||||
std::fs::DirBuilder::new().mode(0o700).create(&good).unwrap();
|
||||
validate_private_dir(&good).unwrap();
|
||||
|
||||
let link = base.join("link");
|
||||
std::os::unix::fs::symlink(&good, &link).unwrap();
|
||||
let err = validate_private_dir(&link).unwrap_err();
|
||||
assert!(err.contains("symlink"), "{err}");
|
||||
|
||||
let file = base.join("file");
|
||||
std::fs::write(&file, b"x").unwrap();
|
||||
let err = validate_private_dir(&file).unwrap_err();
|
||||
assert!(err.contains("not a directory"), "{err}");
|
||||
|
||||
let _ = std::fs::remove_dir_all(&base);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn runtime_dir_rejects_preexisting_open_or_symlink() {
|
||||
use std::os::unix::fs::DirBuilderExt;
|
||||
// Serialize against other tests that read/write process environment.
|
||||
let _env = crate::viewer::secure_input::ENV_LOCK.lock().unwrap();
|
||||
let base = std::env::temp_dir().join(format!(
|
||||
"uu-type-ipc-rt-{}-{}",
|
||||
std::process::id(),
|
||||
uuidish()
|
||||
));
|
||||
let _ = std::fs::remove_dir_all(&base);
|
||||
std::fs::DirBuilder::new().mode(0o700).create(&base).unwrap();
|
||||
|
||||
// Point XDG_RUNTIME_DIR at a private base; plant a bad uu-viewer-type child.
|
||||
let child = base.join("uu-viewer-type");
|
||||
std::fs::DirBuilder::new().mode(0o755).create(&child).unwrap();
|
||||
let _guard = EnvGuard::set("XDG_RUNTIME_DIR", base.to_str().unwrap());
|
||||
let err = runtime_dir().unwrap_err();
|
||||
assert!(err.contains("permissions"), "{err}");
|
||||
let _ = std::fs::remove_dir_all(&child);
|
||||
|
||||
let target = base.join("target");
|
||||
std::fs::DirBuilder::new().mode(0o700).create(&target).unwrap();
|
||||
std::os::unix::fs::symlink(&target, &child).unwrap();
|
||||
let err = runtime_dir().unwrap_err();
|
||||
assert!(err.contains("symlink"), "{err}");
|
||||
let _ = std::fs::remove_file(&child);
|
||||
|
||||
// Fresh create succeeds and validates.
|
||||
let dir = runtime_dir().unwrap();
|
||||
assert!(dir.ends_with("uu-viewer-type"));
|
||||
validate_private_dir(&dir).unwrap();
|
||||
let _ = std::fs::remove_dir_all(&base);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn write_png_refuses_symlink_target() {
|
||||
let dir = tempfile_dir();
|
||||
let real = dir.join("real.png");
|
||||
let link = dir.join("link.png");
|
||||
std::fs::write(&real, b"old").unwrap();
|
||||
std::os::unix::fs::symlink(&real, &link).unwrap();
|
||||
let err = write_png_rgb(
|
||||
&link,
|
||||
1,
|
||||
1,
|
||||
&[1, 2, 3],
|
||||
false,
|
||||
)
|
||||
.unwrap_err();
|
||||
assert!(err.contains("Cannot write snapshot"), "{err}");
|
||||
// Original untouched
|
||||
assert_eq!(std::fs::read(&real).unwrap(), b"old");
|
||||
let _ = std::fs::remove_dir_all(dir);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn write_png_create_new_refuses_existing() {
|
||||
let dir = tempfile_dir();
|
||||
let path = dir.join("exists.png");
|
||||
std::fs::write(&path, b"old").unwrap();
|
||||
let err = write_png_rgb(&path, 1, 1, &[1, 2, 3], true).unwrap_err();
|
||||
assert!(err.contains("Cannot write snapshot"), "{err}");
|
||||
assert_eq!(std::fs::read(&path).unwrap(), b"old");
|
||||
let _ = std::fs::remove_dir_all(dir);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn type_request_debug_shows_secret_len_only() {
|
||||
let req = TypeRequest {
|
||||
delay_ms: 40,
|
||||
omit_last: 1,
|
||||
snapshot: Some("/tmp/out.png".into()),
|
||||
secret: "sentinel-SECRET-9f3a".into(),
|
||||
};
|
||||
let d = format!("{req:?}");
|
||||
assert!(d.contains("secret_len: 20") || d.contains("secret_len: 20,"), "{d}");
|
||||
assert!(!d.contains("sentinel"));
|
||||
assert!(!d.contains("SECRET"));
|
||||
assert!(!d.contains("9f3a"));
|
||||
}
|
||||
|
||||
struct EnvGuard {
|
||||
key: &'static str,
|
||||
prev: Option<std::ffi::OsString>,
|
||||
}
|
||||
impl EnvGuard {
|
||||
fn set(key: &'static str, val: &str) -> Self {
|
||||
let prev = std::env::var_os(key);
|
||||
std::env::set_var(key, val);
|
||||
Self { key, prev }
|
||||
}
|
||||
}
|
||||
impl Drop for EnvGuard {
|
||||
fn drop(&mut self) {
|
||||
match &self.prev {
|
||||
Some(v) => std::env::set_var(self.key, v),
|
||||
None => std::env::remove_var(self.key),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn uuidish() -> String {
|
||||
format!(
|
||||
"{:x}",
|
||||
std::time::SystemTime::now()
|
||||
.duration_since(std::time::UNIX_EPOCH)
|
||||
.unwrap()
|
||||
.as_nanos()
|
||||
)
|
||||
}
|
||||
}
|
||||
+109
-3
@@ -13,7 +13,7 @@ use viewer::clipboard;
|
||||
#[cfg(test)] #[path="initialization.rs"] mod initialization;
|
||||
use viewer::{api::Api,rtc::ReadyPolicy,session::{Options,Session},wire::Shape};
|
||||
use std::time::Duration;
|
||||
const HELP:&str="Experimental native viewer.\n uuremote-viewer ui (GTK window: sign-in, devices, sessions) Desktop UI requires viewer-sdl (decodes with the ffmpeg CLI, or FFmpeg 6.x libraries with viewer-ffmpeg).\n uuremote-viewer power DEVICE reboot|shutdown\n uuremote-viewer unbind DEVICE [--shared] (从账号删除设备 / remove a device from the account)\n uuremote-viewer terminal DEVICE [SESSION]\n uuremote-viewer files DEVICE ls PATH | get REMOTE LOCAL | put LOCAL REMOTE\n uuremote-viewer portmap DEVICE LOCAL_PORT HOST PORT\n uuremote-viewer files-ui|portmap-ui|terminal-ui DEVICE NAME (GTK tool windows)\n uuremote-viewer login [--no-gui]\n uuremote-viewer devices METHOD ARRAY_POINTER ID_POINTER NAME_POINTER\n uuremote-viewer assist CONNECT_ID (验证码从 stdin 读取一行)\n uuremote-viewer connect DEVICE true|false SHAPE_JSON echo|manual raw|legacy [--view-only]\nVideo: UU_VIEWER_CODEC=h264 forces H.264; UU_VIEWER_CHROMA=444 requests true color (default 4:2:0).\nAudio: UU_VIEWER_AUDIO=0 disables playback. UU_VIEWER_VIEW_ONLY=1 disables desktop input.\nDevice-list method/JSON pointers and compatibility shape require verified operator configuration.\nQR login reuses the sibling uuremote-server login command. Never run login in a captured log.\nEcho readiness is transport observation only; no sendVideoTrack RPC is emitted.";
|
||||
const HELP:&str="Experimental native viewer.\n uuremote-viewer ui (GTK window: sign-in, devices, sessions) Desktop UI requires viewer-sdl (decodes with the ffmpeg CLI, or FFmpeg 6.x libraries with viewer-ffmpeg).\n uuremote-viewer power DEVICE reboot|shutdown\n uuremote-viewer type DEVICE [options] (secret from UU_INPUT_ENV or stdin; reuses running viewer)\n options: --delay-ms MS --omit-last N --snapshot PATH --dry-run --new-session\n uuremote-viewer unbind DEVICE [--shared] (从账号删除设备 / remove a device from the account)\n uuremote-viewer terminal DEVICE [SESSION]\n uuremote-viewer files DEVICE ls PATH | get REMOTE LOCAL | put LOCAL REMOTE\n uuremote-viewer portmap DEVICE LOCAL_PORT HOST PORT\n uuremote-viewer files-ui|portmap-ui|terminal-ui DEVICE NAME (GTK tool windows)\n uuremote-viewer login [--no-gui]\n uuremote-viewer devices METHOD ARRAY_POINTER ID_POINTER NAME_POINTER\n uuremote-viewer assist CONNECT_ID (验证码从 stdin 读取一行)\n uuremote-viewer connect DEVICE true|false SHAPE_JSON echo|manual raw|legacy [--view-only]\nVideo: UU_VIEWER_CODEC=h264 forces H.264; UU_VIEWER_CHROMA=444 requests true color (default 4:2:0).\nAudio: UU_VIEWER_AUDIO=0 disables playback. UU_VIEWER_VIEW_ONLY=1 disables desktop input.\nDevice-list method/JSON pointers and compatibility shape require verified operator configuration.\nQR login reuses the sibling uuremote-server login command. Never run login in a captured log.\nEcho readiness is transport observation only; no sendVideoTrack RPC is emitted.";
|
||||
const DEFAULT_SHAPE:&str=r#"{"capture_type":1,"platform":3,"client_version":"4.42.0","width":1920,"height":1080,"fps":60,"chroma":1,
|
||||
"decoders":[{"fps":60,"codec":1,"width":3840,"height":2160,"chroma":1}],"display_modes":[[1920,1080,60]],
|
||||
"displays":[{"id":1,"fps":60,"type":0,"hdr":0}],
|
||||
@@ -60,6 +60,7 @@ async fn run(args:&[String])->Result<(),String> {
|
||||
println!("已从账号删除设备");Ok(())
|
||||
}
|
||||
Some("power")=>power_command(args).await,
|
||||
Some("type")=>type_command(args).await,
|
||||
Some("terminal-local") if args.len()==2 || args.len()==3=>{
|
||||
let session=if args.len()==3{Some(args[2].parse::<u32>().ok().filter(|n|*n!=0).ok_or("Invalid terminal session id")?)}else{None};
|
||||
viewer::tools::terminal_ipc::client(std::path::Path::new(&args[1]),session).await
|
||||
@@ -111,11 +112,93 @@ async fn desktop_command(args:&[String],code:Option<String>)->Result<(),String>
|
||||
let options=Options{timeout:Duration::from_secs(12),legacy_prefix:legacy,ready_policy:policy,clipboard};
|
||||
let mut session=Session::open(&room,&shape,&creds.device_id,&creds.client_id,options,Default::default()).await?;
|
||||
#[cfg(feature="viewer-sdl")]
|
||||
let result=if let Some((window,decoder))=desktop.as_mut(){viewer::sdl::run(&mut session,window,decoder.as_mut(),view_only).await}else{session.run().await};
|
||||
let result=if let Some((window,decoder))=desktop.as_mut(){viewer::sdl::run(&mut session,window,decoder.as_mut(),view_only,&args[1]).await}else{session.run().await};
|
||||
#[cfg(not(feature="viewer-sdl"))]
|
||||
let result=session.run().await;
|
||||
session.close().await;result
|
||||
}
|
||||
async fn type_command(args:&[String])->Result<(),String>{
|
||||
// type DEVICE [--delay-ms MS] [--omit-last N] [--snapshot PATH] [--dry-run] [--new-session]
|
||||
if args.len()<2 || args[1].trim().is_empty() { return Err(HELP.into()) }
|
||||
let device=&args[1];
|
||||
let mut delay_ms:Option<&str>=None;
|
||||
let mut omit_last:Option<&str>=None;
|
||||
let mut snapshot:Option<String>=None;
|
||||
let mut dry_run=false;
|
||||
let mut new_session=false;
|
||||
let mut i=2;
|
||||
while i<args.len() {
|
||||
match args[i].as_str() {
|
||||
"--delay-ms" => {
|
||||
i+=1; delay_ms=Some(args.get(i).map(String::as_str).ok_or_else(||HELP.to_string())?);
|
||||
}
|
||||
"--omit-last" => {
|
||||
i+=1; omit_last=Some(args.get(i).map(String::as_str).ok_or_else(||HELP.to_string())?);
|
||||
}
|
||||
"--snapshot" => {
|
||||
i+=1; snapshot=Some(args.get(i).cloned().ok_or_else(||HELP.to_string())?);
|
||||
}
|
||||
"--dry-run" => { dry_run=true; }
|
||||
"--new-session" => { new_session=true; }
|
||||
_ => return Err(HELP.into()),
|
||||
}
|
||||
i+=1;
|
||||
}
|
||||
let delay=viewer::secure_input::parse_delay_ms(delay_ms)?;
|
||||
let omit=viewer::secure_input::parse_omit_last(omit_last)?;
|
||||
let mut secret=viewer::secure_input::load_secret(std::io::stdin().lock())?;
|
||||
if dry_run {
|
||||
let report=viewer::secure_input::dry_run_report(&secret, omit, false)?;
|
||||
drop(secret);
|
||||
println!("{report}");
|
||||
return Ok(());
|
||||
}
|
||||
secret.omit_last_chars(omit)?;
|
||||
// Prefer a running desktop viewer (avoids force-replacing the live session, upstream #30).
|
||||
match viewer::type_ipc::socket_path(device) {
|
||||
Ok(path) if path.exists() && !new_session => {
|
||||
let req=viewer::type_ipc::TypeRequest{
|
||||
delay_ms: delay.as_millis() as u64,
|
||||
omit_last: 0, // already applied locally
|
||||
snapshot,
|
||||
secret: secret.as_str().to_owned(),
|
||||
};
|
||||
drop(secret);
|
||||
let response=viewer::type_ipc::send_to_viewer(device, req).await?;
|
||||
if !response.ok {
|
||||
return Err(response.error.unwrap_or_else(||"Secure input failed on running viewer".into()));
|
||||
}
|
||||
println!("安全输入已发送({} 个按键事件,{} 字符)。", response.events, response.chars);
|
||||
if let Some(path)=response.snapshot {
|
||||
println!("snapshot={path}");
|
||||
log::info!("Secure input snapshot: {path}");
|
||||
}
|
||||
return Ok(());
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
if !new_session {
|
||||
drop(secret);
|
||||
return Err("No running desktop viewer for this device; open a connect/ui session first, or pass --new-session".into());
|
||||
}
|
||||
let mut shape:Shape=serde_json::from_str(DEFAULT_SHAPE).map_err(|_|"Invalid built-in type shape")?;
|
||||
shape.capture_type=1;
|
||||
let creds=credentials()?;let api=Api::new(auth::UUAuthClient::new(creds.clone()),auth::BASE_URL);
|
||||
let room=api.join(device,false,true).await.map_err(|e|e.to_string())?;
|
||||
let mac=api.target_is_mac(&room,Some(device)).await.map_err(|e|e.to_string())?;
|
||||
let actions=viewer::secure_input::expand(secret.as_str(),mac)?;
|
||||
let event_count=actions.len();
|
||||
let char_count=secret.chars_count();
|
||||
drop(secret);
|
||||
log::info!("Secure input prepared (new session): chars={} events={} delay_ms={} mac={}", char_count, event_count, delay.as_millis(), mac);
|
||||
let options=Options{timeout:Duration::from_secs(12),legacy_prefix:true,ready_policy:ReadyPolicy::EchoOnly,clipboard:clipboard::Bridge::new(false)};
|
||||
let mut session=Session::open(&room,&shape,&creds.device_id,&creds.client_id,options,Default::default()).await?;
|
||||
let result=viewer::secure_input::run_session(&mut session,actions.as_slice(),delay).await;
|
||||
session.close().await;
|
||||
if result.is_ok(){println!("安全输入已发送({event_count} 个按键事件);新会话路径无截图。");}
|
||||
result
|
||||
}
|
||||
|
||||
fn credentials()->Result<auth::Credentials,String> {auth::Credentials::load(config::read_fresh().map_err(|_|"Cannot read credential configuration")?.as_ref())}
|
||||
fn api()->Result<Api,String> {Ok(Api::new(auth::UUAuthClient::new(credentials()?),auth::BASE_URL))}
|
||||
|
||||
@@ -128,11 +211,34 @@ mod cli_tests {
|
||||
use super::*;
|
||||
#[tokio::test]
|
||||
async fn invalid_commands_never_fall_through_to_login_or_host_service() {
|
||||
for args in [vec!["invalid"],vec!["power"],vec!["power","device","logout"],vec!["power","device","reboot","extra"],vec!["login","--invalid"],vec!["connect"],vec!["assist"],vec!["assist","id","forbidden-code-argument"],vec!["terminal"],vec!["terminal","device","extra"],vec!["terminal","device","0"],vec!["terminal","device","4294967296"],vec!["terminal-ui","device"],vec!["files","device","bad","path"],vec!["portmap","device","bad","host","80"],vec!["portmap","device","8000","host","0"],vec!["devices","DELETE","/data","/id","/name"],vec!["unbind"],vec!["unbind",""],vec!["unbind","device","--other"],vec!["unbind","device","--shared","extra"]] {
|
||||
for args in [vec!["invalid"],vec!["power"],vec!["power","device","logout"],vec!["power","device","reboot","extra"],vec!["type"],vec!["type","device","--delay-ms"],vec!["type","device","--delay-ms","x"],vec!["type","device","extra"],vec!["type","device","--omit-last"],vec!["type","device","--snapshot"],vec!["login","--invalid"],vec!["connect"],vec!["assist"],vec!["assist","id","forbidden-code-argument"],vec!["terminal"],vec!["terminal","device","extra"],vec!["terminal","device","0"],vec!["terminal","device","4294967296"],vec!["terminal-ui","device"],vec!["files","device","bad","path"],vec!["portmap","device","bad","host","80"],vec!["portmap","device","8000","host","0"],vec!["devices","DELETE","/data","/id","/name"],vec!["unbind"],vec!["unbind",""],vec!["unbind","device","--other"],vec!["unbind","device","--shared","extra"]] {
|
||||
assert!(run(&args.into_iter().map(str::to_owned).collect::<Vec<_>>()).await.is_err());
|
||||
}
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn type_dry_run_and_no_viewer_paths_are_redacted() {
|
||||
let _g = viewer::secure_input::ENV_LOCK.lock().unwrap();
|
||||
std::env::set_var("UU_INPUT_ENV", "UU_TYPE_SENTINEL_ENV");
|
||||
std::env::set_var("UU_TYPE_SENTINEL_ENV", "sentinel-SECRET-9f3a");
|
||||
let out = {
|
||||
// dry-run
|
||||
let args: Vec<String> = ["type","missing-device-id","--dry-run"].into_iter().map(str::to_owned).collect();
|
||||
// reload env for dry-run — previous load_secret removed the var
|
||||
std::env::set_var("UU_INPUT_ENV", "UU_TYPE_SENTINEL_ENV");
|
||||
std::env::set_var("UU_TYPE_SENTINEL_ENV", "sentinel-SECRET-9f3a");
|
||||
run(&args).await
|
||||
};
|
||||
assert!(out.is_ok(), "{out:?}");
|
||||
std::env::set_var("UU_INPUT_ENV", "UU_TYPE_SENTINEL_ENV");
|
||||
std::env::set_var("UU_TYPE_SENTINEL_ENV", "sentinel-SECRET-9f3a");
|
||||
let err = run(&["type".into(),"missing-device-id".into()]).await.unwrap_err();
|
||||
assert!(err.contains("No running desktop viewer") || err.contains("--new-session"), "{err}");
|
||||
assert!(!err.contains("sentinel"));
|
||||
assert!(!err.contains("SECRET"));
|
||||
std::env::remove_var("UU_INPUT_ENV");
|
||||
std::env::remove_var("UU_TYPE_SENTINEL_ENV");
|
||||
}
|
||||
#[tokio::test]
|
||||
async fn login_reuses_companion_subcommand_with_a_local_process_mock() {
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
let path=std::env::temp_dir().join(format!("uu-viewer-login-mock-{}",viewer::wire::uuid()));
|
||||
|
||||
Reference in new issue
Block a user