microsoft-webui-desktop 3.0.1

Configurable native desktop SDK for WebUI applications
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT license.

use super::*;
use crate::ipc::{IpcHost, IpcOptions, IpcRegistry, IpcWindowOwner};
use std::sync::Arc;

fn owner() -> IpcWindowOwner {
    IpcWindowOwner::new(
        Arc::new(IpcRegistry::default()),
        IpcOptions::default(),
        IpcHost::Source {
            origin: "webui://app".into(),
        },
    )
    .unwrap()
}

fn input(bridge: &IpcBridge) -> OwnedIpcHttpRequest {
    OwnedIpcHttpRequest {
        navigation: 1,
        method: DesktopHttpMethod::Post,
        path: "/_webui/ipc".into(),
        token: "a".repeat(32),
        body: Vec::new(),
        input_permit: bridge.reserve_input(0).unwrap(),
    }
}

#[test]
fn asynchronous_stream_bounds_actual_bytes_and_rejects_header_lies() {
    let owner = owner();
    let bridge = owner.bridge();
    let context = glib::MainContext::new();
    context
        .with_thread_default(|| {
            for declared in [None, Some(3), Some(2), Some(4)] {
                let stream: gio::InputStream =
                    gio::MemoryInputStream::from_bytes(&glib::Bytes::from_static(&[1, 2, 3]))
                        .upcast();
                let result = context.block_on(read_body(
                    &bridge,
                    input(&bridge),
                    Some(stream),
                    ReadLimits {
                        maximum: 1024,
                        control: 512,
                        declared,
                    },
                ));
                if declared.is_none() || declared == Some(3) {
                    assert_eq!(result.unwrap().body, [1, 2, 3]);
                } else {
                    assert_eq!(result.err().unwrap().code, IpcErrorCode::InvalidFrame);
                }
            }
            let stream: gio::InputStream =
                gio::MemoryInputStream::from_bytes(&glib::Bytes::from_static(&[1, 2, 3])).upcast();
            assert_eq!(
                context
                    .block_on(read_body(
                        &bridge,
                        input(&bridge),
                        Some(stream),
                        ReadLimits {
                            maximum: 2,
                            control: 2,
                            declared: None
                        }
                    ))
                    .err()
                    .unwrap()
                    .code,
                IpcErrorCode::PayloadTooLarge
            );
        })
        .unwrap();
}

#[test]
fn native_headers_are_bounded_before_copy_and_sdk_assets_bypass_ipc() {
    let headers = webkit6::soup::MessageHeaders::new(webkit6::soup::MessageHeadersType::Request);
    headers.append("X-Test", &"a".repeat(33));
    assert_eq!(
        header(&headers, c"X-Test", 32).unwrap_err().code,
        IpcErrorCode::PayloadTooLarge
    );
    assert_eq!(header(&headers, c"Missing", 32).unwrap(), None);
    assert!(!is_ipc_path("/_webui/ipc/runtime.js"));
    assert!(!is_ipc_path("/_webui/ipc/bootstrap.js"));
    assert!(is_ipc_path("/_webui/ipc/outbound"));
}

#[test]
fn tiny_gio_control_read_succeeds_while_payload_bytes_are_saturated() {
    let owner = owner();
    let bridge = owner.bridge();
    let held: Vec<_> = (0..8)
        .map(|_| bridge.reserve_input(1_048_576).unwrap())
        .collect();
    let context = glib::MainContext::new();
    context
        .with_thread_default(|| {
            for declared in [None, Some(24)] {
                let stream: gio::InputStream =
                    gio::MemoryInputStream::from_bytes(&glib::Bytes::from_static(&[0; 24]))
                        .upcast();
                let read = context
                    .block_on(read_body(
                        &bridge,
                        input(&bridge),
                        Some(stream),
                        ReadLimits {
                            maximum: 1_048_576,
                            control: 2176,
                            declared,
                        },
                    ))
                    .unwrap();
                assert_eq!(read.body, [0; 24]);
            }
        })
        .unwrap();
    drop(held);
}