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

Commit 45c3855f authored by Jeff Tinker's avatar Jeff Tinker
Browse files

VTS tests for fixed MediaDrm security level APIs 

Vendors implementing the newly added MediaDrm.setSecurityLevel
HAL found that it was difficult to implement properly. Also the
semantics are somewhat ambiguous from the Java platform API
level. The APIs have changed to bind the security level
assignment to openSession which clarifies the API for apps as
well as making it more natural to implement in HAL modules. This
CL updates the VTS tests to account for those changes.

bug:72831697
bug:64001680

test: VtsHalDrmV1_1TargetTest, GTS media tests
Change-Id: I2adf13f9da7726b206df6fcc82b1e2e11fc94674
parent e3d0fd34

drm/1.1/vts/functional/drm_hal_clearkey_test.cpp

+82 −49
Original line number Diff line number Diff line
@@ -158,6 +158,7 @@ public: 
    virtual void TearDown() override {}



    SessionId openSession();

    SessionId openSession(SecurityLevel level);

    void closeSession(const SessionId& sessionId);

    hidl_vec<uint8_t> loadKeys(const SessionId& sessionId, const KeyType& type);

    sp<IMemory> getDecryptMemory(size_t size, size_t index);
@@ -276,6 +277,23 @@ SessionId DrmHalClearkeyTest::openSession() { 
    return sessionId;

}



/**

 * Helper method to open as session using V1.1 API

 */

SessionId DrmHalClearkeyTest::openSession(SecurityLevel level) {

    SessionId sessionId;



    auto res = drmPlugin->openSession_1_1(level,

            [&sessionId](Status status, const SessionId& id) {

                EXPECT_EQ(Status::OK, status);

                EXPECT_NE(0u, id.size());

                sessionId = id;

            });

    EXPECT_OK(res);

    return sessionId;

}





/**

 * Helper method to close a session

 */
@@ -298,14 +316,14 @@ TEST_F(DrmHalClearkeyTest, GetHdcpLevels) { 
}



/**

 * Test that the plugin returns valid open and max session counts

 * Test that the plugin returns default open and max session counts

 */

