jail.nix/tests/spec/DBusCombinatorsSpec.hs
Alex David 3610987241 Allow multiple calls to dbus combinator
Before this change, additional calls to the dbus combinator would add
multiple `xdg-dbus-proxy` instances, but only the latest call would be
forwarded into the jail.

With this change, all permissions are saved in state, then, in a
deferred `add-runtime` we add a single `xdg-dbus-proxy` exposing the
union of all previous dbus calls.

This should allow writing combinators that expose dbus permissions like
notifications, or reading light/dark mode changes which can be composed
just like the other non-dbus combinators.
2025-09-28 15:44:36 -07:00

283 lines
11 KiB
Haskell

module DBusCombinatorsSpec (spec) where
import Control.Concurrent (modifyMVar_, newMVar, readMVar)
import Control.Exception (bracket)
import DBus qualified
import DBus.Client qualified as DBus
import System.Random
import Test.Hspec
import TestPrelude
spec :: Spec
spec = inTestM $ do
let mockMethod =
MockDBusMethod
{ objPath = "/foo/bar/baz",
ifaceName = "foo.bar.Iface",
methodName = "Demo"
}
describe "unsafe-dbus" $ do
it "gives unfiltered access to DBus method calls" $ do
(sendDBusOutput, methodCalls) <- withDBusClient $ \mockBusName client -> do
withMockDBusMethodHandler client mockMethod "some return value" $ do
runNixDrv
[i|
jail "send-dbus" (#{callDBusMethodNixDrv mockBusName mockMethod "some arg"}) (c: [
c.unsafe-dbus
])
|]
liftIO $ do
sendDBusOutput `shouldBe` " some return value"
methodCalls `shouldBe` ["some arg"]
it "gives unfiltered access to DBus signals" $ do
(_, signals) <- withDBusClient $ \mockBusName client -> do
withMockDBusSignalHandler client mockMethod $ do
runNixDrv
[i|
jail "send-dbus" (#{sendDBusSignalNixDrv mockBusName mockMethod "some message"}) (c: [
c.unsafe-dbus
])
|]
liftIO $ signals `shouldBe` ["some message"]
describe "dbus" $ do
describe "sending signals from within the jail" $ do
it "filters all signals if there are no rules" $ do
(_, signals) <- withDBusClient $ \mockBusName client -> do
withMockDBusSignalHandler client mockMethod $ do
runNixDrv
[i|
jail "send-dbus" (#{sendDBusSignalNixDrv mockBusName mockMethod "some arg"}) (c: [
(c.dbus {})
])
|]
liftIO $ signals `shouldBe` []
describe "calling methods from within the jail" $ do
it "allows method calls that match the call filter rules" $ do
(sendDBusOutput, methodCalls) <- withDBusClient $ \mockBusName client -> do
withMockDBusMethodHandler client mockMethod "some return value" $ do
runNixDrv
[i|
jail "send-dbus" (#{callDBusMethodNixDrv mockBusName mockMethod "some arg"}) (c: [
(c.dbus {
call = [ #{toNixString $ toProxyRule mockBusName mockMethod} ];
})
])
|]
liftIO $ do
sendDBusOutput `shouldBe` " some return value"
methodCalls `shouldBe` ["some arg"]
it "allows method calls if the receiving bus has `own` privileges" $ do
(sendDBusOutput, methodCalls) <- withDBusClient $ \mockBusName client -> do
withMockDBusMethodHandler client mockMethod "some return value" $ do
runNixDrv
[i|
jail "send-dbus" (#{callDBusMethodNixDrv mockBusName mockMethod "some arg"}) (c: [
(c.dbus {
own = [ #{toNixString $ DBus.formatBusName mockBusName} ];
})
])
|]
liftIO $ do
sendDBusOutput `shouldBe` " some return value"
methodCalls `shouldBe` ["some arg"]
it "allows method calls if the receiving bus has `talk` privileges" $ do
(sendDBusOutput, methodCalls) <- withDBusClient $ \mockBusName client -> do
withMockDBusMethodHandler client mockMethod "some return value" $ do
runNixDrv
[i|
jail "send-dbus" (#{callDBusMethodNixDrv mockBusName mockMethod "some arg"}) (c: [
(c.dbus {
talk = [ #{toNixString $ DBus.formatBusName mockBusName} ];
})
])
|]
liftIO $ do
sendDBusOutput `shouldBe` " some return value"
methodCalls `shouldBe` ["some arg"]
it "filters method calls if the receiving bus only has `see` privileges" $ do
(sendDBusOutput, methodCalls) <- withDBusClient $ \mockBusName client -> do
withMockDBusMethodHandler client mockMethod "some return value" $ do
runNixDrv
[i|
jail "send-dbus" (#{callDBusMethodNixDrv mockBusName mockMethod "some arg"}) (c: [
(c.dbus {
see = [ #{toNixString $ DBus.formatBusName mockBusName} ];
})
])
|]
liftIO $ do
sendDBusOutput `shouldBe` "Failed to call dbus method\n"
methodCalls `shouldBe` []
it "filters all method calls if there are no rules" $ do
(sendDBusOutput, methodCalls) <- withDBusClient $ \mockBusName client -> do
withMockDBusMethodHandler client mockMethod "some return value" $ do
runNixDrv
[i|
jail "send-dbus" (#{callDBusMethodNixDrv mockBusName mockMethod "some arg"}) (c: [
(c.dbus { })
])
|]
liftIO $ do
sendDBusOutput `shouldBe` "Failed to call dbus method\n"
methodCalls `shouldBe` []
it "filters method calls if the rules do not match" $ do
(sendDBusOutput, methodCalls) <- withDBusClient $ \mockBusName client -> do
withMockDBusMethodHandler client mockMethod "some return value" $ do
let otherMockMethod = mockMethod {objPath = "/some/unrelated/object/path"}
runNixDrv
[i|
jail "send-dbus" (#{callDBusMethodNixDrv mockBusName mockMethod "some arg"}) (c: [
(c.dbus {
call = [ #{toNixString $ toProxyRule mockBusName otherMockMethod} ];
})
])
|]
liftIO $ do
sendDBusOutput `shouldBe` "Failed to call dbus method\n"
methodCalls `shouldBe` []
describe "multiple calls to the dbus combinator" $ do
it "exposes a union of all of the specified permissions" $ do
let mockMethod1 =
MockDBusMethod
{ objPath = "/foo/object1",
ifaceName = "foo.iface1.Iface",
methodName = "method1"
}
let mockMethod2 =
MockDBusMethod
{ objPath = "/foo/object2",
ifaceName = "foo.iface2.Iface",
methodName = "method2"
}
((sendDBusOutput, method2Calls), method1Calls) <- withDBusClient $ \mockBusName client -> do
withMockDBusMethodHandler client mockMethod1 "return value 1" $ do
withMockDBusMethodHandler client mockMethod2 "return value 2" $ do
runNixDrv
[i|
jail
"send-multiple"
(sh ''
${lib.getExe (#{callDBusMethodNixDrv mockBusName mockMethod1 "arg1"})}
${lib.getExe (#{callDBusMethodNixDrv mockBusName mockMethod2 "arg2"})}
'')
(c: [
(c.dbus { call = [ #{toNixString $ toProxyRule mockBusName mockMethod1} ]; })
(c.dbus { call = [ #{toNixString $ toProxyRule mockBusName mockMethod2} ]; })
])
|]
liftIO $ do
sendDBusOutput `shouldBe` " return value 1 return value 2"
method1Calls `shouldBe` ["arg1"]
method2Calls `shouldBe` ["arg2"]
-- * DBus test helpers
withDBusClient :: (DBus.BusName -> DBus.Client -> TestM a) -> TestM a
withDBusClient action = do
rand :: Int <- liftIO randomIO
mockBusName <- liftIO $ DBus.parseBusName $ "id.alexdav.jailnix.test" <> show rand
let setup = do
client <- liftIO DBus.connectSession
DBus.requestName client mockBusName [DBus.nameDoNotQueue] >>= \case
DBus.NamePrimaryOwner -> pure client
reply -> error $ "Got unexpected requestName reply: " <> show reply
lifted (bracket setup DBus.disconnect) $ action mockBusName
data MockDBusMethod = MockDBusMethod
{ objPath :: DBus.ObjectPath,
ifaceName :: DBus.InterfaceName,
methodName :: DBus.MemberName
}
-- | Returns a RULE that can be passed into `--call` or `--broadcast` that
-- matches the given MockDBusMethod. See XDG-DBUS-PROXY(1).
toProxyRule :: DBus.BusName -> MockDBusMethod -> String
toProxyRule busName mockMethod =
DBus.formatBusName busName
<> "="
<> DBus.formatInterfaceName (ifaceName mockMethod)
<> "."
<> DBus.formatMemberName (methodName mockMethod)
<> "@"
<> DBus.formatObjectPath (objPath mockMethod)
withMockDBusMethodHandler :: DBus.Client -> MockDBusMethod -> String -> TestM a -> TestM (a, [String])
withMockDBusMethodHandler client (MockDBusMethod {objPath, ifaceName, methodName}) returnValue action = do
recordedMethodCalls <- liftIO $ newMVar []
let mockMethod :: String -> IO String
mockMethod arg = do
modifyMVar_ recordedMethodCalls (pure . (<> [arg]))
pure returnValue
liftIO
$ DBus.export
client
objPath
$ DBus.defaultInterface
{ DBus.interfaceName = ifaceName,
DBus.interfaceMethods = [DBus.autoMethod methodName mockMethod]
}
(,) <$> action <*> liftIO (readMVar recordedMethodCalls)
withMockDBusSignalHandler :: DBus.Client -> MockDBusMethod -> TestM a -> TestM (a, [String])
withMockDBusSignalHandler client (MockDBusMethod {objPath}) action = do
recordedSignals <- liftIO $ newMVar []
let onSignal sig = do
let body = case DBus.fromVariant <$> DBus.signalBody sig of
[Just s] -> s
_ -> error $ "Expected string signal body, got: " <> show (DBus.signalBody sig)
modifyMVar_ recordedSignals (pure . (<> [body]))
let matchRule = DBus.matchAny {DBus.matchPath = Just objPath}
void $ liftIO $ DBus.addMatch client matchRule onSignal
(,) <$> action <*> liftIO (readMVar recordedSignals)
-- | Returns a nix expression that calls the specified (String -> String) DBus method
callDBusMethodNixDrv :: DBus.BusName -> MockDBusMethod -> String -> String
callDBusMethodNixDrv busName (MockDBusMethod {objPath, ifaceName, methodName}) arg =
[i|
sh ''
if ! \\
${pkgs.dbus}/bin/dbus-send \\
--type=method_call \\
--print-reply=literal \\
--dest=#{toNixShellArg $ DBus.formatBusName busName} \\
#{toNixShellArg $ DBus.formatObjectPath objPath} \\
#{toNixShellArg $ DBus.formatInterfaceName ifaceName}.#{toNixShellArg $ DBus.formatMemberName methodName} \\
string:#{toNixShellArg arg} \\
; then
echo "Failed to call dbus method"
fi
''
|]
where
toNixShellArg :: String -> String
toNixShellArg s = "${lib.escapeShellArg " <> toNixString s <> "}"
sendDBusSignalNixDrv :: DBus.BusName -> MockDBusMethod -> String -> String
sendDBusSignalNixDrv busName (MockDBusMethod {objPath, ifaceName}) msg = do
[i|
sh ''
if ! \\
${pkgs.dbus}/bin/dbus-send \\
--type=signal \\
--dest=#{toNixShellArg $ DBus.formatBusName busName} \\
#{toNixShellArg $ DBus.formatObjectPath objPath} \\
#{toNixShellArg $ DBus.formatInterfaceName ifaceName} \\
string:#{toNixShellArg msg} \\
; then
echo "Failed to call dbus method"
fi
''
|]
where
toNixShellArg :: String -> String
toNixShellArg s = "${lib.escapeShellArg " <> toNixString s <> "}"