Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 8c3b143e authored by Prabir Pradhan's avatar Prabir Pradhan
Browse files

InputTracer: Introduce TracedEventArgs to track secure events 

Introduce TracedEventArgs to give the tracing backend additional
information about the traced event.

We start by tracking whether an event is secure. An event is marked as
secure if it is targeting at least one secure window.

For now, do not trace secure events in the perfetto backend.

Bug: 210460522
Test: manual with perfetto
Change-Id: I41648d769319e47486556d0a2d6b8f02142048d2
parent b95d4aa4

services/inputflinger/dispatcher/trace/InputTracer.cpp

+17 −8
Original line number Diff line number Diff line
@@ -59,9 +59,10 @@ TracedEvent createTracedEvent(const KeyEntry& e) { 
                          e.downTime,  e.flags,     e.repeatCount};

}



void writeEventToBackend(const TracedEvent& event, InputTracingBackendInterface& backend) {

    std::visit(Visitor{[&](const TracedMotionEvent& e) { backend.traceMotionEvent(e); },

                       [&](const TracedKeyEvent& e) { backend.traceKeyEvent(e); }},

void writeEventToBackend(const TracedEvent& event, const TracedEventArgs args,

                         InputTracingBackendInterface& backend) {

    std::visit(Visitor{[&](const TracedMotionEvent& e) { backend.traceMotionEvent(e, args); },

                       [&](const TracedKeyEvent& e) { backend.traceKeyEvent(e, args); }},

               event);

}
@@ -110,7 +111,11 @@ void InputTracer::dispatchToTargetHint(const EventTrackerInterface& cookie, 
        // TODO(b/210460522): Disallow adding new targets from a derived cookie.

        return;

    }

    // TODO(b/210460522): Determine if the event is sensitive based on the target.

    if (target.windowHandle != nullptr) {

        eventState->isSecure |= target.windowHandle->getInfo()->layoutParamsFlags.test(

                gui::WindowInfo::Flag::SECURE);

        // TODO(b/210460522): Set events as sensitive when the IME connection is active.

    }

}



void InputTracer::eventProcessingComplete(const EventTrackerInterface& cookie) {
@@ -145,7 +150,8 @@ std::unique_ptr<EventTrackerInterface> InputTracer::traceDerivedEvent( 
        // It is possible for a derived event to be dispatched some time after the original event

        // is dispatched, such as in the case of key fallback events. To account for these cases,

        // derived events can be traced after the processing is complete for the original event.

        writeEventToBackend(eventState->events.back(), *mBackend);

        const TracedEventArgs traceArgs{.isSecure = eventState->isSecure};

        writeEventToBackend(eventState->events.back(), traceArgs, *mBackend);

    }

    return std::make_unique<EventTrackerImpl>(std::move(eventState), /*isDerived=*/true);

}
@@ -184,6 +190,7 @@ void InputTracer::traceEventDispatch(const DispatchEntry& dispatchEntry, 
    const int32_t windowId = dispatchEntry.windowId.value_or(0);

    const int32_t vsyncId = dispatchEntry.windowId.has_value() ? dispatchEntry.vsyncId : 0;



    // TODO(b/210460522): Pass HMAC into traceEventDispatch.

    const WindowDispatchArgs windowDispatchArgs{std::move(traced),

                                                dispatchEntry.deliveryTime,

                                                dispatchEntry.resolvedFlags,
@@ -195,7 +202,8 @@ void InputTracer::traceEventDispatch(const DispatchEntry& dispatchEntry, 
                                                /*hmac=*/{},

                                                resolvedKeyRepeatCount};

    if (eventState->isEventProcessingComplete) {

        mBackend->traceWindowDispatch(std::move(windowDispatchArgs));

        mBackend->traceWindowDispatch(std::move(windowDispatchArgs),

                                      TracedEventArgs{.isSecure = eventState->isSecure});

    } else {

        eventState->pendingDispatchArgs.emplace_back(std::move(windowDispatchArgs));

    }
@@ -214,12 +222,13 @@ bool InputTracer::isDerivedCookie(const EventTrackerInterface& cookie) { 


void InputTracer::EventState::onEventProcessingComplete() {

    // Write all of the events known so far to the trace.

    const TracedEventArgs traceArgs{.isSecure = isSecure};

    for (const auto& event : events) {

        writeEventToBackend(event, *tracer.mBackend);

        writeEventToBackend(event, traceArgs, *tracer.mBackend);

    }

    // Write all pending dispatch args to the trace.

    for (const auto& windowDispatchArgs : pendingDispatchArgs) {

        tracer.mBackend->traceWindowDispatch(windowDispatchArgs);

        tracer.mBackend->traceWindowDispatch(windowDispatchArgs, traceArgs);

    }

    pendingDispatchArgs.clear();

services/inputflinger/dispatcher/trace/InputTracer.h

+2 −2
Original line number Diff line number Diff line
@@ -66,8 +66,8 @@ private: 
        bool isEventProcessingComplete{false};

        // A queue to hold dispatch args from being traced until event processing is complete.

        std::vector<const WindowDispatchArgs> pendingDispatchArgs;

        // TODO(b/210460522): Add additional args for tracking event sensitivity and

        //  dispatch target UIDs.

        // True if the event is targeting at least one secure window;

        bool isSecure{false};

    };



    // Get the event state associated with a tracking cookie.

services/inputflinger/dispatcher/trace/InputTracingBackendInterface.h

+9 −3
Original line number Diff line number Diff line
@@ -74,6 +74,12 @@ struct TracedMotionEvent { 
/** A representation of a traced input event. */

using TracedEvent = std::variant<TracedKeyEvent, TracedMotionEvent>;



/** Additional information about an input event being traced. */

struct TracedEventArgs {

    // True if the event is targeting at least one secure window.

    bool isSecure;

};



/**

 * An interface for the tracing backend, used for setting a custom backend for testing.

 */
@@ -82,10 +88,10 @@ public: 
    virtual ~InputTracingBackendInterface() = default;



    /** Trace a KeyEvent. */

    virtual void traceKeyEvent(const TracedKeyEvent&) = 0;

    virtual void traceKeyEvent(const TracedKeyEvent&, const TracedEventArgs&) = 0;



    /** Trace a MotionEvent. */

    virtual void traceMotionEvent(const TracedMotionEvent&) = 0;

    virtual void traceMotionEvent(const TracedMotionEvent&, const TracedEventArgs&) = 0;



    /** Trace an event being sent to a window. */

    struct WindowDispatchArgs {
@@ -100,7 +106,7 @@ public: 
        std::array<uint8_t, 32> hmac;

        int32_t resolvedKeyRepeatCount;

    };

    virtual void traceWindowDispatch(const WindowDispatchArgs&) = 0;

    virtual void traceWindowDispatch(const WindowDispatchArgs&, const TracedEventArgs&) = 0;

};



} // namespace android::inputdispatcher::trace

services/inputflinger/dispatcher/trace/InputTracingPerfettoBackend.cpp

+20 −7
Original line number Diff line number Diff line
@@ -63,7 +63,12 @@ PerfettoBackend::PerfettoBackend() { 
    });

}



void PerfettoBackend::traceMotionEvent(const TracedMotionEvent& event) {

void PerfettoBackend::traceMotionEvent(const TracedMotionEvent& event,

                                       const TracedEventArgs& args) {

    if (args.isSecure) {

        // For now, avoid tracing secure event entirely.

        return;

    }

    InputEventDataSource::Trace([&](InputEventDataSource::TraceContext ctx) {

        auto tracePacket = ctx.NewTracePacket();

        auto* inputEvent = tracePacket->set_android_input_event();
@@ -72,7 +77,11 @@ void PerfettoBackend::traceMotionEvent(const TracedMotionEvent& event) { 
    });

}



void PerfettoBackend::traceKeyEvent(const TracedKeyEvent& event) {

void PerfettoBackend::traceKeyEvent(const TracedKeyEvent& event, const TracedEventArgs& args) {

    if (args.isSecure) {

        // For now, avoid tracing secure event entirely.

        return;

    }

    InputEventDataSource::Trace([&](InputEventDataSource::TraceContext ctx) {

        auto tracePacket = ctx.NewTracePacket();

        auto* inputEvent = tracePacket->set_android_input_event();
@@ -81,13 +90,17 @@ void PerfettoBackend::traceKeyEvent(const TracedKeyEvent& event) { 
    });

}



void PerfettoBackend::traceWindowDispatch(const WindowDispatchArgs& dispatchArgs) {

void PerfettoBackend::traceWindowDispatch(const WindowDispatchArgs& dispatchArgs,

                                          const TracedEventArgs& args) {

    if (args.isSecure) {

        // For now, avoid tracing secure event entirely.

        return;

    }

    InputEventDataSource::Trace([&](InputEventDataSource::TraceContext ctx) {

        auto tracePacket = ctx.NewTracePacket();

        auto* inputEventProto = tracePacket->set_android_input_event();

        auto* dispatchEventProto = inputEventProto->set_dispatcher_window_dispatch_event();

        AndroidInputEventProtoConverter::toProtoWindowDispatchEvent(dispatchArgs,

                                                                    *dispatchEventProto);

        auto* inputEvent = tracePacket->set_android_input_event();

        auto* dispatchEvent = inputEvent->set_dispatcher_window_dispatch_event();

        AndroidInputEventProtoConverter::toProtoWindowDispatchEvent(dispatchArgs, *dispatchEvent);

    });

}

services/inputflinger/dispatcher/trace/InputTracingPerfettoBackend.h

+3 −3
Original line number Diff line number Diff line
@@ -48,9 +48,9 @@ public: 
    PerfettoBackend();

    ~PerfettoBackend() override = default;



    void traceKeyEvent(const TracedKeyEvent&) override;

    void traceMotionEvent(const TracedMotionEvent&) override;

    void traceWindowDispatch(const WindowDispatchArgs&) override;

    void traceKeyEvent(const TracedKeyEvent&, const TracedEventArgs&) override;

    void traceMotionEvent(const TracedMotionEvent&, const TracedEventArgs&) override;

    void traceWindowDispatch(const WindowDispatchArgs&, const TracedEventArgs&) override;



    class InputEventDataSource : public perfetto::DataSource<InputEventDataSource> {

    public: