Keymaster.h

   1 /*
   2  * Copyright (C) 2016 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #ifndef ANDROID_VOLD_KEYMASTER_H
  18 #define ANDROID_VOLD_KEYMASTER_H
  19
  20 #include "KeyBuffer.h"
  21
  22 #include <memory>
  23 #include <string>
  24 #include <utility>
  25
  26 #include <android-base/macros.h>
  27 #include <keymasterV4_0/Keymaster.h>
  28 #include <keymasterV4_0/authorization_set.h>
  29
  30 namespace android {
  31 namespace vold {
  32
  33 namespace km = ::android::hardware::keymaster::V4_0;
  34 using KmDevice = km::support::Keymaster;
  35
  36 // C++ wrappers to the Keymaster hidl interface.
  37 // This is tailored to the needs of KeyStorage, but could be extended to be
  38 // a more general interface.
  39
  40 // Wrapper for a Keymaster operation handle representing an
  41 // ongoing Keymaster operation.  Aborts the operation
  42 // in the destructor if it is unfinished. Methods log failures
  43 // to LOG(ERROR).
  44 class KeymasterOperation {
  45   public:
  46     ~KeymasterOperation();
  47     // Is this instance valid? This is false if creation fails, and becomes
  48     // false on finish or if an update fails.
  49     explicit operator bool() { return mError == km::ErrorCode::OK; }
  50     km::ErrorCode errorCode() { return mError; }
  51     // Call "update" repeatedly until all of the input is consumed, and
  52     // concatenate the output. Return true on success.
  53     template <class TI, class TO>
  54     bool updateCompletely(TI& input, TO* output) {
  55         if (output) output->clear();
  56         return updateCompletely(input.data(), input.size(), [&](const char* b, size_t n) {
  57             if (output) std::copy(b, b + n, std::back_inserter(*output));
  58         });
  59     }
  60
  61     // Finish and write the output to this string, unless pointer is null.
  62     bool finish(std::string* output);
  63     // Move constructor
  64     KeymasterOperation(KeymasterOperation&& rhs) { *this = std::move(rhs); }
  65     // Construct an object in an error state for error returns
  66     KeymasterOperation() : mDevice{nullptr}, mOpHandle{0}, mError{km::ErrorCode::UNKNOWN_ERROR} {}
  67     // Move Assignment
  68     KeymasterOperation& operator=(KeymasterOperation&& rhs) {
  69         mDevice = rhs.mDevice;
  70         rhs.mDevice = nullptr;
  71
  72         mOpHandle = rhs.mOpHandle;
  73         rhs.mOpHandle = 0;
  74
  75         mError = rhs.mError;
  76         rhs.mError = km::ErrorCode::UNKNOWN_ERROR;
  77
  78         return *this;
  79     }
  80
  81   private:
  82     KeymasterOperation(KmDevice* d, uint64_t h)
  83         : mDevice{d}, mOpHandle{h}, mError{km::ErrorCode::OK} {}
  84     KeymasterOperation(km::ErrorCode error) : mDevice{nullptr}, mOpHandle{0}, mError{error} {}
  85
  86     bool updateCompletely(const char* input, size_t inputLen,
  87                           const std::function<void(const char*, size_t)> consumer);
  88
  89     KmDevice* mDevice;
  90     uint64_t mOpHandle;
  91     km::ErrorCode mError;
  92     DISALLOW_COPY_AND_ASSIGN(KeymasterOperation);
  93     friend class Keymaster;
  94 };
  95
  96 // Wrapper for a Keymaster device for methods that start a KeymasterOperation or are not
  97 // part of one.
  98 class Keymaster {
  99   public:
 100     Keymaster();
 101     // false if we failed to open the keymaster device.
 102     explicit operator bool() { return mDevice.get() != nullptr; }
 103     // Generate a key in the keymaster from the given params.
 104     bool generateKey(const km::AuthorizationSet& inParams, std::string* key);
 105     // If the keymaster supports it, permanently delete a key.
 106     bool deleteKey(const std::string& key);
 107     // Replace stored key blob in response to KM_ERROR_KEY_REQUIRES_UPGRADE.
 108     bool upgradeKey(const std::string& oldKey, const km::AuthorizationSet& inParams,
 109                     std::string* newKey);
 110     // Begin a new cryptographic operation, collecting output parameters if pointer is non-null
 111     KeymasterOperation begin(km::KeyPurpose purpose, const std::string& key,
 112                              const km::AuthorizationSet& inParams,
 113                              const km::HardwareAuthToken& authToken,
 114                              km::AuthorizationSet* outParams);
 115     bool isSecure();
 116
 117   private:
 118     std::unique_ptr<KmDevice> mDevice;
 119     DISALLOW_COPY_AND_ASSIGN(Keymaster);
 120     static bool hmacKeyGenerated;
 121 };
 122
 123 }  // namespace vold
 124 }  // namespace android
 125
 126 // FIXME no longer needed now cryptfs is in C++.
 127
 128 /*
 129  * The following functions provide C bindings to keymaster services
 130  * needed by cryptfs scrypt. The compatibility check checks whether
 131  * the keymaster implementation is considered secure, i.e., TEE backed.
 132  * The create_key function generates an RSA key for signing.
 133  * The sign_object function signes an object with the given keymaster
 134  * key.
 135  */
 136
 137 /* Return values for keymaster_sign_object_for_cryptfs_scrypt */
 138
 139 enum class KeymasterSignResult {
 140     ok = 0,
 141     error = -1,
 142     upgrade = -2,
 143 };
 144
 145 int keymaster_compatibility_cryptfs_scrypt();
 146 int keymaster_create_key_for_cryptfs_scrypt(uint32_t rsa_key_size, uint64_t rsa_exponent,
 147                                             uint32_t ratelimit, uint8_t* key_buffer,
 148                                             uint32_t key_buffer_size, uint32_t* key_out_size);
 149
 150 int keymaster_upgrade_key_for_cryptfs_scrypt(uint32_t rsa_key_size, uint64_t rsa_exponent,
 151                                              uint32_t ratelimit, const uint8_t* key_blob,
 152                                              size_t key_blob_size, uint8_t* key_buffer,
 153                                              uint32_t key_buffer_size, uint32_t* key_out_size);
 154
 155 KeymasterSignResult keymaster_sign_object_for_cryptfs_scrypt(
 156     const uint8_t* key_blob, size_t key_blob_size, uint32_t ratelimit, const uint8_t* object,
 157     const size_t object_size, uint8_t** signature_buffer, size_t* signature_buffer_size);
 158
 159 #endif