diff --git a/CHANGELOG.md b/CHANGELOG.md index ad61a61..e1c56fd 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -29,6 +29,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 (`1:6.2.0-13.el9`), as on a dpkg host. Oracle's and Red Hat's fixes name it, and without it an epoch-1 fix read as newer than every installed build (NetOrk/netork#2394). +### Fixed +- `open_stream(privileged=True)` with a sudo password asks sudo first whether it wants it + (`sudo -n sh -c true`). A sudo that does not prompt (NOPASSWD, a cached timestamp) used to + get the password on stdin anyway, where it went to the command as the first bytes of the + stream: into the Podman API, over `sudo podman system dial-stdio` (NetOrk/netork#818). + Such a sudo now gets the command through `sudo -n`, and only one that asks gets the + password. + ### Added - `get_time_sync()` and `configure_time_sync()` through napalm-device-types' `PosixTimeSyncMixin` (4.35.0): the host's NTP servers in its client's order, its time zone, diff --git a/napalm_linux/linux.py b/napalm_linux/linux.py index ac67d3d..93ff14e 100644 --- a/napalm_linux/linux.py +++ b/napalm_linux/linux.py @@ -158,6 +158,11 @@ _PRIVILEGED_STDIN = ( "mktemp, cat) and have root install that file." ) +#: Whether sudo runs a command for the login user without a password now: in +#: the shape every privileged command takes (``sh -c``), so a sudoers rule that +#: covers one covers the other (``open_stream``). +_SUDO_ASKS_NOTHING = "sudo -n sh -c true" + #: First in every script ``_sudo`` runs: a sudo that does not prompt (NOPASSWD, #: a cached timestamp) leaves the password on stdin, and nothing may read it. _NO_STDIN = "exec ByteStream: """Start *command* on an exec channel and return a stream to it. - A privileged stream with a sudo password starts with that password, for - ``sudo -S``; a sudo that does not prompt leaves it for *command*. Write - nothing to such a stream that must not follow the password, as - ``_PRIVILEGED_STDIN`` says for ``run_command``. + A privileged stream with a sudo password asks sudo first whether it + wants the password (``sudo -n sh -c true``): a sudo that does not prompt + -- NOPASSWD, a cached timestamp -- would leave it on stdin, and the + stream's own data follows it there, the Podman API over ``sudo podman + system dial-stdio`` say (NetOrk/netork#818). Such a sudo gets the + command through ``sudo -n``; one that asks gets the password first, for + ``sudo -S``. """ line, prefix = self._privileged(command, privileged) + if prefix and self._sudo_asks_nothing(): + line, prefix = f"sudo -n sh -c {_shlex_quote(command)}", None return open_stream_on_transport(self._transport(), line, stdin_prefix=prefix) + def _sudo_asks_nothing(self) -> bool: + """Whether sudo runs a command for the login user without its password now.""" + probe = run_on_transport(self._transport(), _SUDO_ASKS_NOTHING, timeout=15) + return probe.exit_code == 0 + def reboot_host(self) -> None: """Restart the host (``HostRebootMixin``); returns once the restart is under way. diff --git a/tests/test_command_channel.py b/tests/test_command_channel.py index 4072792..ab60066 100644 --- a/tests/test_command_channel.py +++ b/tests/test_command_channel.py @@ -20,9 +20,10 @@ from napalm_linux import LinuxDriver class FakeChannel: - def __init__(self): + def __init__(self, exits): self.command = None self.sent = b"" + self._exits = exits def exec_command(self, command): self.command = command @@ -55,21 +56,28 @@ class FakeChannel: return True def recv_exit_status(self): - return 0 + return self._exits.get(self.command, 0) + + +#: The probe a privileged stream sends first, and how a sudo that asks for its +#: password answers it. +SUDO_PROBE = "sudo -n sh -c true" +ASKS = {SUDO_PROBE: 1} class FakeTransport: - def __init__(self): + def __init__(self, exits=None): self.channels = [] + self.exits = ASKS if exits is None else exits def open_session(self): - self.channels.append(FakeChannel()) + self.channels.append(FakeChannel(self.exits)) return self.channels[-1] -def _driver(*, root=False, sudo_password=None): +def _driver(*, root=False, sudo_password=None, exits=None): driver = LinuxDriver("h", "u", "p", optional_args={"sudo_password": sudo_password}) - transport = FakeTransport() + transport = FakeTransport(exits) driver._device = SimpleNamespace( remote_conn_pre=SimpleNamespace(get_transport=lambda: transport) ) @@ -166,6 +174,54 @@ def test_a_privileged_stream_gets_the_password_first(): assert channel.sent == b"pw\n" +class TestNoPasswordIntoAStream: + """A privileged stream carries data after the password: the Podman API over + ``sudo podman system dial-stdio`` (NetOrk/netork#818). A sudo that does not ask + -- NOPASSWD, a cached timestamp -- would hand the password to the command as + the first bytes of that data. So the stream asks sudo first, and sends the + password only to a sudo that wants it.""" + + def test_sudo_is_asked_first(self): + driver, transport = _driver(sudo_password="pw") + + driver.open_stream("podman system dial-stdio", privileged=True) + + assert transport.channels[0].command == SUDO_PROBE + assert transport.channels[0].sent == b"" + + def test_a_sudo_that_asks_nothing_gets_no_password(self): + driver, transport = _driver(sudo_password="pw", exits={}) + + driver.open_stream("podman system dial-stdio", privileged=True) + + channel = transport.channels[-1] + assert channel.command == "sudo -n sh -c 'podman system dial-stdio'" + assert channel.sent == b"" + + def test_without_a_password_there_is_nothing_to_ask(self): + driver, transport = _driver() + + driver.open_stream("podman system dial-stdio", privileged=True) + + assert [c.command for c in transport.channels] == [ + "sudo -n sh -c 'podman system dial-stdio'" + ] + + def test_a_root_login_asks_nothing_either(self): + driver, transport = _driver(root=True, sudo_password="pw") + + driver.open_stream("podman system dial-stdio", privileged=True) + + assert [c.command for c in transport.channels] == ["podman system dial-stdio"] + + def test_podman_is_reached_as_root(self): + driver, transport = _driver(root=True) + + driver.open_container_engine("podman").open_api() + + assert transport.channels[-1].command == "podman system dial-stdio" + + def test_the_container_engine_api_is_a_stream_over_dial_stdio(): driver, transport = _driver()