1use crate::*;
2use axum::extract::{
3 FromRequestParts,
4 ws::{CloseFrame, Message, WebSocket, WebSocketUpgrade},
5};
6use futures::{SinkExt, StreamExt};
7use tokio::io::{AsyncReadExt, AsyncWriteExt};
8
9pub fn visible(me: &Value, domain: &Value) -> bool {
10 let owner = &domain["owner"];
11 (owner.as_str().is_some_and(|id| !id.is_empty()) && owner == &me["id"])
12 || array(&me["groups"]).iter().any(|group| group == "infra-admin")
13}
14
15pub async fn authorize(me: &Value, name: &str) -> Result<()> {
16 let owner = host::call(json!({"operation":"vm.owner","payload":{"name":name}})).await?;
17 if visible(me, &owner) {
18 Ok(())
19 } else {
20 Err(Error::new(
21 404,
22 "This VM isn't in your account. Open your VM home.",
23 ))
24 }
25}
26
27pub async fn console(request: Request, name: &str, serial: bool) -> Result<Response> {
28 // Browsers send Origin on a WebSocket handshake. Reject cross-site control.
29 same_origin(&request)?;
30 let (mut parts, _) = request.into_parts();
31 let upgrade = WebSocketUpgrade::from_request_parts(&mut parts, &())
32 .await
33 .map_err(|_| Error::new(400, "Open the screen from the VM page."))?
34 .max_message_size(1024 * 1024)
35 .max_frame_size(1024 * 1024);
36 let name = name.to_owned();
37 Ok(upgrade
38 .protocols(["binary"])
39 .on_upgrade(move |mut socket| async move {
40 let stream = async {
41 if serial {
42 return host::open(json!({"operation":"vm.serial","payload":{"name":name}}))
43 .await
44 .map(|(_, stream)| stream);
45 }
46 let mut stream = tokio::net::UnixStream::connect(env(
47 "SNOWGLOBE_VM_SCREEN_SOCKET",
48 "/run/snowglobe-vm-screen/screen.sock",
49 ))
50 .await?;
51 stream
52 .write_all(format!("{}\n", json!({"name":name})).as_bytes())
53 .await?;
54 Ok(stream)
55 }
56 .await;
57 match stream {
58 Ok(stream) => bridge(socket, stream).await,
59 Err(error) => {
60 let reason = if error.message.len() <= 120 {
61 error.message
62 } else {
63 "The host operation couldn't finish. Check its logs, then retry.".into()
64 };
65 let _ = socket
66 .send(Message::Close(Some(CloseFrame {
67 code: 1011,
68 reason: reason.into(),
69 })))
70 .await;
71 }
72 }
73 })
74 .into_response())
75}
76
77pub(crate) fn same_origin(request: &Request) -> Result<()> {
78 let supplied = request
79 .headers()
80 .get("origin")
81 .and_then(|v| v.to_str().ok())
82 .and_then(|v| url::Url::parse(v).ok());
83 // The ingress strips forwarded headers and supplies the original Host.
84 let host = request
85 .headers()
86 .get("host")
87 .and_then(|v| v.to_str().ok())
88 .unwrap_or("");
89 if supplied.as_ref().is_none_or(|origin| {
90 let authority = match origin.port() {
91 Some(port) => format!("{}:{port}", origin.host_str().unwrap_or("")),
92 None => origin.host_str().unwrap_or("").to_owned(),
93 };
94 authority != host || !matches!(origin.scheme(), "http" | "https")
95 }) {
96 return Err(Error::new(403, "Open this page on the same site to connect."));
97 }
98 Ok(())
99}
100
101async fn bridge(socket: WebSocket, stream: tokio::net::UnixStream) {
102 let (mut send, mut receive) = socket.split();
103 let (mut read, mut write) = stream.into_split();
104 let upstream = async {
105 while let Some(Ok(message)) = receive.next().await {
106 match message {
107 Message::Binary(data) => write.write_all(&data).await?,
108 Message::Text(data) => write.write_all(data.as_bytes()).await?,
109 Message::Close(_) => break,
110 Message::Ping(_) | Message::Pong(_) => {}
111 }
112 }
113 Ok::<_, std::io::Error>(())
114 };
115 let downstream = async {
116 let mut buffer = vec![0; 65536];
117 loop {
118 let count = read.read(&mut buffer).await?;
119 if count == 0 {
120 break;
121 }
122 send.send(Message::Binary(Bytes::copy_from_slice(&buffer[..count])))
123 .await
124 .map_err(std::io::Error::other)?;
125 }
126 Ok::<_, std::io::Error>(())
127 };
128 tokio::select! { _ = upstream => {}, _ = downstream => {} }
129 // Dropping either half disconnects the host tunnel and releases its slot.
130}
131
132pub async fn upload(
133 app: Arc<App>,
134 request: Request,
135 query: &HashMap<String, String>,
136) -> Result<Response> {
137 same_origin(&request)?;
138 let volume = query
139 .get("name")
140 .ok_or_else(|| Error::new(400, "Choose an ISO file to upload."))?;
141 let size = request
142 .headers()
143 .get("content-length")
144 .and_then(|v| v.to_str().ok())
145 .and_then(|v| v.parse::<u64>().ok())
146 .filter(|v| (32768..=32 * 2u64.pow(30)).contains(v))
147 .ok_or_else(|| Error::new(400, "Choose an ISO between 32 KiB and 32 GiB."))?;
148 let (_, mut stream) =
149 host::open(json!({"operation":"vm.upload","payload":{"volume":volume,"size":size}}))
150 .await?;
151 let mut incoming = request.into_body().into_data_stream();
152 let mut remaining = size;
153 while let Some(data) = tokio::time::timeout(Duration::from_secs(120), incoming.next())
154 .await
155 .map_err(|_| Error::new(408, "The upload paused too long. Upload the ISO again."))?
156 {
157 let data = data?;
158 if data.len() as u64 > remaining {
159 return Err(Error::new(
160 400,
161 "The ISO size changed. Upload the file again.",
162 ));
163 }
164 tokio::time::timeout(Duration::from_secs(120), stream.write_all(&data))
165 .await
166 .map_err(|_| {
167 Error::new(
168 504,
169 "The host stopped receiving the ISO. Try uploading again.",
170 )
171 })??;
172 remaining -= data.len() as u64;
173 }
174 if remaining != 0 {
175 return Err(Error::new(
176 400,
177 "The upload was interrupted. Upload the ISO again.",
178 ));
179 }
180 let value = tokio::time::timeout(Duration::from_secs(120), host::response(&mut stream))
181 .await
182 .map_err(|_| {
183 Error::new(
184 504,
185 "The host is still saving the ISO. Refresh the library before retrying.",
186 )
187 })??;
188 app.cache.invalidate("vms:library");
189 Ok(Document::new(value).response())
190}
191
192#[cfg(test)]
193mod tests {
194 use super::*;
195 use axum::body::Body;
196
197 #[test]
198 fn ownership_follows_account_id_and_effective_admin_role() {
199 let user = json!({"id":"account-1","name":"renamed","groups":["vm"]});
200 assert!(visible(&user, &json!({"owner":"account-1"})));
201 assert!(!visible(&user, &json!({"owner":"account-2"})));
202 assert!(!visible(&user, &Value::Null));
203 assert!(!visible(
204 &json!({"id":"snow","groups":["vm"]}),
205 &json!({"owner":"other"})
206 ));
207 assert!(visible(
208 &json!({"id":"snow","groups":["infra-admin"]}),
209 &Value::Null
210 ));
211 let private = json!({"owner":"account-1","ownerOnly":true});
212 assert!(visible(&user, &private));
213 assert!(!visible(&json!({"id":"other","groups":["vm"]}), &private));
214 assert!(visible(&json!({"id":"admin","groups":["infra-admin"]}), &private));
215 assert!(visible(&json!({"id":"admin","groups":["infra-admin"]}), &json!({"ownerOnly":true})));
216 }
217
218 #[test]
219 fn screen_rejects_missing_and_cross_site_origins() {
220 for (origin, allowed) in [
221 (None, false),
222 (Some("https://other.test"), false),
223 (Some("null"), false),
224 (Some("https://vm.test"), true),
225 (Some("http://vm.test:5178"), false),
226 ] {
227 let mut request = Request::builder().header("host", "vm.test");
228 if let Some(origin) = origin {
229 request = request.header("origin", origin);
230 }
231 assert_eq!(
232 same_origin(&request.body(Body::empty()).unwrap()).is_ok(),
233 allowed
234 );
235 }
236 let request = Request::builder()
237 .header("host", "127.0.0.1:5178")
238 .header("origin", "http://127.0.0.1:5178")
239 .body(Body::empty())
240 .unwrap();
241 assert!(same_origin(&request).is_ok());
242 }
243}