/*
 *  Copyright (c) 2016 - 2019 Samsung Electronics Co., Ltd All Rights Reserved
 *
 *  Contact: Kyungwook Tak <k.tak@samsung.com>
 *
 *  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
 *
 * @file        test_key-provider.cpp
 * @author      Kyungwook Tak (k.tak@samsung.com)
 * @version
 * @brief
 */
#define BOOST_TEST_MODULE KEY_MANAGER_TEST
#include <boost/test/unit_test.hpp>
#include <exception.h>
#include <key-provider.h>
#include <test_common.h>
#include <iostream>

const CKM::Password PASSWORD = "12345TIZEN12345AAAAAAAAA";
const CKM::Password INCORRECT_PASSWORD = "AAAAAAAAAAAAAAAAAAAAA";
const CKM::Password NEW_PASSWORD = "NEW12345TIZEN12345NEW";

const std::string USERNAME_SHORT = "AB";
const std::string USERNAME_LONG = "SOFTWARE_CENTER_SYSTEM_SW_LAB";
const std::string CLIENT_ID_1 = "SAMPLE_CLIENT_ID_1";
const std::string CLIENT_ID_2 = "SAMPLE_CLIENT_ID_2";

extern bool isLibInitialized;

BOOST_AUTO_TEST_SUITE(KEY_PROVIDER_TEST)
BOOST_AUTO_TEST_CASE(KeyDomainKEK)
{
	BOOST_REQUIRE_MESSAGE(isLibInitialized,
						  "Library is not initialized!");
	CKM::KeyProvider keyProvider;
	CKM::RawBuffer rb_test;
	BOOST_REQUIRE_NO_THROW(rb_test =
							   CKM::KeyProvider::generateDomainKEK(USERNAME_LONG, PASSWORD));
	BOOST_REQUIRE_NO_THROW(keyProvider = CKM::KeyProvider(rb_test, PASSWORD));
	BOOST_REQUIRE_MESSAGE(keyProvider.isInitialized(),
						  "KeyProvider created, but uninitialized");
}

BOOST_AUTO_TEST_CASE(KeyDomainKekInvalidPassword)
{
	BOOST_REQUIRE_MESSAGE(isLibInitialized,
						  "Library is not initialized!");
	CKM::KeyProvider keyProvider;
	CKM::RawBuffer rb_test;
	BOOST_REQUIRE_NO_THROW(rb_test =
							   CKM::KeyProvider::generateDomainKEK(USERNAME_LONG, PASSWORD));
	BOOST_REQUIRE_THROW(keyProvider = CKM::KeyProvider(rb_test, INCORRECT_PASSWORD),
						CKM::Exc::AuthenticationFailed);
	BOOST_REQUIRE_MESSAGE(!keyProvider.isInitialized(),
						  "KeyProvider not created, but initialized");
}

BOOST_AUTO_TEST_CASE(KeygetPureDomainKEK)
{
	BOOST_REQUIRE_MESSAGE(isLibInitialized,
						  "Library is not initialized!");
	CKM::KeyProvider keyProvider;
	CKM::RawBuffer rb_test;
	BOOST_REQUIRE_NO_THROW(rb_test =
							   CKM::KeyProvider::generateDomainKEK(USERNAME_LONG, PASSWORD));
	BOOST_REQUIRE_NO_THROW(keyProvider = CKM::KeyProvider(rb_test, PASSWORD));
	BOOST_REQUIRE_MESSAGE(keyProvider.isInitialized(),
						  "KeyProvider created, but uninitialized");
	BOOST_REQUIRE_NO_THROW(rb_test = keyProvider.getPureDomainKEK());
}

BOOST_AUTO_TEST_CASE(KeyGetWrappedDomainKEK)
{
	BOOST_REQUIRE_MESSAGE(isLibInitialized,
						  "Library is not initialized!");
	CKM::KeyProvider keyProvider;
	CKM::RawBuffer rb_test;
	BOOST_REQUIRE_NO_THROW(rb_test =
							   CKM::KeyProvider::generateDomainKEK(USERNAME_LONG, PASSWORD));
	BOOST_REQUIRE_NO_THROW(keyProvider = CKM::KeyProvider(rb_test, PASSWORD));
	BOOST_REQUIRE_MESSAGE(keyProvider.isInitialized(),
						  "KeyProvider created, but uninitialized");
	BOOST_REQUIRE_NO_THROW(rb_test = keyProvider.getWrappedDomainKEK(PASSWORD));
}

