/*
 *
 * Copyright 2020, 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 "include/KeyMintAidlUtils.h"

namespace aidl {
namespace android {
namespace hardware {
namespace keymint {

using namespace ::keymaster;

vector<uint8_t> authToken2AidlVec(const HardwareAuthToken& token) {
    static_assert(1 /* version size */ + sizeof(token.challenge) + sizeof(token.userId) +
                          sizeof(token.authenticatorId) + sizeof(token.authenticatorType) +
                          sizeof(token.timestamp) + 32 /* HMAC size */
                      == sizeof(hw_auth_token_t),
                  "HardwareAuthToken content size does not match hw_auth_token_t size");

    vector<uint8_t> result;

    if (token.mac.size() <= 32) return result;

    result.resize(sizeof(hw_auth_token_t));
    auto pos = result.begin();
    *pos++ = 0;  // Version byte
    pos = copy_bytes_to_iterator(token.challenge, pos);
    pos = copy_bytes_to_iterator(token.userId, pos);
    pos = copy_bytes_to_iterator(token.authenticatorId, pos);
    pos = copy_bytes_to_iterator(token.authenticatorType, pos);
    pos = copy_bytes_to_iterator(token.timestamp, pos);
    pos = std::copy(token.mac.data(), token.mac.data() + token.mac.size(), pos);

    return result;
}

// TODO(seleneh): This needs to be modified depends on how aidl support for union came out to
// be.
vector<KeyParameter> kmParamSet2Aidl(const keymaster_key_param_set_t& set) {
    vector<KeyParameter> result;
    if (set.length == 0 || set.params == nullptr) return result;

    result.resize(set.length);
    keymaster_key_param_t* params = set.params;
    for (size_t i = 0; i < set.length; ++i) {
        auto tag = params[i].tag;
        result[i].tag = legacy_enum_conversion(tag);
        switch (typeFromTag(tag)) {
        case KM_ENUM:
        case KM_ENUM_REP:
            result[i].integer = params[i].enumerated;
            break;
        case KM_UINT:
        case KM_UINT_REP:
            result[i].integer = params[i].integer;
            break;
        case KM_ULONG:
        case KM_ULONG_REP:
            result[i].longInteger = params[i].long_integer;
            break;
        case KM_DATE:
            result[i].longInteger = params[i].date_time;
            break;
        case KM_BOOL:
            result[i].boolValue = params[i].boolean;
            break;
        case KM_BIGNUM:
        case KM_BYTES:
            result[i].blob.assign(params[i].blob.data,
                                  params[i].blob.data + params[i].blob.data_length);
            break;
        case KM_INVALID:
        default:
            params[i].tag = KM_TAG_INVALID;
            /* just skip */
            break;
        }
    }
    return result;
}

// TODO(seleneh): This needs to be modified depends on how aidl support for union came out to
// be.
keymaster_key_param_set_t aidlKeyParams2Km(const vector<KeyParameter>& keyParams) {
    keymaster_key_param_set_t set;

    set.params = new keymaster_key_param_t[keyParams.size()];
    set.length = keyParams.size();

    for (size_t i = 0; i < keyParams.size(); ++i) {
        auto tag = legacy_enum_conversion(keyParams[i].tag);
        switch (typeFromTag(tag)) {
        case KM_ENUM:
        case KM_ENUM_REP:
            set.params[i] = keymaster_param_enum(tag, keyParams[i].integer);
            break;
        case KM_UINT:
        case KM_UINT_REP:
            set.params[i] = keymaster_param_int(tag, keyParams[i].integer);
            break;
        case KM_ULONG:
        case KM_ULONG_REP:
            set.params[i] = keymaster_param_long(tag, keyParams[i].longInteger);
            break;
        case KM_DATE:
            set.params[i] = keymaster_param_date(tag, keyParams[i].longInteger);
            break;
        case KM_BOOL:
            if (keyParams[i].boolValue)
                set.params[i] = keymaster_param_bool(tag);
            else
                set.params[i].tag = KM_TAG_INVALID;
            break;
        case KM_BIGNUM:
        case KM_BYTES:
            set.params[i] =
                keymaster_param_blob(tag, keyParams[i].blob.data(), keyParams[i].blob.size());
            break;
        case KM_INVALID:
        default:
            set.params[i].tag = KM_TAG_INVALID;
            /* just skip */
            break;
        }
    }

    return set;
}

}  // namespace keymint
}  // namespace hardware
}  // namespace android
}  // namespace aidl