meteepp.h

Go to the documentation of this file.

/* SPDX-License-Identifier: Apache-2.0 */
/*
 * Copyright (C) 2021-2025 Intel Corporation
 */
#ifndef _METEEPP_H_
#define _METEEPP_H_
 
#include <sstream>
#include <stdexcept>
#include <string>
#include <system_error>
#include <vector>
#include "metee.h"
 
namespace intel {
    namespace security {


        static class metee_category_t : public std::error_category {
        public:
            virtual const char* name() const noexcept { return "MeTee"; }
            virtual std::string message(int ev) const {
#define TEE_ERR_STATE(state) case TEE_##state: return #state
                switch (ev) {
                    TEE_ERR_STATE(SUCCESS);
                    TEE_ERR_STATE(INTERNAL_ERROR);
                    TEE_ERR_STATE(DEVICE_NOT_FOUND);
                    TEE_ERR_STATE(DEVICE_NOT_READY);
                    TEE_ERR_STATE(INVALID_PARAMETER);
                    TEE_ERR_STATE(UNABLE_TO_COMPLETE_OPERATION);
                    TEE_ERR_STATE(TIMEOUT);
                    TEE_ERR_STATE(NOTSUPPORTED);
                    TEE_ERR_STATE(CLIENT_NOT_FOUND);
                    TEE_ERR_STATE(BUSY);
                    TEE_ERR_STATE(DISCONNECTED);
                    TEE_ERR_STATE(INSUFFICIENT_BUFFER);
                    TEE_ERR_STATE(PERMISSION_DENIED);
                default:
                    return std::to_string(ev);
                }
#undef TEE_ERR_STATE
            }
        } metee_category;

        class metee_exception : public std::system_error
        {
        public:
            metee_exception(const std::string& what, int err = TEE_INTERNAL_ERROR) : std::system_error(err, metee_category, what) {}
            metee_exception(int err, const std::error_category& cat) : std::system_error(err, cat) {}
            metee_exception(int err, const std::error_category& cat, const std::string& what)
                : std::system_error(err, cat, what) {}

            virtual ~metee_exception() noexcept {}
        };

        DEFINE_GUID(METEE_GUID_ZERO,
            0x00000000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);

        class metee
        {
        public:
            metee() : metee(METEE_GUID_ZERO) {}

            metee(uint32_t log_level, TeeLogCallback2 log_callback) : metee(METEE_GUID_ZERO, log_level, log_callback) {}

            metee(const GUID& guid)
            {
                TEESTATUS status = TeeInit(&_handle, &guid, nullptr);
                if (!TEE_IS_SUCCESS(status)) {
                    throw metee_exception("Init failed", status);
                }
            }

            metee(const GUID& guid, uint32_t log_level) : metee(guid, log_level, static_cast<TeeLogCallback2>(nullptr)) {}

            metee(const GUID& guid, uint32_t log_level, TeeLogCallback log_callback) :
                metee(guid, { tee_device_address::TEE_DEVICE_TYPE_NONE , nullptr }, log_level, log_callback) {}

            metee(const GUID& guid, uint32_t log_level, TeeLogCallback2 log_callback) :
                metee(guid, { tee_device_address::TEE_DEVICE_TYPE_NONE , nullptr }, log_level, log_callback) {}

            metee(const GUID& guid, const struct tee_device_address& device, uint32_t log_level) :
                metee(guid, device, log_level, static_cast<TeeLogCallback2>(nullptr)) {}

            metee(const GUID &guid, const struct tee_device_address &device, uint32_t log_level, TeeLogCallback log_callback)
            {
                TEESTATUS status = TeeInitFull(&_handle, &guid, device, log_level, log_callback);
                if (!TEE_IS_SUCCESS(status)) {
                    throw metee_exception("Init failed", status);
                }
            }

            metee(const GUID& guid, const struct tee_device_address& device, uint32_t log_level, TeeLogCallback2 log_callback)
            {
                TEESTATUS status = TeeInitFull2(&_handle, &guid, device, log_level, log_callback);
                if (!TEE_IS_SUCCESS(status)) {
                    throw metee_exception("Init failed", status);
                }
            }