BOOST_AUTO_TEST_CASE(KeyGenerateDEK)
{
	BOOST_REQUIRE_MESSAGE(isLibInitialized,
						  "Library is not initialized!");
	CKM::KeyProvider keyProvider;
	CKM::RawBuffer rb_test;
	CKM::RawBuffer rb_DEK1;
	BOOST_REQUIRE_NO_THROW(rb_test =
							   CKM::KeyProvider::generateDomainKEK(USERNAME_LONG, PASSWORD));
	BOOST_REQUIRE_NO_THROW(keyProvider = CKM::KeyProvider(rb_test, PASSWORD));
	BOOST_REQUIRE_MESSAGE(keyProvider.isInitialized(),
						  "KeyProvider created, but uninitialized");
	BOOST_REQUIRE_NO_THROW(rb_DEK1 = keyProvider.generateDEK(CLIENT_ID_1));
}

BOOST_AUTO_TEST_CASE(KeyGetPureDEK)
{
	BOOST_REQUIRE_MESSAGE(isLibInitialized,
						  "Library is not initialized!");
	CKM::KeyProvider keyProvider;
	CKM::RawBuffer rb_pureDEK1;
	CKM::RawBuffer rb_DEK1;
	CKM::RawBuffer rb_test;
	BOOST_REQUIRE_NO_THROW(rb_test =
							   CKM::KeyProvider::generateDomainKEK(USERNAME_LONG, PASSWORD));
	BOOST_REQUIRE_NO_THROW(keyProvider = CKM::KeyProvider(rb_test, PASSWORD));
	BOOST_REQUIRE_MESSAGE(keyProvider.isInitialized(),
						  "KeyProvider created, but uninitialized");
	BOOST_REQUIRE_NO_THROW(rb_DEK1 = keyProvider.generateDEK(CLIENT_ID_1));
	BOOST_REQUIRE_NO_THROW(rb_pureDEK1 = keyProvider.getPureDEK(rb_DEK1));
}

BOOST_AUTO_TEST_CASE(KeyReencrypt)
{
	BOOST_REQUIRE_MESSAGE(isLibInitialized,
						  "Library is not initialized!");
	CKM::RawBuffer rb_test;
	BOOST_REQUIRE_NO_THROW(rb_test =
							   CKM::KeyProvider::generateDomainKEK(USERNAME_LONG, PASSWORD));
	BOOST_REQUIRE_NO_THROW(CKM::KeyProvider::reencrypt(rb_test, PASSWORD,
						   NEW_PASSWORD));
}

BOOST_AUTO_TEST_CASE(KeyReencrypt_incorrect_password)
{
	BOOST_REQUIRE_MESSAGE(isLibInitialized,
						  "Library is not initialized!");
	CKM::RawBuffer rb_test;
	BOOST_REQUIRE_NO_THROW(rb_test =
							   CKM::KeyProvider::generateDomainKEK(USERNAME_LONG, PASSWORD));
	BOOST_REQUIRE_THROW((rb_test = CKM::KeyProvider::reencrypt(rb_test,
								   INCORRECT_PASSWORD,
								   NEW_PASSWORD)), CKM::Exc::AuthenticationFailed);
}

BOOST_AUTO_TEST_CASE(KeyGetPureDEK_after_reencrypt)
{
	BOOST_REQUIRE_MESSAGE(isLibInitialized,
						  "Library is not initialized!");
	CKM::KeyProvider keyProvider;
	CKM::RawBuffer rb_DEK1;
	CKM::RawBuffer rb_test;
	BOOST_REQUIRE_NO_THROW(rb_test =
							   CKM::KeyProvider::generateDomainKEK(USERNAME_LONG, PASSWORD));
	BOOST_REQUIRE_NO_THROW(keyProvider = CKM::KeyProvider(rb_test, PASSWORD));
	BOOST_REQUIRE_NO_THROW(rb_DEK1 = keyProvider.generateDEK(CLIENT_ID_1));
	BOOST_REQUIRE_NO_THROW(keyProvider.getPureDEK(rb_DEK1));
}

