default/tests/FakeFaceEngineTest.cpp

/*
 * Copyright (C) 2022 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <android/binder_process.h>
#include <face.sysprop.h>
#include <gtest/gtest.h>

#include <aidl/android/hardware/biometrics/face/BnSessionCallback.h>
#include <android-base/logging.h>

#include "Face.h"
#include "FakeFaceEngine.h"
#include "util/Util.h"

using namespace ::android::face::virt;
using namespace ::aidl::android::hardware::biometrics::face;
using namespace ::aidl::android::hardware::keymaster;

namespace aidl::android::hardware::biometrics::face {

class TestSessionCallback : public BnSessionCallback {
  public:
    ndk::ScopedAStatus onChallengeGenerated(int64_t challenge) override {
        mLastChallenge = challenge;
        return ndk::ScopedAStatus::ok();
    };
    ::ndk::ScopedAStatus onChallengeRevoked(int64_t challenge) override {
        mLastChallengeRevoked = challenge;
        return ndk::ScopedAStatus::ok();
    };
    ::ndk::ScopedAStatus onError(Error error, int32_t) override {
        mError = error;
        return ndk::ScopedAStatus::ok();
    };
    ::ndk::ScopedAStatus onEnrollmentProgress(int32_t enrollmentId, int32_t remaining) override {
        if (remaining == 0) mLastEnrolled = enrollmentId;
        mRemaining = remaining;
        return ndk::ScopedAStatus::ok();
    };

    ::ndk::ScopedAStatus onAuthenticationSucceeded(int32_t enrollmentId,
                                                   const HardwareAuthToken&) override {
        mLastAuthenticated = enrollmentId;
        mAuthenticateFailed = false;
        return ndk::ScopedAStatus::ok();
    };
    ::ndk::ScopedAStatus onAuthenticationFailed() override {
        mLastAuthenticated = 0;
        mAuthenticateFailed = true;
        return ndk::ScopedAStatus::ok();
    };
    ::ndk::ScopedAStatus onInteractionDetected() override {
        mInteractionDetectedCount++;
        return ndk::ScopedAStatus::ok();
    };

    ::ndk::ScopedAStatus onEnrollmentFrame(const EnrollmentFrame& frame) override {
        mEnrollmentFrames.push_back(frame.data.vendorCode);
        return ndk::ScopedAStatus::ok();
    }

    ::ndk::ScopedAStatus onEnrollmentsEnumerated(
            const std::vector<int32_t>& enrollmentIds) override {
        mLastEnrollmentsEnumerated = enrollmentIds;
        return ndk::ScopedAStatus::ok();
    };
    ::ndk::ScopedAStatus onEnrollmentsRemoved(const std::vector<int32_t>& enrollmentIds) override {
        mLastEnrollmentRemoved = enrollmentIds;
        return ndk::ScopedAStatus::ok();
    };
    ::ndk::ScopedAStatus onAuthenticatorIdRetrieved(int64_t authenticatorId) override {
        mLastAuthenticatorId = authenticatorId;
        return ndk::ScopedAStatus::ok();
    };
    ::ndk::ScopedAStatus onAuthenticatorIdInvalidated(int64_t authenticatorId) override {
        mLastAuthenticatorId = authenticatorId;
        mAuthenticatorIdInvalidated = true;
        return ndk::ScopedAStatus::ok();
    };
    ::ndk::ScopedAStatus onAuthenticationFrame(const AuthenticationFrame& /*authFrame*/) override {
        return ndk::ScopedAStatus::ok();
    }
    ::ndk::ScopedAStatus onLockoutPermanent() override {
        mLockoutPermanent = true;
        return ndk::ScopedAStatus::ok();
    };
    ::ndk::ScopedAStatus onLockoutTimed(int64_t /* timeout */) override {
        return ndk::ScopedAStatus::ok();
    }
    ::ndk::ScopedAStatus onLockoutCleared() override {
        mLockoutPermanent = false;
        return ndk::ScopedAStatus::ok();
    }
    ::ndk::ScopedAStatus onSessionClosed() override { return ndk::ScopedAStatus::ok(); }

    ::ndk::ScopedAStatus onFeaturesRetrieved(const std::vector<Feature>& features) override {
        mFeatures = features;
        return ndk::ScopedAStatus::ok();
    }

    ::ndk::ScopedAStatus onFeatureSet(Feature feature) override {
        mLastFeatureSet = feature;
        return ndk::ScopedAStatus::ok();
    }

    Error mError = Error::UNKNOWN;
    int64_t mLastChallenge = -1;
    int64_t mLastChallengeRevoked = -1;
    int32_t mLastEnrolled = -1;
    int32_t mLastAuthenticated = -1;
    int64_t mLastAuthenticatorId = -1;
    std::vector<int32_t> mLastEnrollmentsEnumerated;
    std::vector<int32_t> mLastEnrollmentRemoved;
    std::vector<Feature> mFeatures;
    Feature mLastFeatureSet;
    std::vector<int32_t> mEnrollmentFrames;
    bool mAuthenticateFailed = false;
    bool mAuthenticatorIdInvalidated = false;
    bool mLockoutPermanent = false;
    int mInteractionDetectedCount = 0;
    int mRemaining = -1;
};

