Remove dependency on libsoftkeymaster. am: fcc4c5c71b am: 1c550eb78f (729ea459) · Commits · e / os / android_hardware_interfaces

keymaster/4.0/support/include/keymasterV4_0/keymaster_utils.h

+3 −0

Original line number	Diff line number	Diff line
		@@ -52,6 +52,9 @@ inline static hidl_vec<uint8_t> blob2hidlVec(const std::vector<uint8_t>& blob) {
		HardwareAuthToken hidlVec2AuthToken(const hidl_vec<uint8_t>& buffer);
		hidl_vec<uint8_t> authToken2HidlVec(const HardwareAuthToken& token);

		uint32_t getOsVersion();
		uint32_t getOsPatchlevel();

		} // namespace support
		} // namespace V4_0
		} // namespace keymaster

keymaster/4.0/support/keymaster_utils.cpp

+101 −15

Original line number	Diff line number	Diff line
		@@ -14,11 +14,13 @@
		* limitations under the License.
		*/

		#include <regex.h>

		#include <android-base/properties.h>
		#include <hardware/hw_auth_token.h>
		#include <keymasterV4_0/keymaster_utils.h>

		namespace android {
		namespace hardware {
		namespace android::hardware {

		inline static bool operator<(const hidl_vec<uint8_t>& a, const hidl_vec<uint8_t>& b) {
		auto result = memcmp(a.data(), b.data(), std::min(a.size(), b.size()));
		@@ -32,8 +34,7 @@ inline static bool operator<(const hidl_array<uint8_t, SIZE>& a,
		return memcmp(a.data(), b.data(), SIZE) == -1;
		}

		namespace keymaster {
		namespace V4_0 {
		namespace keymaster::V4_0 {

		bool operator<(const HmacSharingParameters& a, const HmacSharingParameters& b) {
		return std::tie(a.seed, a.nonce) < std::tie(b.seed, b.nonce);
		@@ -109,8 +110,93 @@ HardwareAuthToken hidlVec2AuthToken(const hidl_vec<uint8_t>& buffer) {
		return token;
		}

		namespace {

		constexpr char kPlatformVersionProp[] = "ro.build.version.release";
		constexpr char kPlatformVersionRegex[] = "^([0-9]{1,2})(\\.([0-9]{1,2}))?(\\.([0-9]{1,2}))?";
		constexpr size_t kMajorVersionMatch = 1;
		constexpr size_t kMinorVersionMatch = 3;
		constexpr size_t kSubminorVersionMatch = 5;
		constexpr size_t kPlatformVersionMatchCount = kSubminorVersionMatch + 1;

		constexpr char kPlatformPatchlevelProp[] = "ro.build.version.security_patch";
		constexpr char kPlatformPatchlevelRegex[] = "^([0-9]{4})-([0-9]{2})-[0-9]{2}$";
		constexpr size_t kYearMatch = 1;
		constexpr size_t kMonthMatch = 2;
		constexpr size_t kPlatformPatchlevelMatchCount = kMonthMatch + 1;

		uint32_t match_to_uint32(const char* expression, const regmatch_t& match) {
		if (match.rm_so == -1) return 0;

		size_t len = match.rm_eo - match.rm_so;
		std::string s(expression + match.rm_so, len);
		return std::stoul(s);
		}

		std::string wait_and_get_property(const char* prop) {
		std::string prop_value;
		while (!android::base::WaitForPropertyCreation(prop))
		;
		prop_value = android::base::GetProperty(prop, "" /* default */);
		return prop_value;
		}

		} // anonymous namespace

		uint32_t getOsVersion(const char* version_str) {
		regex_t regex;
		if (regcomp(&regex, kPlatformVersionRegex, REG_EXTENDED)) {
		return 0;
		}

		regmatch_t matches[kPlatformVersionMatchCount];
		int not_match =
		regexec(&regex, version_str, kPlatformVersionMatchCount, matches, 0 /* flags */);
		regfree(&regex);
		if (not_match) {
		return 0;
		}

		uint32_t major = match_to_uint32(version_str, matches[kMajorVersionMatch]);
		uint32_t minor = match_to_uint32(version_str, matches[kMinorVersionMatch]);
		uint32_t subminor = match_to_uint32(version_str, matches[kSubminorVersionMatch]);

		return (major * 100 + minor) * 100 + subminor;
		}

		uint32_t getOsVersion() {
		std::string version = wait_and_get_property(kPlatformVersionProp);
		return getOsVersion(version.c_str());
		}

		uint32_t getOsPatchlevel(const char* patchlevel_str) {
		regex_t regex;
		if (regcomp(&regex, kPlatformPatchlevelRegex, REG_EXTENDED) != 0) {
		return 0;
		}

		regmatch_t matches[kPlatformPatchlevelMatchCount];
		int not_match =
		regexec(&regex, patchlevel_str, kPlatformPatchlevelMatchCount, matches, 0 /* flags */);
		regfree(&regex);
		if (not_match) {
		return 0;
		}

		uint32_t year = match_to_uint32(patchlevel_str, matches[kYearMatch]);
		uint32_t month = match_to_uint32(patchlevel_str, matches[kMonthMatch]);

		if (month < 1 \|\| month > 12) {
		return 0;
		}
		return year * 100 + month;
		}

		uint32_t getOsPatchlevel() {
		std::string patchlevel = wait_and_get_property(kPlatformPatchlevelProp);
		return getOsPatchlevel(patchlevel.c_str());
		}

		} // namespace support
		} // namespace V4_0
		} // namespace keymaster
		} // namespace hardware
		} // namespace android
		} // namespace keymaster::V4_0
		} // namespace android::hardware

keymaster/4.0/vts/functional/Android.bp

+4 −2

Original line number	Diff line number	Diff line
		@@ -27,7 +27,9 @@ cc_test {
		"android.hardware.keymaster@4.0",
		"libcrypto_static",
		"libkeymaster4support",
		"libsoftkeymasterdevice",
		],
		test_suites: ["general-tests", "vts-core"],
		test_suites: [
		"general-tests",
		"vts-core",
		],
		}

