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

Commit 9c858ac6 authored by Siarhei Vishniakou's avatar Siarhei Vishniakou
Browse files

Add hmac to InputEvent and scale to MotionEvent 

We need to pass some additional data to the app to be able to construct
the MotionEvent.

For proper support of getRawX/getRawY, add the xScale and yScale to
MotionEvent.

For the verification of input events, add hmac to InputEvent.

Bug: 134977432
Bug: 140786233
Test: atest libinput_tests inputflinger_tests
Change-Id: Ia3400ebbd9698549aad4d97a3b789ab7e10f6b65
parent 4274794a

include/input/Input.h

+24 −16
Original line number Diff line number Diff line
@@ -31,6 +31,7 @@ 
#include <utils/RefBase.h>

#include <utils/Timers.h>

#include <utils/Vector.h>

#include <array>

#include <limits>

#include <queue>
@@ -258,6 +259,11 @@ const char* motionClassificationToString(MotionClassification classification); 
 */

constexpr float AMOTION_EVENT_INVALID_CURSOR_POSITION = std::numeric_limits<float>::quiet_NaN();



/**

 * Invalid value of HMAC - SHA256. Any events with this HMAC value will be marked as not verified.

 */

constexpr std::array<uint8_t, 32> INVALID_HMAC = {0};



/*

 * Pointer coordinate data.

 */
@@ -356,14 +362,17 @@ public: 


    inline void setDisplayId(int32_t displayId) { mDisplayId = displayId; }



    inline std::array<uint8_t, 32> getHmac() const { return mHmac; }



protected:

    void initialize(int32_t deviceId, int32_t source, int32_t displayId);

    void initialize(int32_t deviceId, int32_t source, int32_t displayId,

                    std::array<uint8_t, 32> hmac);

    void initialize(const InputEvent& from);



    int32_t mDeviceId;

    int32_t mSource;

    int32_t mDisplayId;

    std::array<uint8_t, 32> mHmac;

};