class FakeFaceEngineTest : public ::testing::Test {
  protected:
    void SetUp() override {
        LOG(ERROR) << "JRM SETUP";
        mCallback = ndk::SharedRefBase::make<TestSessionCallback>();
    }

    void TearDown() override {
        Face::cfg().setopt<OptIntVec>("enrollments", {});
        Face::cfg().set<std::int64_t>("challenge", 0);
        Face::cfg().setopt<OptIntVec>("features", {});
        Face::cfg().set<std::int64_t>("authenticator_id", 0);
        Face::cfg().set<std::string>("strength", "");
        Face::cfg().setopt<OptIntVec>("operation_detect_interaction_latency", {});
    }

    FakeFaceEngine mEngine;
    std::shared_ptr<TestSessionCallback> mCallback;
    std::promise<void> mCancel;
};

TEST_F(FakeFaceEngineTest, one_eq_one) {
    ASSERT_EQ(1, 1);
}

TEST_F(FakeFaceEngineTest, GenerateChallenge) {
    mEngine.generateChallengeImpl(mCallback.get());
    ASSERT_EQ(Face::cfg().get<std::int64_t>("challenge"), mCallback->mLastChallenge);
}

TEST_F(FakeFaceEngineTest, RevokeChallenge) {
    auto challenge = Face::cfg().get<std::int64_t>("challenge");
    mEngine.revokeChallengeImpl(mCallback.get(), challenge);
    ASSERT_FALSE(Face::cfg().get<std::int64_t>("challenge"));
    ASSERT_EQ(challenge, mCallback->mLastChallengeRevoked);
}

TEST_F(FakeFaceEngineTest, ResetLockout) {
    Face::cfg().set<bool>("lockout", true);
    mEngine.resetLockoutImpl(mCallback.get(), {});
    ASSERT_FALSE(mCallback->mLockoutPermanent);
    ASSERT_FALSE(Face::cfg().get<bool>("lockout"));
}

TEST_F(FakeFaceEngineTest, AuthenticatorId) {
    Face::cfg().set<std::int64_t>("authenticator_id", 50);
    mEngine.getAuthenticatorIdImpl(mCallback.get());
    ASSERT_EQ(50, mCallback->mLastAuthenticatorId);
    ASSERT_FALSE(mCallback->mAuthenticatorIdInvalidated);
}

TEST_F(FakeFaceEngineTest, GetAuthenticatorIdWeakReturnsZero) {
    Face::cfg().set<std::string>("strength", "weak");
    Face::cfg().set<std::int64_t>("authenticator_id", 500);
    mEngine.getAuthenticatorIdImpl(mCallback.get());
    ASSERT_EQ(0, mCallback->mLastAuthenticatorId);
    ASSERT_FALSE(mCallback->mAuthenticatorIdInvalidated);
}

TEST_F(FakeFaceEngineTest, AuthenticatorIdInvalidate) {
    Face::cfg().set<std::int64_t>("authenticator_id", 500);
    mEngine.invalidateAuthenticatorIdImpl(mCallback.get());
    ASSERT_NE(500, Face::cfg().get<std::int64_t>("authenticator_id"));
    ASSERT_TRUE(mCallback->mAuthenticatorIdInvalidated);
}