TEST_F(DrmHalClearkeyTest, GetSessionCounts) {

TEST_F(DrmHalClearkeyTest, GetDefaultSessionCounts) {

    auto res = drmPlugin->getNumberOfSessions(

            [&](Status status, uint32_t currentSessions,

                    uint32_t maxSessions) {

                EXPECT_EQ(Status::OK, status);

                EXPECT_GT(maxSessions, (uint32_t)0);

                EXPECT_GE(maxSessions, (uint32_t)8);

                EXPECT_GE(currentSessions, (uint32_t)0);

                EXPECT_LE(currentSessions, maxSessions);

            });
@@ -313,77 +331,92 @@ TEST_F(DrmHalClearkeyTest, GetSessionCounts) { 
}



/**

 * Test that the plugin returns a valid security level for

 * a valid session

 * Test that the plugin returns valid open and max session counts

 * after a session is opened.

 */

TEST_F(DrmHalClearkeyTest, GetSecurityLevel) {

TEST_F(DrmHalClearkeyTest, GetOpenSessionCounts) {

    uint32_t initialSessions = 0;

    auto res = drmPlugin->getNumberOfSessions(

            [&](Status status, uint32_t currentSessions,

                    uint32_t maxSessions) {

                EXPECT_EQ(Status::OK, status);

                EXPECT_GE(maxSessions, (uint32_t)8);

                EXPECT_GE(currentSessions, (uint32_t)0);

                EXPECT_LE(currentSessions, maxSessions);

                initialSessions = currentSessions;

            });

    EXPECT_OK(res);



    SessionId session = openSession();

    auto res = drmPlugin->getSecurityLevel(session,

            [&](Status status, SecurityLevel level) {

    res = drmPlugin->getNumberOfSessions(

            [&](Status status, uint32_t currentSessions,

                    uint32_t /*maxSessions*/) {

                EXPECT_EQ(Status::OK, status);

                EXPECT_GE(level, SecurityLevel::SW_SECURE_CRYPTO);

                EXPECT_LE(level, SecurityLevel::HW_SECURE_ALL);

                EXPECT_EQ(currentSessions, initialSessions + 1);

            });

    EXPECT_OK(res);

    closeSession(session);

}



/**

 * Test that the plugin returns the documented error

 * when requesting the security level for an invalid sessionId

 */

TEST_F(DrmHalClearkeyTest, GetSecurityLevelInvalidSessionId) {

    SessionId session;

    auto res = drmPlugin->getSecurityLevel(session,

            [&](Status status, SecurityLevel /*level*/) {

                EXPECT_EQ(Status::BAD_VALUE, status);

    closeSession(session);

    res = drmPlugin->getNumberOfSessions(

            [&](Status status, uint32_t currentSessions,

                    uint32_t /*maxSessions*/) {

                EXPECT_EQ(Status::OK, status);

                EXPECT_EQ(currentSessions, initialSessions);

            });

    EXPECT_OK(res);

}



/**

 * Test that setting all valid security levels on a valid sessionId

 * is supported

 * Test that the plugin returns the same security level

 * by default as when it is requested explicitly

 */

TEST_F(DrmHalClearkeyTest, SetSecurityLevel) {

TEST_F(DrmHalClearkeyTest, GetDefaultSecurityLevel) {

    SessionId session = openSession();

    for (uint32_t level = static_cast<uint32_t>(SecurityLevel::SW_SECURE_CRYPTO);

         level <= static_cast<uint32_t>(SecurityLevel::HW_SECURE_ALL); level++) {

        EXPECT_EQ(Status::OK, drmPlugin->setSecurityLevel(session, static_cast<SecurityLevel>(level)));



        // check that the level got set

    SecurityLevel defaultLevel;

    auto res = drmPlugin->getSecurityLevel(session,

                [&](Status status, SecurityLevel readLevel) {

            [&](Status status, SecurityLevel level) {

                EXPECT_EQ(Status::OK, status);

                    EXPECT_EQ(level, static_cast<uint32_t>(readLevel));

                defaultLevel = level;

            });

    EXPECT_OK(res);

    closeSession(session);



    session = openSession(defaultLevel);

    res = drmPlugin->getSecurityLevel(session,

            [&](Status status, SecurityLevel level) {

                EXPECT_EQ(Status::OK, status);

                EXPECT_EQ(level, defaultLevel);

            });

    EXPECT_OK(res);

    }

    closeSession(session);

}



/**

 * Test that setting an invalid security level on a valid

 * sessionId is prohibited with the documented error code.

 * Test that the plugin returns the lowest security level

 * when it is requested

 */

TEST_F(DrmHalClearkeyTest, SetInvalidSecurityLevel) {

    SessionId session = openSession();

    SecurityLevel level = static_cast<SecurityLevel>(

            static_cast<uint32_t>(SecurityLevel::HW_SECURE_ALL) + 1);

    Status status = drmPlugin->setSecurityLevel(session, level);

    EXPECT_EQ(Status::BAD_VALUE, status);

TEST_F(DrmHalClearkeyTest, GetSecurityLevel) {

    SessionId session = openSession(SecurityLevel::SW_SECURE_CRYPTO);

    auto res = drmPlugin->getSecurityLevel(session,

            [&](Status status, SecurityLevel level) {

                EXPECT_EQ(Status::OK, status);

                EXPECT_EQ(level, SecurityLevel::SW_SECURE_CRYPTO);

            });

    EXPECT_OK(res);

    closeSession(session);

}



/**

 * Test that attempting to set security level on an invalid

 * (empty) sessionId is prohibited with the documented error

 * code.

 * Test that the plugin returns the documented error

 * when requesting the security level for an invalid sessionId

 */

TEST_F(DrmHalClearkeyTest, SetSecurityLevelInvalidSessionId) {

TEST_F(DrmHalClearkeyTest, GetSecurityLevelInvalidSessionId) {

    SessionId session;

    SecurityLevel level = SecurityLevel::SW_SECURE_CRYPTO;

    EXPECT_EQ(Status::BAD_VALUE, drmPlugin->setSecurityLevel(session, level));

    auto res = drmPlugin->getSecurityLevel(session,

            [&](Status status, SecurityLevel /*level*/) {

                EXPECT_EQ(Status::BAD_VALUE, status);

            });

    EXPECT_OK(res);

}



/**