            metee(const metee& other) = delete;

            metee(metee&& other) noexcept : _handle(other._handle)
            {
                other._handle.handle = nullptr;
            }

            metee& operator=(const metee& other) = delete;

            metee& operator=(metee&& other) noexcept
            {
                TeeDisconnect(&_handle);
                _handle = other._handle;
                other._handle.handle = nullptr;
                return *this;
            }

            virtual ~metee()
            {
                TeeDisconnect(&_handle);
            }

            void cancel_io()
            {
                TeeCancelIO(&_handle);
            }

            void connect()
            {
                TEESTATUS status;
 
                status = TeeConnect(&_handle);
                if (!TEE_IS_SUCCESS(status)) {
                    throw metee_exception("Connect failed", status);
                }
            }

            std::vector<uint8_t> read(uint32_t timeout)
            {
                TEESTATUS status;
                size_t size = 0;
                std::vector<uint8_t> buffer(max_msg_len());
 
                status = TeeRead(&_handle, buffer.data(), buffer.size(), &size, timeout);
                if (!TEE_IS_SUCCESS(status)) {
                    throw metee_exception("Read failed", status);
                }
 
                buffer.resize(size);
                return std::move(buffer);
            }

            size_t write(const std::vector<uint8_t> &buffer, uint32_t timeout)
            {
                TEESTATUS status;
                size_t size = 0;
 
                status = TeeWrite(&_handle, buffer.data(), buffer.size(), &size, timeout);
                if (!TEE_IS_SUCCESS(status)) {
                    throw metee_exception("Write failed", status);
                }
 
                return size;
            }

            uint32_t fw_status(uint32_t fwStatusNum)
            {
                TEESTATUS status;
                uint32_t fwStatus = 0;
 
                status = TeeFWStatus(&_handle, fwStatusNum, &fwStatus);
                if (!TEE_IS_SUCCESS(status)) {
                    throw metee_exception("FWStatus failed", status);
                }
 
                return fwStatus;
            }

            uint32_t trc()
            {
                TEESTATUS status;
                uint32_t trc_val = 0;
 
                status = TeeGetTRC(&_handle, &trc_val);
                if (!TEE_IS_SUCCESS(status)) {
                    throw metee_exception("GetTRC failed", status);
                }
 
                return trc_val;
            }

            std::string kind()
            {
                TEESTATUS status;
                const size_t KIND_SIZE = 32;
                char kind[KIND_SIZE];
                size_t kind_size = KIND_SIZE;
 
                status = TeeGetKind(&_handle, kind, &kind_size);
                if (!TEE_IS_SUCCESS(status)) {
                    throw metee_exception("TeeGetKind failed", status);
                }
 
                return kind;
            }

            uint32_t log_level(uint32_t log_level)
            {
                return TeeSetLogLevel(&_handle, log_level);
            }

            uint32_t log_level()
            {
                return TeeGetLogLevel(&_handle);
            }

            void log_callback(TeeLogCallback log_callback)
            {
                TeeSetLogCallback(&_handle, log_callback);
            }

            uint32_t max_msg_len()
            {
                return TeeGetMaxMsgLen(&_handle);
            }

            uint8_t protocol_ver()
            {
                return TeeGetProtocolVer(&_handle);
            }

            TEE_DEVICE_HANDLE device_handle()
            {
                return TeeGetDeviceHandle(&_handle);
            }

            std::string driver_version()
            {
                TEESTATUS status;
                teeDriverVersion_t driverVersion = { 0 };
 
                status = ::GetDriverVersion(&_handle, &driverVersion);
                if (!TEE_IS_SUCCESS(status)) {
                    throw metee_exception("GetDriverVersion failed", status);
                }
 
                std::stringstream ss;
                ss << driverVersion.major << "."
                    << driverVersion.minor << "."
                    << driverVersion.hotfix << "."
                    << driverVersion.build;
                return ss.str();
            }
 
        private:
            _TEEHANDLE _handle; 
        };
    } // namespace security
} // namespace intel
#endif // _METEEPP_H_