TEST_F(FakeFaceEngineTest, Enroll) {
    Face::cfg().set<std::string>("next_enrollment",
                                 "1,0:1000-[21,5,6,7,1],1100-[1118,1108,1]:true");
    keymaster::HardwareAuthToken hat{.mac = {2, 4}};
    mEngine.enrollImpl(mCallback.get(), hat, {} /*enrollmentType*/, {} /*features*/,
                       mCancel.get_future());
    ASSERT_FALSE(Face::cfg().getopt<OptString>("next_enrollment").has_value());
    ASSERT_EQ(1, Face::cfg().getopt<OptIntVec>("enrollments").size());
    ASSERT_EQ(1, Face::cfg().getopt<OptIntVec>("enrollments")[0].value());
    ASSERT_EQ(1, mCallback->mLastEnrolled);
    ASSERT_EQ(0, mCallback->mRemaining);
}

TEST_F(FakeFaceEngineTest, EnrollFails) {
    Face::cfg().set<std::string>("next_enrollment",
                                 "1,0:1000-[21,5,6,7,1],1100-[1118,1108,1]:false");
    keymaster::HardwareAuthToken hat{.mac = {2, 4}};
    mEngine.enrollImpl(mCallback.get(), hat, {} /*enrollmentType*/, {} /*features*/,
                       mCancel.get_future());
    ASSERT_FALSE(Face::cfg().getopt<OptString>("next_enrollment").has_value());
    ASSERT_EQ(0, Face::cfg().getopt<OptIntVec>("enrollments").size());
}

TEST_F(FakeFaceEngineTest, EnrollCancel) {
    Face::cfg().set<std::string>("next_enrollment", "1:2000-[21,8,9],300:false");
    keymaster::HardwareAuthToken hat{.mac = {2, 4}};
    mCancel.set_value();
    mEngine.enrollImpl(mCallback.get(), hat, {} /*enrollmentType*/, {} /*features*/,
                       mCancel.get_future());
    ASSERT_EQ(Error::CANCELED, mCallback->mError);
    ASSERT_EQ(-1, mCallback->mLastEnrolled);
    ASSERT_EQ(0, Face::cfg().getopt<OptIntVec>("enrollments").size());
    ASSERT_FALSE(Face::cfg().get<std::string>("next_enrollment").empty());
}

TEST_F(FakeFaceEngineTest, Authenticate) {
    Face::cfg().setopt<OptIntVec>("enrollments", {100});
    Face::cfg().set<std::int32_t>("enrollment_hit", 100);
    mEngine.authenticateImpl(mCallback.get(), 0 /* operationId*/, mCancel.get_future());

    ASSERT_EQ(100, mCallback->mLastAuthenticated);
    ASSERT_FALSE(mCallback->mAuthenticateFailed);
}

TEST_F(FakeFaceEngineTest, AuthenticateCancel) {
    Face::cfg().setopt<OptIntVec>("enrollments", {100});
    Face::cfg().set<std::int32_t>("enrollment_hit", 100);
    mCancel.set_value();
    mEngine.authenticateImpl(mCallback.get(), 0 /* operationId*/, mCancel.get_future());
    ASSERT_EQ(Error::CANCELED, mCallback->mError);
}

TEST_F(FakeFaceEngineTest, AuthenticateFailedForUnEnrolled) {
    Face::cfg().setopt<OptIntVec>("enrollments", {3});
    Face::cfg().set<std::int32_t>("enrollment_hit", 100);
    mEngine.authenticateImpl(mCallback.get(), 0 /* operationId*/, mCancel.get_future());
    ASSERT_EQ(Error::TIMEOUT, mCallback->mError);
    ASSERT_TRUE(mCallback->mAuthenticateFailed);
}

TEST_F(FakeFaceEngineTest, DetectInteraction) {
    Face::cfg().setopt<OptIntVec>("enrollments", {100});
    Face::cfg().set<std::int32_t>("enrollment_hit", 100);
    ASSERT_EQ(0, mCallback->mInteractionDetectedCount);
    mEngine.detectInteractionImpl(mCallback.get(), mCancel.get_future());
    ASSERT_EQ(1, mCallback->mInteractionDetectedCount);
}

TEST_F(FakeFaceEngineTest, DetectInteractionCancel) {
    Face::cfg().setopt<OptIntVec>("enrollments", {100});
    Face::cfg().set<std::int32_t>("enrollment_hit", 100);
    mCancel.set_value();
    mEngine.detectInteractionImpl(mCallback.get(), mCancel.get_future());
    ASSERT_EQ(Error::CANCELED, mCallback->mError);
}