/*
@@ -396,17 +405,9 @@ public: 
    static const char* getLabel(int32_t keyCode);

    static int32_t getKeyCodeFromLabel(const char* label);



    void initialize(

            int32_t deviceId,

            int32_t source,

            int32_t displayId,

            int32_t action,

            int32_t flags,

            int32_t keyCode,

            int32_t scanCode,

            int32_t metaState,

            int32_t repeatCount,

            nsecs_t downTime,

    void initialize(int32_t deviceId, int32_t source, int32_t displayId,

                    std::array<uint8_t, 32> hmac, int32_t action, int32_t flags, int32_t keyCode,

                    int32_t scanCode, int32_t metaState, int32_t repeatCount, nsecs_t downTime,

                    nsecs_t eventTime);

    void initialize(const KeyEvent& from);
@@ -463,6 +464,10 @@ public: 


    inline void setActionButton(int32_t button) { mActionButton = button; }



    inline float getXScale() const { return mXScale; }



    inline float getYScale() const { return mYScale; }



    inline float getXOffset() const { return mXOffset; }



    inline float getYOffset() const { return mYOffset; }
@@ -624,9 +629,10 @@ public: 


    ssize_t findPointerIndex(int32_t pointerId) const;



    void initialize(int32_t deviceId, int32_t source, int32_t displayId, int32_t action,

                    int32_t actionButton, int32_t flags, int32_t edgeFlags, int32_t metaState,

                    int32_t buttonState, MotionClassification classification, float xOffset,

    void initialize(int32_t deviceId, int32_t source, int32_t displayId,

                    std::array<uint8_t, 32> hmac, int32_t action, int32_t actionButton,

                    int32_t flags, int32_t edgeFlags, int32_t metaState, int32_t buttonState,

                    MotionClassification classification, float xScale, float yScale, float xOffset,

                    float yOffset, float xPrecision, float yPrecision, float rawXCursorPosition,

                    float rawYCursorPosition, nsecs_t downTime, nsecs_t eventTime,

                    size_t pointerCount, const PointerProperties* pointerProperties,
@@ -676,6 +682,8 @@ protected: 
    int32_t mMetaState;

    int32_t mButtonState;

    MotionClassification mClassification;

    float mXScale;

    float mYScale;

    float mXOffset;

    float mYOffset;

    float mXPrecision;

include/input/InputTransport.h

+15 −16
Original line number Diff line number Diff line
@@ -76,6 +76,9 @@ struct InputMessage { 
    } header;



    // Body *must* be 8 byte aligned.

    // For keys and motions, rely on the fact that std::array takes up exactly as much space

    // as the underlying data. This is not guaranteed by C++, but it simplifies the conversions.

    static_assert(sizeof(std::array<uint8_t, 32>) == 32);

    union Body {

        struct Key {

            uint32_t seq;
@@ -84,6 +87,7 @@ struct InputMessage { 
            int32_t deviceId;

            int32_t source;

            int32_t displayId;

            std::array<uint8_t, 32> hmac;

            int32_t action;

            int32_t flags;

            int32_t keyCode;
@@ -103,6 +107,7 @@ struct InputMessage { 
            int32_t deviceId;

            int32_t source;

            int32_t displayId;

            std::array<uint8_t, 32> hmac;

            int32_t action;

            int32_t actionButton;

            int32_t flags;
@@ -112,6 +117,8 @@ struct InputMessage { 
            uint8_t empty2[3];                   // 3 bytes to fill gap created by classification

            int32_t edgeFlags;

            nsecs_t downTime __attribute__((aligned(8)));

            float xScale;

            float yScale;

            float xOffset;

            float yOffset;

            float xPrecision;
@@ -269,19 +276,10 @@ public: 
     * Returns BAD_VALUE if seq is 0.

     * Other errors probably indicate that the channel is broken.

     */

    status_t publishKeyEvent(

            uint32_t seq,

            int32_t deviceId,

            int32_t source,

            int32_t displayId,

            int32_t action,

            int32_t flags,

            int32_t keyCode,

            int32_t scanCode,

            int32_t metaState,

            int32_t repeatCount,

            nsecs_t downTime,

            nsecs_t eventTime);

    status_t publishKeyEvent(uint32_t seq, int32_t deviceId, int32_t source, int32_t displayId,

                             std::array<uint8_t, 32> hmac, int32_t action, int32_t flags,

                             int32_t keyCode, int32_t scanCode, int32_t metaState,

                             int32_t repeatCount, nsecs_t downTime, nsecs_t eventTime);



    /* Publishes a motion event to the input channel.

     *
@@ -292,9 +290,10 @@ public: 
     * Other errors probably indicate that the channel is broken.

     */

    status_t publishMotionEvent(uint32_t seq, int32_t deviceId, int32_t source, int32_t displayId,

                                int32_t action, int32_t actionButton, int32_t flags,

                                int32_t edgeFlags, int32_t metaState, int32_t buttonState,

                                MotionClassification classification, float xOffset, float yOffset,

                                std::array<uint8_t, 32> hmac, int32_t action, int32_t actionButton,

                                int32_t flags, int32_t edgeFlags, int32_t metaState,

                                int32_t buttonState, MotionClassification classification,

                                float xScale, float yScale, float xOffset, float yOffset,

                                float xPrecision, float yPrecision, float xCursorPosition,

                                float yCursorPosition, nsecs_t downTime, nsecs_t eventTime,

                                uint32_t pointerCount, const PointerProperties* pointerProperties,

libs/input/Input.cpp

+36 −24
Original line number Diff line number Diff line
@@ -57,16 +57,19 @@ const char* inputEventTypeToString(int32_t type) { 
    return "UNKNOWN";

}



void InputEvent::initialize(int32_t deviceId, int32_t source, int32_t displayId) {

void InputEvent::initialize(int32_t deviceId, int32_t source, int32_t displayId,

                            std::array<uint8_t, 32> hmac) {

    mDeviceId = deviceId;

    mSource = source;

    mDisplayId = displayId;

    mHmac = hmac;

}



void InputEvent::initialize(const InputEvent& from) {

    mDeviceId = from.mDeviceId;

    mSource = from.mSource;

    mDisplayId = from.mDisplayId;

    mHmac = from.mHmac;

}



// --- KeyEvent ---
@@ -79,19 +82,11 @@ int32_t KeyEvent::getKeyCodeFromLabel(const char* label) { 
    return getKeyCodeByLabel(label);

}



void KeyEvent::initialize(

        int32_t deviceId,

        int32_t source,

        int32_t displayId,

        int32_t action,

        int32_t flags,

        int32_t keyCode,

        int32_t scanCode,

        int32_t metaState,

        int32_t repeatCount,

        nsecs_t downTime,

        nsecs_t eventTime) {

    InputEvent::initialize(deviceId, source, displayId);

void KeyEvent::initialize(int32_t deviceId, int32_t source, int32_t displayId,

                          std::array<uint8_t, 32> hmac, int32_t action, int32_t flags,

                          int32_t keyCode, int32_t scanCode, int32_t metaState, int32_t repeatCount,

                          nsecs_t downTime, nsecs_t eventTime) {

    InputEvent::initialize(deviceId, source, displayId, hmac);

    mAction = action;

    mFlags = flags;

    mKeyCode = keyCode;
@@ -250,15 +245,16 @@ void PointerProperties::copyFrom(const PointerProperties& other) { 


// --- MotionEvent ---



void MotionEvent::initialize(int32_t deviceId, int32_t source, int32_t displayId, int32_t action,

                             int32_t actionButton, int32_t flags, int32_t edgeFlags,

                             int32_t metaState, int32_t buttonState,

                             MotionClassification classification, float xOffset, float yOffset,

                             float xPrecision, float yPrecision, float rawXCursorPosition,

                             float rawYCursorPosition, nsecs_t downTime, nsecs_t eventTime,

                             size_t pointerCount, const PointerProperties* pointerProperties,

void MotionEvent::initialize(int32_t deviceId, int32_t source, int32_t displayId,

                             std::array<uint8_t, 32> hmac, int32_t action, int32_t actionButton,

                             int32_t flags, int32_t edgeFlags, int32_t metaState,

                             int32_t buttonState, MotionClassification classification, float xScale,

                             float yScale, float xOffset, float yOffset, float xPrecision,

                             float yPrecision, float rawXCursorPosition, float rawYCursorPosition,

                             nsecs_t downTime, nsecs_t eventTime, size_t pointerCount,

                             const PointerProperties* pointerProperties,

                             const PointerCoords* pointerCoords) {

    InputEvent::initialize(deviceId, source, displayId);

    InputEvent::initialize(deviceId, source, displayId, hmac);

    mAction = action;

    mActionButton = actionButton;

    mFlags = flags;
@@ -266,6 +262,8 @@ void MotionEvent::initialize(int32_t deviceId, int32_t source, int32_t displayId 
    mMetaState = metaState;

    mButtonState = buttonState;

    mClassification = classification;

    mXScale = xScale;

    mYScale = yScale;

    mXOffset = xOffset;

    mYOffset = yOffset;

    mXPrecision = xPrecision;
@@ -281,7 +279,7 @@ void MotionEvent::initialize(int32_t deviceId, int32_t source, int32_t displayId 
}



void MotionEvent::copyFrom(const MotionEvent* other, bool keepHistory) {

    InputEvent::initialize(other->mDeviceId, other->mSource, other->mDisplayId);

    InputEvent::initialize(other->mDeviceId, other->mSource, other->mDisplayId, other->mHmac);

    mAction = other->mAction;

    mActionButton = other->mActionButton;

    mFlags = other->mFlags;
@@ -289,6 +287,8 @@ void MotionEvent::copyFrom(const MotionEvent* other, bool keepHistory) { 
    mMetaState = other->mMetaState;

    mButtonState = other->mButtonState;

    mClassification = other->mClassification;

    mXScale = other->mXScale;

    mYScale = other->mYScale;

    mXOffset = other->mXOffset;

    mYOffset = other->mYOffset;

    mXPrecision = other->mXPrecision;
@@ -490,6 +490,12 @@ status_t MotionEvent::readFromParcel(Parcel* parcel) { 
    mDeviceId = parcel->readInt32();

    mSource = parcel->readInt32();

    mDisplayId = parcel->readInt32();

    std::vector<uint8_t> hmac;

    status_t result = parcel->readByteVector(&hmac);

    if (result != OK || hmac.size() != 32) {

        return BAD_VALUE;

    }

    std::move(hmac.begin(), hmac.begin() + hmac.size(), mHmac.begin());

    mAction = parcel->readInt32();

    mActionButton = parcel->readInt32();

    mFlags = parcel->readInt32();
@@ -497,6 +503,8 @@ status_t MotionEvent::readFromParcel(Parcel* parcel) { 
    mMetaState = parcel->readInt32();

    mButtonState = parcel->readInt32();

    mClassification = static_cast<MotionClassification>(parcel->readByte());

    mXScale = parcel->readFloat();

    mYScale = parcel->readFloat();

    mXOffset = parcel->readFloat();

    mYOffset = parcel->readFloat();

    mXPrecision = parcel->readFloat();
@@ -543,6 +551,8 @@ status_t MotionEvent::writeToParcel(Parcel* parcel) const { 
    parcel->writeInt32(mDeviceId);

    parcel->writeInt32(mSource);

    parcel->writeInt32(mDisplayId);

    std::vector<uint8_t> hmac(mHmac.begin(), mHmac.end());

    parcel->writeByteVector(hmac);

    parcel->writeInt32(mAction);

    parcel->writeInt32(mActionButton);

    parcel->writeInt32(mFlags);
@@ -550,6 +560,8 @@ status_t MotionEvent::writeToParcel(Parcel* parcel) const { 
    parcel->writeInt32(mMetaState);

    parcel->writeInt32(mButtonState);

    parcel->writeByte(static_cast<int8_t>(mClassification));

    parcel->writeFloat(mXScale);

    parcel->writeFloat(mYScale);

    parcel->writeFloat(mXOffset);

    parcel->writeFloat(mYOffset);

    parcel->writeFloat(mXPrecision);
@@ -607,7 +619,7 @@ int32_t MotionEvent::getAxisFromLabel(const char* label) { 


void FocusEvent::initialize(bool hasFocus, bool inTouchMode) {

    InputEvent::initialize(ReservedInputDeviceId::VIRTUAL_KEYBOARD_ID, AINPUT_SOURCE_UNKNOWN,

                           ADISPLAY_ID_NONE);

                           ADISPLAY_ID_NONE, INVALID_HMAC);

    mHasFocus = hasFocus;

    mInTouchMode = inTouchMode;

}

libs/input/InputTransport.cpp

+37 −39
Original line number Diff line number Diff line
@@ -147,6 +147,8 @@ void InputMessage::getSanitizedCopy(InputMessage* msg) const { 
            msg->body.key.source = body.key.source;

            // int32_t displayId

            msg->body.key.displayId = body.key.displayId;

            // std::array<uint8_t, 32> hmac

            msg->body.key.hmac = body.key.hmac;

            // int32_t action

            msg->body.key.action = body.key.action;

            // int32_t flags
@@ -174,6 +176,8 @@ void InputMessage::getSanitizedCopy(InputMessage* msg) const { 
            msg->body.motion.source = body.motion.source;

            // int32_t displayId

            msg->body.motion.displayId = body.motion.displayId;

            // std::array<uint8_t, 32> hmac

            msg->body.motion.hmac = body.motion.hmac;

            // int32_t action

            msg->body.motion.action = body.motion.action;

            // int32_t actionButton
@@ -190,6 +194,10 @@ void InputMessage::getSanitizedCopy(InputMessage* msg) const { 
            msg->body.motion.edgeFlags = body.motion.edgeFlags;

            // nsecs_t downTime

            msg->body.motion.downTime = body.motion.downTime;

            // float xScale

            msg->body.motion.xScale = body.motion.xScale;

            // float yScale

            msg->body.motion.yScale = body.motion.yScale;

            // float xOffset

            msg->body.motion.xOffset = body.motion.xOffset;

            // float yOffset
@@ -424,19 +432,11 @@ InputPublisher::InputPublisher(const sp<InputChannel>& channel) : 
InputPublisher::~InputPublisher() {

}



status_t InputPublisher::publishKeyEvent(

        uint32_t seq,

        int32_t deviceId,

        int32_t source,

        int32_t displayId,

        int32_t action,

        int32_t flags,

        int32_t keyCode,

        int32_t scanCode,

        int32_t metaState,

        int32_t repeatCount,

        nsecs_t downTime,

        nsecs_t eventTime) {

status_t InputPublisher::publishKeyEvent(uint32_t seq, int32_t deviceId, int32_t source,

                                         int32_t displayId, std::array<uint8_t, 32> hmac,

                                         int32_t action, int32_t flags, int32_t keyCode,

                                         int32_t scanCode, int32_t metaState, int32_t repeatCount,

                                         nsecs_t downTime, nsecs_t eventTime) {

    if (ATRACE_ENABLED()) {

        std::string message = StringPrintf("publishKeyEvent(inputChannel=%s, keyCode=%" PRId32 ")",

                mChannel->getName().c_str(), keyCode);
@@ -461,6 +461,7 @@ status_t InputPublisher::publishKeyEvent( 
    msg.body.key.deviceId = deviceId;

    msg.body.key.source = source;

    msg.body.key.displayId = displayId;

    msg.body.key.hmac = hmac;

    msg.body.key.action = action;

    msg.body.key.flags = flags;

    msg.body.key.keyCode = keyCode;
@@ -473,11 +474,12 @@ status_t InputPublisher::publishKeyEvent( 
}



status_t InputPublisher::publishMotionEvent(

        uint32_t seq, int32_t deviceId, int32_t source, int32_t displayId, int32_t action,

        int32_t actionButton, int32_t flags, int32_t edgeFlags, int32_t metaState,

        int32_t buttonState, MotionClassification classification, float xOffset, float yOffset,

        float xPrecision, float yPrecision, float xCursorPosition, float yCursorPosition,

        nsecs_t downTime, nsecs_t eventTime, uint32_t pointerCount,

        uint32_t seq, int32_t deviceId, int32_t source, int32_t displayId,

        std::array<uint8_t, 32> hmac, int32_t action, int32_t actionButton, int32_t flags,

        int32_t edgeFlags, int32_t metaState, int32_t buttonState,

        MotionClassification classification, float xScale, float yScale, float xOffset,

        float yOffset, float xPrecision, float yPrecision, float xCursorPosition,

        float yCursorPosition, nsecs_t downTime, nsecs_t eventTime, uint32_t pointerCount,

        const PointerProperties* pointerProperties, const PointerCoords* pointerCoords) {

    if (ATRACE_ENABLED()) {

        std::string message = StringPrintf(
@@ -489,13 +491,14 @@ status_t InputPublisher::publishMotionEvent( 
        ALOGD("channel '%s' publisher ~ publishMotionEvent: seq=%u, deviceId=%d, source=0x%x, "

              "displayId=%" PRId32 ", "

              "action=0x%x, actionButton=0x%08x, flags=0x%x, edgeFlags=0x%x, "

              "metaState=0x%x, buttonState=0x%x, classification=%s, xOffset=%f, yOffset=%f, "

              "metaState=0x%x, buttonState=0x%x, classification=%s, xScale=%.1f, yScale=%.1f, "

              "xOffset=%.1f, yOffset=%.1f, "

              "xPrecision=%f, yPrecision=%f, downTime=%" PRId64 ", eventTime=%" PRId64 ", "

              "pointerCount=%" PRIu32,

              mChannel->getName().c_str(), seq, deviceId, source, displayId, action, actionButton,

              flags, edgeFlags, metaState, buttonState,

              motionClassificationToString(classification), xOffset, yOffset, xPrecision,

              yPrecision, downTime, eventTime, pointerCount);

              motionClassificationToString(classification), xScale, yScale, xOffset, yOffset,

              xPrecision, yPrecision, downTime, eventTime, pointerCount);

    }



    if (!seq) {
@@ -515,6 +518,7 @@ status_t InputPublisher::publishMotionEvent( 
    msg.body.motion.deviceId = deviceId;

    msg.body.motion.source = source;

    msg.body.motion.displayId = displayId;

    msg.body.motion.hmac = hmac;

    msg.body.motion.action = action;

    msg.body.motion.actionButton = actionButton;

    msg.body.motion.flags = flags;
@@ -522,6 +526,8 @@ status_t InputPublisher::publishMotionEvent( 
    msg.body.motion.metaState = metaState;

    msg.body.motion.buttonState = buttonState;

    msg.body.motion.classification = classification;

    msg.body.motion.xScale = xScale;

    msg.body.motion.yScale = yScale;

    msg.body.motion.xOffset = xOffset;

    msg.body.motion.yOffset = yOffset;

    msg.body.motion.xPrecision = xPrecision;
@@ -1136,18 +1142,10 @@ ssize_t InputConsumer::findTouchState(int32_t deviceId, int32_t source) const { 
}



void InputConsumer::initializeKeyEvent(KeyEvent* event, const InputMessage* msg) {

    event->initialize(

            msg->body.key.deviceId,

            msg->body.key.source,

            msg->body.key.displayId,

            msg->body.key.action,

            msg->body.key.flags,

            msg->body.key.keyCode,

            msg->body.key.scanCode,

            msg->body.key.metaState,

            msg->body.key.repeatCount,

            msg->body.key.downTime,

            msg->body.key.eventTime);

    event->initialize(msg->body.key.deviceId, msg->body.key.source, msg->body.key.displayId,

                      msg->body.key.hmac, msg->body.key.action, msg->body.key.flags,

                      msg->body.key.keyCode, msg->body.key.scanCode, msg->body.key.metaState,

                      msg->body.key.repeatCount, msg->body.key.downTime, msg->body.key.eventTime);

}



void InputConsumer::initializeFocusEvent(FocusEvent* event, const InputMessage* msg) {
@@ -1164,15 +1162,15 @@ void InputConsumer::initializeMotionEvent(MotionEvent* event, const InputMessage 
    }



    event->initialize(msg->body.motion.deviceId, msg->body.motion.source,

                      msg->body.motion.displayId, msg->body.motion.action,

                      msg->body.motion.displayId, msg->body.motion.hmac, msg->body.motion.action,

                      msg->body.motion.actionButton, msg->body.motion.flags,

                      msg->body.motion.edgeFlags, msg->body.motion.metaState,

                      msg->body.motion.buttonState, msg->body.motion.classification,

                      msg->body.motion.xOffset, msg->body.motion.yOffset,

                      msg->body.motion.xPrecision, msg->body.motion.yPrecision,

                      msg->body.motion.xCursorPosition, msg->body.motion.yCursorPosition,

                      msg->body.motion.downTime, msg->body.motion.eventTime, pointerCount,

                      pointerProperties, pointerCoords);

                      msg->body.motion.xScale, msg->body.motion.yScale, msg->body.motion.xOffset,

                      msg->body.motion.yOffset, msg->body.motion.xPrecision,

                      msg->body.motion.yPrecision, msg->body.motion.xCursorPosition,

                      msg->body.motion.yCursorPosition, msg->body.motion.downTime,

                      msg->body.motion.eventTime, pointerCount, pointerProperties, pointerCoords);

}



void InputConsumer::addSample(MotionEvent* event, const InputMessage* msg) {

libs/input/KeyCharacterMap.cpp

+3 −3
Original line number Diff line number Diff line
@@ -487,9 +487,9 @@ void KeyCharacterMap::addKey(Vector<KeyEvent>& outEvents, 
        int32_t deviceId, int32_t keyCode, int32_t metaState, bool down, nsecs_t time) {

    outEvents.push();

    KeyEvent& event = outEvents.editTop();

    event.initialize(deviceId, AINPUT_SOURCE_KEYBOARD, ADISPLAY_ID_NONE,

            down ? AKEY_EVENT_ACTION_DOWN : AKEY_EVENT_ACTION_UP,

            0, keyCode, 0, metaState, 0, time, time);

    event.initialize(deviceId, AINPUT_SOURCE_KEYBOARD, ADISPLAY_ID_NONE, INVALID_HMAC,

                     down ? AKEY_EVENT_ACTION_DOWN : AKEY_EVENT_ACTION_UP, 0, keyCode, 0, metaState,

                     0, time, time);

}



void KeyCharacterMap::addMetaKeys(Vector<KeyEvent>& outEvents,