| /* | |
| * | |
| * Copyright 2019, 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 "TrustyConfirmationUI.h" | |
| #include <android-base/logging.h> | |
| #include <android/hardware/confirmationui/1.0/types.h> | |
| #include <android/hardware/keymaster/4.0/types.h> | |
| #include <fcntl.h> | |
| #include <linux/input.h> | |
| #include <poll.h> | |
| #include <pthread.h> | |
| #include <secure_input/evdev.h> | |
| #include <secure_input/secure_input_device.h> | |
| #include <secure_input/secure_input_proto.h> | |
| #include <signal.h> | |
| #include <sys/ioctl.h> | |
| #include <sys/stat.h> | |
| #include <sys/types.h> | |
| #include <teeui/msg_formatting.h> | |
| #include <teeui/utils.h> | |
| #include <time.h> | |
| #include <atomic> | |
| #include <functional> | |
| #include <memory> | |
| #include <thread> | |
| #include <tuple> | |
| #include <vector> | |
| namespace android { | |
| namespace hardware { | |
| namespace confirmationui { | |
| namespace V1_0 { | |
| namespace implementation { | |
| using namespace secure_input; | |
| using ::android::trusty::confirmationui::TrustyAppError; | |
| using ::teeui::AbortMsg; | |
| using ::teeui::DeliverTestCommandMessage; | |
| using ::teeui::DeliverTestCommandResponse; | |
| using ::teeui::FetchConfirmationResult; | |
| using ::teeui::MsgString; | |
| using ::teeui::MsgVector; | |
| using ::teeui::PromptUserConfirmationMsg; | |
| using ::teeui::PromptUserConfirmationResponse; | |
| using ::teeui::ResultMsg; | |
| using ::secure_input::createSecureInput; | |
| using ::android::hardware::keymaster::V4_0::HardwareAuthToken; | |
| using ::std::tie; | |
| using TeeuiRc = ::teeui::ResponseCode; | |
| constexpr const char kTrustyDeviceName[] = "/dev/trusty-ipc-dev0"; | |
| constexpr const char kConfirmationuiAppName[] = CONFIRMATIONUI_PORT; | |
| namespace { | |
| class Finalize { | |
| private: | |
| std::function<void()> f_; | |
| public: | |
| Finalize(std::function<void()> f) : f_(f) {} | |
| ~Finalize() { | |
| if (f_) f_(); | |
| } | |
| void release() { f_ = {}; } | |
| }; | |
| ResponseCode convertRc(TeeuiRc trc) { | |
| static_assert( | |
| uint32_t(TeeuiRc::OK) == uint32_t(ResponseCode::OK) && | |
| uint32_t(TeeuiRc::Canceled) == uint32_t(ResponseCode::Canceled) && | |
| uint32_t(TeeuiRc::Aborted) == uint32_t(ResponseCode::Aborted) && | |
| uint32_t(TeeuiRc::OperationPending) == uint32_t(ResponseCode::OperationPending) && | |
| uint32_t(TeeuiRc::Ignored) == uint32_t(ResponseCode::Ignored) && | |
| uint32_t(TeeuiRc::SystemError) == uint32_t(ResponseCode::SystemError) && | |
| uint32_t(TeeuiRc::Unimplemented) == uint32_t(ResponseCode::Unimplemented) && | |
| uint32_t(TeeuiRc::Unexpected) == uint32_t(ResponseCode::Unexpected) && | |
| uint32_t(TeeuiRc::UIError) == uint32_t(ResponseCode::UIError) && | |
| uint32_t(TeeuiRc::UIErrorMissingGlyph) == uint32_t(ResponseCode::UIErrorMissingGlyph) && | |
| uint32_t(TeeuiRc::UIErrorMessageTooLong) == | |
| uint32_t(ResponseCode::UIErrorMessageTooLong) && | |
| uint32_t(TeeuiRc::UIErrorMalformedUTF8Encoding) == | |
| uint32_t(ResponseCode::UIErrorMalformedUTF8Encoding), | |
| "teeui::ResponseCode and " | |
| "::android::hardware::confirmationui::V1_0::Responsecude are out of " | |
| "sync"); | |
| return ResponseCode(trc); | |
| } | |
| teeui::UIOption convertUIOption(UIOption uio) { | |
| static_assert(uint32_t(UIOption::AccessibilityInverted) == | |
| uint32_t(teeui::UIOption::AccessibilityInverted) && | |
| uint32_t(UIOption::AccessibilityMagnified) == | |
| uint32_t(teeui::UIOption::AccessibilityMagnified), | |
| "teeui::UIOPtion and ::android::hardware::confirmationui::V1_0::UIOption " | |
| "anre out of sync"); | |
| return teeui::UIOption(uio); | |
| } | |
| inline MsgString hidl2MsgString(const hidl_string& s) { | |
| return {s.c_str(), s.c_str() + s.size()}; | |
| } | |
| template <typename T> inline MsgVector<T> hidl2MsgVector(const hidl_vec<T>& v) { | |
| return {v}; | |
| } | |
| inline MsgVector<teeui::UIOption> hidl2MsgVector(const hidl_vec<UIOption>& v) { | |
| MsgVector<teeui::UIOption> result(v.size()); | |
| for (unsigned int i = 0; i < v.size(); ++i) { | |
| result[i] = convertUIOption(v[i]); | |
| } | |
| return result; | |
| } | |
| } // namespace | |
| TrustyConfirmationUI::TrustyConfirmationUI() | |
| : listener_state_(ListenerState::None), prompt_result_(ResponseCode::Ignored) {} | |
| TrustyConfirmationUI::~TrustyConfirmationUI() { | |
| ListenerState state = listener_state_; | |
| if (state == ListenerState::SetupDone || state == ListenerState::Interactive) { | |
| abort(); | |
| } | |
| if (state != ListenerState::None) { | |
| callback_thread_.join(); | |
| } | |
| } | |
| std::tuple<TeeuiRc, MsgVector<uint8_t>, MsgVector<uint8_t>> | |
| TrustyConfirmationUI::promptUserConfirmation_(const MsgString& promptText, | |
| const MsgVector<uint8_t>& extraData, | |
| const MsgString& locale, | |
| const MsgVector<teeui::UIOption>& uiOptions) { | |
| std::unique_lock<std::mutex> stateLock(listener_state_lock_); | |
| /* | |
| * This is the main listener thread function. The listener thread life cycle | |
| * is equivalent to the life cycle of a single confirmation request. The life | |
| * cycle is devided in four phases. | |
| * * The starting phase: | |
| * * The Trusted App gets loaded and/or the connection to it gets established. | |
| * * A connection to the secure input device is established. | |
| * * The prompt is initiated. This sends all information required by the | |
| * confirmation dialog to the TA. The dialog is not yet displayed. | |
| * * An event loop is created. | |
| * * The event loop listens for user input events, fetches them from the | |
| * secure input device, and delivers them to the TA. | |
| * * All evdev devices are grabbed to give confirmationui exclusive access | |
| * to user input. | |
| * | |
| * Note: During the starting phase the hwbinder service thread is blocked and | |
| * waiting for possible Errors. If the setup phase concludes sucessfully, the | |
| * hwbinder service thread gets unblocked and returns successfully. Errors | |
| * that occur after the first phase are delivered by callback interface. | |
| * | |
| * * The 2nd phase - non interactive phase | |
| * * The event loop thread is started. | |
| * * After a grace period: | |
| * * A handshake between the secure input device SecureInput and the TA | |
| * is performed. | |
| * * The input event handler are armed to process user input events. | |
| * | |
| * * The 3rd phase - interactive phase | |
| * * We wait to any external event | |
| * * Abort | |
| * * Secure user input asserted | |
| * * Secure input delivered (for non interactive VTS testing) | |
| * * The result is fetched from the TA. | |
| * | |
| * * The 4th phase - cleanup | |
| * The cleanup phase is given by the scope of automatic variables created | |
| * in this function. The cleanup commences in reverse order of their creation. | |
| * Here is a list of more complex items in the order in which they go out of | |
| * scope | |
| * * finalizeSecureTouch - signals and joins the secure touch thread. | |
| * * eventloop - signals and joins the event loop thread. The event | |
| * handlers also own all EventDev instances which ungrab the event devices. | |
| * When the eventloop goes out of scope the EventDevs get destroyed | |
| * relinquishing the exclusive hold on the event devices. | |
| * * finalizeConfirmationPrompt - calls abort on the TA, making sure a | |
| * pending operation gets canceled. If the prompt concluded successfully this | |
| * is a spurious call but semantically a no op. | |
| * * secureInput - shuts down the connection to the secure input device | |
| * SecureInput. | |
| * * app - disconnects the TA. Since app is a shared pointer this may not | |
| * unload the app here. It is possible that more instances of the shared | |
| * pointer are held in TrustyConfirmationUI::deliverSecureInputEvent and | |
| * TrustyConfirmationUI::abort. But these instances are extremely short lived | |
| * and it is safe if they are destroyed by either. | |
| * * stateLock - unlocks the listener_state_lock_ if it happens to be held | |
| * at the time of return. | |
| */ | |
| std::tuple<TeeuiRc, MsgVector<uint8_t>, MsgVector<uint8_t>> result; | |
| TeeuiRc& rc = std::get<TeeuiRc>(result); | |
| rc = TeeuiRc::SystemError; | |
| listener_state_ = ListenerState::Starting; | |
| auto app = std::make_shared<TrustyApp>(kTrustyDeviceName, kConfirmationuiAppName); | |
| if (!app) return result; // TeeuiRc::SystemError | |
| app_ = app; | |
| auto hsBegin = [&]() -> std::tuple<TeeuiRc, Nonce> { | |
| auto [error, result] = | |
| app->issueCmd<secure_input::InputHandshake, secure_input::InputHandshakeResponse>(); | |
| auto& [rc, nCo] = result; | |
| if (error != TrustyAppError::OK || rc != TeeuiRc::OK) { | |
| LOG(ERROR) << "Failed to begin secure input handshake (" << int32_t(error) << "/" | |
| << uint32_t(rc) << ")"; | |
| rc = error != TrustyAppError::OK ? TeeuiRc::SystemError : rc; | |
| } | |
| return result; | |
| }; | |
| auto hsFinalize = [&](const Signature& sig, const Nonce& nCi) -> TeeuiRc { | |
| auto [error, finalizeResponse] = | |
| app->issueCmd<FinalizeInputSessionHandshake, FinalizeInputSessionHandshakeResponse>( | |
| nCi, sig); | |
| auto& [rc] = finalizeResponse; | |
| if (error != TrustyAppError::OK || rc != TeeuiRc::OK) { | |
| LOG(ERROR) << "Failed to finalize secure input handshake (" << int32_t(error) << "/" | |
| << uint32_t(rc) << ")"; | |
| rc = error != TrustyAppError::OK ? TeeuiRc::SystemError : rc; | |
| } | |
| return rc; | |
| }; | |
| auto deliverInput = [&](DTupKeyEvent event, | |
| const Signature& sig) -> std::tuple<TeeuiRc, InputResponse> { | |
| auto [error, result] = | |
| app->issueCmd<DeliverInputEvent, DeliverInputEventResponse>(event, sig); | |
| auto& [rc, ir] = result; | |
| if (error != TrustyAppError::OK) { | |
| LOG(ERROR) << "Failed to deliver input command"; | |
| rc = TeeuiRc::SystemError; | |
| } | |
| return result; | |
| }; | |
| std::atomic<TeeuiRc> eventRC = TeeuiRc::OperationPending; | |
| auto inputResult = [&](TeeuiRc rc) { | |
| TeeuiRc expected = TeeuiRc::OperationPending; | |
| if (eventRC.compare_exchange_strong(expected, rc)) { | |
| listener_state_condv_.notify_all(); | |
| } | |
| }; | |
| // create Secure Input device. | |
| auto secureInput = createSecureInput(hsBegin, hsFinalize, deliverInput, inputResult); | |
| if (!secureInput || !(*secureInput)) { | |
| LOG(ERROR) << "Failed to open secure input device"; | |
| return result; // TeeuiRc::SystemError; | |
| } | |
| Finalize finalizeConfirmationPrompt([app] { | |
| LOG(INFO) << "Calling abort for cleanup"; | |
| app->issueCmd<AbortMsg>(); | |
| }); | |
| // initiate prompt | |
| LOG(INFO) << "Initiating prompt"; | |
| TrustyAppError error; | |
| auto initResponse = std::tie(rc); | |
| std::tie(error, initResponse) = | |
| app->issueCmd<PromptUserConfirmationMsg, PromptUserConfirmationResponse>( | |
| promptText, extraData, locale, uiOptions); | |
| if (error == TrustyAppError::MSG_TOO_LONG) { | |
| LOG(ERROR) << "PromptUserConfirmationMsg failed: message too long"; | |
| rc = TeeuiRc::UIErrorMessageTooLong; | |
| return result; | |
| } else if (error != TrustyAppError::OK) { | |
| LOG(ERROR) << "PromptUserConfirmationMsg failed: " << int32_t(error); | |
| return result; // TeeuiRc::SystemError; | |
| } | |
| if (rc != TeeuiRc::OK) { | |
| LOG(ERROR) << "PromptUserConfirmationMsg failed: " << uint32_t(rc); | |
| return result; | |
| } | |
| LOG(INFO) << "Grabbing event devices"; | |
| EventLoop eventloop; | |
| bool grabbed = | |
| grabAllEvDevsAndRegisterCallbacks(&eventloop, [&](short flags, const EventDev& evDev) { | |
| if (!(flags & POLLIN)) return; | |
| secureInput->handleEvent(evDev); | |
| }); | |
| if (!grabbed) { | |
| rc = TeeuiRc::SystemError; | |
| return result; | |
| } | |
| abort_called_ = false; | |
| secureInputDelivered_ = false; | |
| // ############################## Start 2nd Phase ############################################# | |
| listener_state_ = ListenerState::SetupDone; | |
| stateLock.unlock(); | |
| listener_state_condv_.notify_all(); | |
| if (!eventloop.start()) { | |
| rc = TeeuiRc::SystemError; | |
| return result; | |
| } | |
| stateLock.lock(); | |
| LOG(INFO) << "going to sleep for the grace period"; | |
| auto then = std::chrono::system_clock::now() + | |
| std::chrono::milliseconds(kUserPreInputGracePeriodMillis) + | |
| std::chrono::microseconds(50); | |
| listener_state_condv_.wait_until(stateLock, then, [&]() { return abort_called_; }); | |
| LOG(INFO) << "waking up"; | |
| if (abort_called_) { | |
| LOG(ERROR) << "Abort called"; | |
| result = {TeeuiRc::Aborted, {}, {}}; | |
| return result; | |
| } | |
| LOG(INFO) << "Arming event poller"; | |
| // tell the event poller to act on received input events from now on. | |
| secureInput->start(); | |
| // ############################## Start 3rd Phase - interactive phase ######################### | |
| LOG(INFO) << "Transition to Interactive"; | |
| listener_state_ = ListenerState::Interactive; | |
| stateLock.unlock(); | |
| listener_state_condv_.notify_all(); | |
| stateLock.lock(); | |
| listener_state_condv_.wait(stateLock, [&]() { | |
| return eventRC != TeeuiRc::OperationPending || abort_called_ || secureInputDelivered_; | |
| }); | |
| LOG(INFO) << "Listener waking up"; | |
| if (abort_called_) { | |
| LOG(ERROR) << "Abort called"; | |
| result = {TeeuiRc::Aborted, {}, {}}; | |
| return result; | |
| } | |
| if (!secureInputDelivered_) { | |
| if (eventRC != TeeuiRc::OK) { | |
| LOG(ERROR) << "Bad input response"; | |
| result = {eventRC, {}, {}}; | |
| return result; | |
| } | |
| } | |
| stateLock.unlock(); | |
| LOG(INFO) << "Fetching Result"; | |
| std::tie(error, result) = app->issueCmd<FetchConfirmationResult, ResultMsg>(); | |
| LOG(INFO) << "Result yields " << int32_t(error) << "/" << uint32_t(rc); | |
| if (error != TrustyAppError::OK) { | |
| result = {TeeuiRc::SystemError, {}, {}}; | |
| } | |
| return result; | |
| // ############################## Start 4th Phase - cleanup ################################## | |
| } | |
| // Methods from ::android::hardware::confirmationui::V1_0::IConfirmationUI | |
| // follow. | |
| Return<ResponseCode> TrustyConfirmationUI::promptUserConfirmation( | |
| const sp<IConfirmationResultCallback>& resultCB, const hidl_string& promptText, | |
| const hidl_vec<uint8_t>& extraData, const hidl_string& locale, | |
| const hidl_vec<UIOption>& uiOptions) { | |
| std::unique_lock<std::mutex> stateLock(listener_state_lock_, std::defer_lock); | |
| if (!stateLock.try_lock()) { | |
| return ResponseCode::OperationPending; | |
| } | |
| switch (listener_state_) { | |
| case ListenerState::None: | |
| break; | |
| case ListenerState::Starting: | |
| case ListenerState::SetupDone: | |
| case ListenerState::Interactive: | |
| return ResponseCode::OperationPending; | |
| case ListenerState::Terminating: | |
| callback_thread_.join(); | |
| listener_state_ = ListenerState::None; | |
| break; | |
| default: | |
| return ResponseCode::Unexpected; | |
| } | |
| assert(listener_state_ == ListenerState::None); | |
| callback_thread_ = std::thread( | |
| [this](sp<IConfirmationResultCallback> resultCB, hidl_string promptText, | |
| hidl_vec<uint8_t> extraData, hidl_string locale, hidl_vec<UIOption> uiOptions) { | |
| auto [trc, msg, token] = | |
| promptUserConfirmation_(hidl2MsgString(promptText), hidl2MsgVector(extraData), | |
| hidl2MsgString(locale), hidl2MsgVector(uiOptions)); | |
| bool do_callback = (listener_state_ == ListenerState::Interactive || | |
| listener_state_ == ListenerState::SetupDone) && | |
| resultCB; | |
| prompt_result_ = convertRc(trc); | |
| listener_state_ = ListenerState::Terminating; | |
| if (do_callback) { | |
| auto error = resultCB->result(prompt_result_, msg, token); | |
| if (!error.isOk()) { | |
| LOG(ERROR) << "Result callback failed " << error.description(); | |
| } | |
| } else { | |
| listener_state_condv_.notify_all(); | |
| } | |
| }, | |
| resultCB, promptText, extraData, locale, uiOptions); | |
| listener_state_condv_.wait(stateLock, [this] { | |
| return listener_state_ == ListenerState::SetupDone || | |
| listener_state_ == ListenerState::Interactive || | |
| listener_state_ == ListenerState::Terminating; | |
| }); | |
| if (listener_state_ == ListenerState::Terminating) { | |
| callback_thread_.join(); | |
| listener_state_ = ListenerState::None; | |
| return prompt_result_; | |
| } | |
| return ResponseCode::OK; | |
| } | |
| Return<ResponseCode> | |
| TrustyConfirmationUI::deliverSecureInputEvent(const HardwareAuthToken& secureInputToken) { | |
| ResponseCode rc = ResponseCode::Ignored; | |
| { | |
| /* | |
| * deliverSecureInputEvent is only used by the VTS test to mock human input. A correct | |
| * implementation responds with a mock confirmation token signed with a test key. The | |
| * problem is that the non interactive grace period was not formalized in the HAL spec, | |
| * so that the VTS test does not account for the grace period. (It probably should.) | |
| * This means we can only pass the VTS test if we block until the grace period is over | |
| * (SetupDone -> Interactive) before we deliver the input event. | |
| * | |
| * The true secure input is delivered by a different mechanism and gets ignored - | |
| * not queued - until the grace period is over. | |
| * | |
| */ | |
| std::unique_lock<std::mutex> stateLock(listener_state_lock_); | |
| listener_state_condv_.wait(stateLock, | |
| [this] { return listener_state_ != ListenerState::SetupDone; }); | |
| if (listener_state_ != ListenerState::Interactive) return ResponseCode::Ignored; | |
| auto sapp = app_.lock(); | |
| if (!sapp) return ResponseCode::Ignored; | |
| auto [error, response] = | |
| sapp->issueCmd<DeliverTestCommandMessage, DeliverTestCommandResponse>( | |
| static_cast<teeui::TestModeCommands>(secureInputToken.challenge)); | |
| if (error != TrustyAppError::OK) return ResponseCode::SystemError; | |
| auto& [trc] = response; | |
| if (trc != TeeuiRc::Ignored) secureInputDelivered_ = true; | |
| rc = convertRc(trc); | |
| } | |
| if (secureInputDelivered_) listener_state_condv_.notify_all(); | |
| // VTS test expect an OK response if the event was successfully delivered. | |
| // But since the TA returns the callback response now, we have to translate | |
| // Canceled into OK. Canceled is only returned if the delivered event canceled | |
| // the operation, which means that the event was successfully delivered. Thus | |
| // we return OK. | |
| if (rc == ResponseCode::Canceled) return ResponseCode::OK; | |
| return rc; | |
| } | |
| Return<void> TrustyConfirmationUI::abort() { | |
| { | |
| std::unique_lock<std::mutex> stateLock(listener_state_lock_); | |
| if (listener_state_ == ListenerState::SetupDone || | |
| listener_state_ == ListenerState::Interactive) { | |
| auto sapp = app_.lock(); | |
| if (sapp) sapp->issueCmd<AbortMsg>(); | |
| abort_called_ = true; | |
| } | |
| } | |
| listener_state_condv_.notify_all(); | |
| return Void(); | |
| } | |
| android::sp<IConfirmationUI> createTrustyConfirmationUI() { | |
| return new TrustyConfirmationUI(); | |
| } | |
| } // namespace implementation | |
| } // namespace V1_0 | |
| } // namespace confirmationui | |
| } // namespace hardware | |
| } // namespace android |