Skip to main content

xrack_layout/
password.rs

1use crate::TextEdit;
2use std::{
3    fmt,
4    ops::Range,
5    time::{Duration, Instant},
6};
7use unicode_segmentation::UnicodeSegmentation;
8use xrack_runtime::Node;
9
10const BULLET: &str = "•";
11
12#[derive(Clone)]
13pub(crate) struct PasswordEcho {
14    pub(crate) deadline: Instant,
15    text: Box<str>,
16    range: Range<usize>,
17}
18
19impl fmt::Debug for PasswordEcho {
20    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
21        f.debug_struct("PasswordEcho")
22            .field("deadline", &self.deadline)
23            .finish_non_exhaustive()
24    }
25}
26
27impl PasswordEcho {
28    pub(crate) fn new(
29        node: &Node,
30        text: &str,
31        typed: &str,
32        caret: usize,
33        now: Instant,
34    ) -> Option<Self> {
35        if !node.password_masked() || node.text_read_only() || typed.is_empty() {
36            return None;
37        }
38        let milliseconds = u64::try_from(node.int("password-mask-delay")?).ok()?;
39        if milliseconds == 0 {
40            return None;
41        }
42        let start = caret.checked_sub(typed.len())?;
43        // A combining key can modify the previous grapheme. Only reveal a whole
44        // grapheme whose bytes all came from this event.
45        if !text
46            .grapheme_indices(true)
47            .any(|(offset, grapheme)| offset == start && grapheme == typed)
48        {
49            return None;
50        }
51        Some(Self {
52            deadline: now.checked_add(Duration::from_millis(milliseconds))?,
53            text: text.into(),
54            range: start..caret,
55        })
56    }
57
58    pub(crate) fn matches(&self, node: &Node, text: &str) -> bool {
59        node.password_masked()
60            && !node.text_read_only()
61            && node
62                .int("password-mask-delay")
63                .is_some_and(|delay| delay > 0)
64            && self.text.as_ref() == text
65    }
66
67    fn visible_range(&self, node: &Node, text: &str) -> Option<Range<usize>> {
68        (Instant::now() < self.deadline && self.matches(node, text)).then(|| self.range.clone())
69    }
70}
71
72/// Display coordinates and committed UTF-8 offsets for one marker per grapheme.
73pub struct PasswordMask {
74    source_offsets: Vec<usize>,
75    display: String,
76    marker_len: usize,
77    revealed: Option<(usize, usize)>,
78}
79
80impl PasswordMask {
81    pub fn new(text: &str) -> Self {
82        Self::with_marker(text, BULLET)
83    }
84
85    pub fn for_node(node: &Node, text: &str) -> Self {
86        let Some(marker) = node.text("password-character").and_then(password_marker) else {
87            return Self::new(text);
88        };
89        Self::with_marker(text, marker)
90    }
91
92    #[doc(hidden)]
93    pub fn for_editor(node: &Node, text: &str, editor: Option<&TextEdit>) -> Self {
94        let mut mask = Self::for_node(node, text);
95        if let Some(range) = editor
96            .and_then(|editor| editor.password_echo.as_ref())
97            .and_then(|echo| echo.visible_range(node, text))
98        {
99            mask.reveal(text, range);
100        }
101        mask
102    }
103
104    fn reveal(&mut self, text: &str, range: Range<usize>) {
105        let index = self
106            .source_offsets
107            .partition_point(|&offset| offset < range.start);
108        let display_start = index * self.marker_len;
109        let mut display = self.display.clone();
110        display.replace_range(
111            display_start..display_start + self.marker_len,
112            &text[range.clone()],
113        );
114        self.revealed = Some((index, range.len()));
115        // For example, a revealed regional indicator can join a neighboring
116        // flag. Keep the redacted display if any shaping boundary would move.
117        if !display
118            .grapheme_indices(true)
119            .map(|(offset, _)| offset)
120            .chain(std::iter::once(display.len()))
121            .eq((0..self.source_offsets.len()).map(|index| self.display_boundary(index)))
122        {
123            self.revealed = None;
124            return;
125        }
126        self.display = display;
127    }
128
129    fn with_marker(text: &str, marker: &str) -> Self {
130        let source_offsets: Vec<_> = text
131            .grapheme_indices(true)
132            .map(|(offset, _)| offset)
133            .chain(std::iter::once(text.len()))
134            .collect();
135        let display = marker.repeat(source_offsets.len() - 1);
136        Self {
137            source_offsets,
138            display,
139            marker_len: marker.len(),
140            revealed: None,
141        }
142    }
143
144    pub fn display(&self) -> &str {
145        &self.display
146    }
147
148    pub fn into_display(self) -> String {
149        self.display
150    }
151
152    pub fn display_offset(&self, source: usize) -> usize {
153        let index = self
154            .source_offsets
155            .partition_point(|&offset| offset <= source);
156        self.display_boundary(index.saturating_sub(1))
157    }
158
159    fn display_boundary(&self, index: usize) -> usize {
160        if let Some((slot, len)) = self.revealed
161            && index > slot
162        {
163            (index - 1) * self.marker_len + len
164        } else {
165            index * self.marker_len
166        }
167    }
168
169    pub fn source_offset(&self, display: usize) -> usize {
170        let index = if let Some((slot, len)) = self.revealed {
171            let start = slot * self.marker_len;
172            let end = start + len;
173            if display >= end {
174                slot + 1 + (display - end) / self.marker_len
175            } else {
176                (display / self.marker_len).min(slot)
177            }
178        } else {
179            display / self.marker_len
180        };
181        self.source_offsets[index.min(self.source_offsets.len() - 1)]
182    }
183}
184
185fn password_marker(value: &str) -> Option<&str> {
186    let marker = value.graphemes(true).next()?;
187    // Bound the size of a marker repeated for every grapheme of the password.
188    if marker.len() > 64 || marker.chars().any(|c| c.is_control() || c.is_whitespace()) {
189        return None;
190    }
191    // Two adjacent markers must keep a caret stop between them, even for emoji.
192    let pair = marker.repeat(2);
193    (pair.graphemes(true).next() == Some(marker)).then_some(marker)
194}
195
196#[cfg(test)]
197mod tests {
198    use super::*;
199
200    #[test]
201    fn echo_uses_only_new_graphemes_and_remaps_all_offsets() {
202        let mut node = Node::new("LineEdit", None);
203        node.properties
204            .insert("input-type", xrack_runtime::InputType::Password.into());
205        node.properties
206            .insert("password-character", "*".to_owned().into());
207        node.properties
208            .insert("password-mask-delay", 1000_i64.into());
209        let text = "a👩‍💻b";
210        let end = text.len() - 1;
211        let now = Instant::now();
212        let mut editor = TextEdit::at_end(text);
213        editor.password_echo = PasswordEcho::new(&node, text, "👩‍💻", end, now);
214        assert_eq!(
215            editor.password_echo.as_ref().unwrap().deadline,
216            now + Duration::from_secs(1)
217        );
218        let mask = PasswordMask::for_editor(&node, text, Some(&editor));
219        assert_eq!(mask.display(), "*👩‍💻*");
220        assert_eq!(mask.source_offset(2), 1);
221        assert_eq!(mask.source_offset(end), end);
222        assert_eq!(mask.display_offset(end), end);
223        assert_eq!(mask.source_offset(mask.display().len()), text.len());
224        assert_eq!(PasswordMask::for_node(&node, text).display(), "***");
225        assert_eq!(
226            PasswordMask::for_editor(&node, "x👩‍💻b", Some(&editor)).display(),
227            "***"
228        );
229        assert!(PasswordEcho::new(&node, "e\u{301}", "\u{301}", 3, now).is_none());
230        assert!(PasswordEcho::new(&node, "ab", "ab", 2, now).is_none());
231        node.properties.insert("password-mask-delay", 0_i64.into());
232        assert_eq!(
233            PasswordMask::for_editor(&node, text, Some(&editor)).display(),
234            "***"
235        );
236    }
237
238    #[test]
239    fn marker_preserves_utf8_grapheme_boundaries_and_has_a_safe_fallback() {
240        let mut node = Node::new("LineEdit", None);
241        let source = "e\u{301}👩‍💻";
242        for (configured, marker) in [
243            ("*unused", "*"),
244            ("🔒", "🔒"),
245            ("🇨🇳", "🇨🇳"),
246            ("", "•"),
247            ("\n", "•"),
248            ("🇨", "•"),
249            ("\u{301}", "•"),
250        ] {
251            node.properties
252                .insert("password-character", configured.to_owned().into());
253            let mask = PasswordMask::for_node(&node, source);
254            assert_eq!(mask.display(), marker.repeat(2));
255            assert_eq!(mask.display_offset(1), 0);
256            assert_eq!(mask.display_offset(3), marker.len());
257            assert_eq!(mask.source_offset(marker.len()), 3);
258            assert_eq!(mask.source_offset(mask.display().len()), source.len());
259        }
260    }
261}