TEST_F(FakeFaceEngineTest, GetFeatureEmpty) {
    mEngine.getFeaturesImpl(mCallback.get());
    ASSERT_TRUE(mCallback->mFeatures.empty());
}

TEST_F(FakeFaceEngineTest, SetFeature) {
    Face::cfg().setopt<OptIntVec>("enrollments", {1});
    keymaster::HardwareAuthToken hat{.mac = {2, 4}};
    mEngine.setFeatureImpl(mCallback.get(), hat, Feature::REQUIRE_ATTENTION, true);
    auto features = mCallback->mFeatures;
    ASSERT_TRUE(features.empty());
    ASSERT_EQ(Feature::REQUIRE_ATTENTION, mCallback->mLastFeatureSet);

    mEngine.getFeaturesImpl(mCallback.get());
    features = mCallback->mFeatures;
    ASSERT_FALSE(features.empty());
    ASSERT_NE(features.end(),
              std::find(features.begin(), features.end(), Feature::REQUIRE_ATTENTION));
}

TEST_F(FakeFaceEngineTest, ToggleFeature) {
    Face::cfg().setopt<OptIntVec>("enrollments", {1});
    keymaster::HardwareAuthToken hat{.mac = {2, 4}};
    mEngine.setFeatureImpl(mCallback.get(), hat, Feature::REQUIRE_ATTENTION, true);
    mEngine.getFeaturesImpl(mCallback.get());
    auto features = mCallback->mFeatures;
    ASSERT_FALSE(features.empty());
    ASSERT_NE(features.end(),
              std::find(features.begin(), features.end(), Feature::REQUIRE_ATTENTION));

    mEngine.setFeatureImpl(mCallback.get(), hat, Feature::REQUIRE_ATTENTION, false);
    mEngine.getFeaturesImpl(mCallback.get());
    features = mCallback->mFeatures;
    ASSERT_TRUE(features.empty());
}

TEST_F(FakeFaceEngineTest, TurningOffNonExistentFeatureDoesNothing) {
    Face::cfg().setopt<OptIntVec>("enrollments", {1});
    keymaster::HardwareAuthToken hat{.mac = {2, 4}};
    mEngine.setFeatureImpl(mCallback.get(), hat, Feature::REQUIRE_ATTENTION, false);
    mEngine.getFeaturesImpl(mCallback.get());
    auto features = mCallback->mFeatures;
    ASSERT_TRUE(features.empty());
}

TEST_F(FakeFaceEngineTest, SetMultipleFeatures) {
    Face::cfg().setopt<OptIntVec>("enrollments", {1});
    keymaster::HardwareAuthToken hat{.mac = {2, 4}};
    mEngine.setFeatureImpl(mCallback.get(), hat, Feature::REQUIRE_ATTENTION, true);
    mEngine.setFeatureImpl(mCallback.get(), hat, Feature::REQUIRE_DIVERSE_POSES, true);
    mEngine.setFeatureImpl(mCallback.get(), hat, Feature::DEBUG, true);
    mEngine.getFeaturesImpl(mCallback.get());
    auto features = mCallback->mFeatures;
    ASSERT_EQ(3, features.size());
    ASSERT_NE(features.end(),
              std::find(features.begin(), features.end(), Feature::REQUIRE_ATTENTION));
    ASSERT_NE(features.end(),
              std::find(features.begin(), features.end(), Feature::REQUIRE_DIVERSE_POSES));
    ASSERT_NE(features.end(), std::find(features.begin(), features.end(), Feature::DEBUG));
}