keymaster/4.0/vts/functional/KeymasterHidlTest.cpp

+4 −3

Original line number	Diff line number	Diff line
		@@ -23,6 +23,7 @@
		#include <android/hidl/manager/1.0/IServiceManager.h>

		#include <keymasterV4_0/key_param_output.h>
		#include <keymasterV4_0/keymaster_utils.h>

		namespace android {
		namespace hardware {
		@@ -56,11 +57,11 @@ void KeymasterHidlTest::InitializeKeymaster() {
		.isOk());
		}

		void KeymasterHidlTest::SetUp() {
		void KeymasterHidlTest::SetUpTestCase() {
		InitializeKeymaster();

		os_version_ = ::keymaster::GetOsVersion();
		os_patch_level_ = ::keymaster::GetOsPatchlevel();
		os_version_ = support::getOsVersion();
		os_patch_level_ = support::getOsPatchlevel();

		auto service_manager = android::hidl::manager::V1_0::IServiceManager::getService();
		ASSERT_NE(nullptr, service_manager.get());

keymaster/4.0/vts/functional/KeymasterHidlTest.h

+2 −4

Original line number	Diff line number	Diff line
		@@ -18,10 +18,8 @@

		#include <android/hardware/keymaster/4.0/IKeymasterDevice.h>
		#include <android/hardware/keymaster/4.0/types.h>
		#include <gtest/gtest.h>
		#include <hidl/GtestPrinter.h>
		#include <hidl/ServiceManagement.h>
		#include <keymaster/keymaster_configuration.h>

		#include <VtsHalHidlTargetTestBase.h>

		#include <keymasterV4_0/authorization_set.h>