BOOST_AUTO_TEST_CASE(wrapped_container)
{
	CKM::WrappedKeyAndInfoContainer wrappedContainer;

	auto salt = createRandom(20);
	BOOST_REQUIRE_NO_THROW(wrappedContainer.setKeyInfoSalt(salt.data(), salt.size()));
	BOOST_REQUIRE_NO_THROW(wrappedContainer.setKeyInfoClient("key_info_client"));

	BOOST_REQUIRE_THROW(wrappedContainer.setKeyInfoClient("key_info_client_waaaaay_too_long"),
	                    CKM::Exc::InternalError);

	CKM::WrappedKeyAndInfoContainer wrappedContainer2;
	BOOST_REQUIRE_NO_THROW(
		wrappedContainer2.setKeyInfo(&wrappedContainer.getWrappedKeyAndInfo().keyInfo));

	BOOST_REQUIRE(
		wrappedContainer.getWrappedKeyAndInfo().keyInfo.keyLength ==
			wrappedContainer2.getWrappedKeyAndInfo().keyInfo.keyLength);
	BOOST_REQUIRE(memcmp(
		wrappedContainer.getWrappedKeyAndInfo().keyInfo.salt,
		wrappedContainer2.getWrappedKeyAndInfo().keyInfo.salt,
		sizeof(wrappedContainer.getWrappedKeyAndInfo().keyInfo.salt)) == 0);
	BOOST_REQUIRE(memcmp(
		wrappedContainer.getWrappedKeyAndInfo().keyInfo.client,
		wrappedContainer2.getWrappedKeyAndInfo().keyInfo.client,
		sizeof(wrappedContainer.getWrappedKeyAndInfo().keyInfo.client)) == 0);

	CKM::WrappedKeyAndInfo wrapped3;
	wrapped3.keyInfo.keyLength = MAX_WRAPPED_KEY_SIZE;
	BOOST_REQUIRE_NO_THROW(CKM::WrappedKeyAndInfoContainer wrappedContainer3(
		reinterpret_cast<unsigned char*>(&wrapped3)));

	wrapped3.keyInfo.keyLength++;
	BOOST_REQUIRE_THROW(CKM::WrappedKeyAndInfoContainer wrappedContainer3(
		reinterpret_cast<unsigned char*>(&wrapped3)),
	                    CKM::Exc::InternalError);

	// missing NULL termination in wrapped4.keyInfo.client
	CKM::WrappedKeyAndInfo wrapped4;
	memset(&wrapped4, 0x01, sizeof(CKM::WrappedKeyAndInfo));
	BOOST_REQUIRE_THROW(CKM::WrappedKeyAndInfoContainer wrappedContainer3(
			reinterpret_cast<unsigned char*>(&wrapped4)),
		                    CKM::Exc::InternalError);
}

BOOST_AUTO_TEST_CASE(container)
{
	CKM::KeyAndInfoContainer container;
	BOOST_REQUIRE_NO_THROW(container.setKeyInfoKeyLength(10));

	CKM::KeyAndInfoContainer container2;
	BOOST_REQUIRE_NO_THROW(container2.setKeyInfo(&container.getKeyAndInfo().keyInfo));

	BOOST_REQUIRE(
		container.getKeyAndInfo().keyInfo.keyLength ==
			container2.getKeyAndInfo().keyInfo.keyLength);
}

BOOST_AUTO_TEST_CASE(moves)
{
	CKM::KeyProvider provider;

	try {
		CKM::KeyProvider provider2(std::move(provider));
		CKM::KeyProvider provider3 = std::move(provider2);
	} catch (...) {
		BOOST_REQUIRE_MESSAGE(false, "Unknown exception on moving KeyProvider");
	}
}

BOOST_AUTO_TEST_SUITE_END()