TEST_F(FakeFaceEngineTest, SetMultipleFeaturesAndTurnOffSome) {
    Face::cfg().setopt<OptIntVec>("enrollments", {1});
    keymaster::HardwareAuthToken hat{.mac = {2, 4}};
    mEngine.setFeatureImpl(mCallback.get(), hat, Feature::REQUIRE_ATTENTION, true);
    mEngine.setFeatureImpl(mCallback.get(), hat, Feature::REQUIRE_DIVERSE_POSES, true);
    mEngine.setFeatureImpl(mCallback.get(), hat, Feature::DEBUG, true);
    mEngine.setFeatureImpl(mCallback.get(), hat, Feature::DEBUG, false);
    mEngine.getFeaturesImpl(mCallback.get());
    auto features = mCallback->mFeatures;
    ASSERT_EQ(2, features.size());
    ASSERT_NE(features.end(),
              std::find(features.begin(), features.end(), Feature::REQUIRE_ATTENTION));
    ASSERT_NE(features.end(),
              std::find(features.begin(), features.end(), Feature::REQUIRE_DIVERSE_POSES));
    ASSERT_EQ(features.end(), std::find(features.begin(), features.end(), Feature::DEBUG));
}

TEST_F(FakeFaceEngineTest, Enumerate) {
    Face::cfg().setopt<OptIntVec>("enrollments", {120, 3});
    mEngine.enumerateEnrollmentsImpl(mCallback.get());
    auto enrolls = mCallback->mLastEnrollmentsEnumerated;
    ASSERT_FALSE(enrolls.empty());
    ASSERT_NE(enrolls.end(), std::find(enrolls.begin(), enrolls.end(), 120));
    ASSERT_NE(enrolls.end(), std::find(enrolls.begin(), enrolls.end(), 3));
}

TEST_F(FakeFaceEngineTest, RemoveEnrollments) {
    Face::cfg().setopt<OptIntVec>("enrollments", {120, 3, 100});
    mEngine.removeEnrollmentsImpl(mCallback.get(), {120, 100});
    mEngine.enumerateEnrollmentsImpl(mCallback.get());
    auto enrolls = mCallback->mLastEnrollmentsEnumerated;
    ASSERT_FALSE(enrolls.empty());
    ASSERT_EQ(enrolls.end(), std::find(enrolls.begin(), enrolls.end(), 120));
    ASSERT_NE(enrolls.end(), std::find(enrolls.begin(), enrolls.end(), 3));
    ASSERT_EQ(enrolls.end(), std::find(enrolls.begin(), enrolls.end(), 100));
}

TEST_F(FakeFaceEngineTest, ResetLockoutWithAuth) {
    Face::cfg().set<bool>("lockout", true);
    Face::cfg().setopt<OptIntVec>("enrollments", {33});
    Face::cfg().set<std::int32_t>("enrollment_hit", 33);
    auto cancelFuture = mCancel.get_future();
    mEngine.authenticateImpl(mCallback.get(), 0 /* operationId*/, cancelFuture);

    ASSERT_TRUE(mCallback->mLockoutPermanent);

    mEngine.resetLockoutImpl(mCallback.get(), {} /* hat */);
    ASSERT_FALSE(mCallback->mLockoutPermanent);
    Face::cfg().set<std::int32_t>("enrollment_hit", 33);
    mEngine.authenticateImpl(mCallback.get(), 0 /* operationId*/, cancelFuture);
    ASSERT_EQ(33, mCallback->mLastAuthenticated);
    ASSERT_FALSE(mCallback->mAuthenticateFailed);
}

TEST_F(FakeFaceEngineTest, LatencyDefault) {
    Face::cfg().setopt<OptIntVec>("operation_detect_interaction_latency", {});
    ASSERT_EQ(DEFAULT_LATENCY, mEngine.getLatency(Face::cfg().getopt<OptIntVec>(
                                       "operation_detect_interaction_latency")));
}

TEST_F(FakeFaceEngineTest, LatencyFixed) {
    Face::cfg().setopt<OptIntVec>("operation_detect_interaction_latency", {10});
    ASSERT_EQ(10, mEngine.getLatency(
                          Face::cfg().getopt<OptIntVec>("operation_detect_interaction_latency")));
}

TEST_F(FakeFaceEngineTest, LatencyRandom) {
    Face::cfg().setopt<OptIntVec>("operation_detect_interaction_latency", {1, 1000});
    std::set<int32_t> latencySet;
    for (int i = 0; i < 100; i++) {
        auto x = mEngine.getLatency(
                Face::cfg().getopt<OptIntVec>("operation_detect_interaction_latency"));
        ASSERT_TRUE(x >= 1 && x <= 1000);
        latencySet.insert(x);
    }
    ASSERT_TRUE(latencySet.size() > 95);  // unique values
}

}  // namespace aidl::android::hardware::biometrics::face