1 /*
2  * Copyright (C) 2020 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 #pragma once
18 
19 #include <aidl/android/hardware/security/keymint/BnKeyMintDevice.h>
20 #include <aidl/android/hardware/security/keymint/BnKeyMintOperation.h>
21 #include <aidl/android/hardware/security/keymint/ErrorCode.h>
22 #include <aidl/android/hardware/security/secureclock/BnSecureClock.h>
23 #include <aidl/android/hardware/security/sharedsecret/BnSharedSecret.h>
24 #include <aidl/android/security/compat/BnKeystoreCompatService.h>
25 #include <keymasterV4_1/Keymaster4.h>
26 #include <unordered_map>
27 #include <variant>
28 
29 #include "certificate_utils.h"
30 
31 using ::aidl::android::hardware::security::keymint::AttestationKey;
32 using ::aidl::android::hardware::security::keymint::BeginResult;
33 using ::aidl::android::hardware::security::keymint::Certificate;
34 using ::aidl::android::hardware::security::keymint::HardwareAuthToken;
35 using ::aidl::android::hardware::security::keymint::KeyCharacteristics;
36 using ::aidl::android::hardware::security::keymint::KeyCreationResult;
37 using ::aidl::android::hardware::security::keymint::KeyFormat;
38 using ::aidl::android::hardware::security::keymint::KeyMintHardwareInfo;
39 using ::aidl::android::hardware::security::keymint::KeyParameter;
40 using ::aidl::android::hardware::security::keymint::KeyPurpose;
41 using KeyMintSecurityLevel = ::aidl::android::hardware::security::keymint::SecurityLevel;
42 using V4_0_ErrorCode = ::android::hardware::keymaster::V4_0::ErrorCode;
43 using ::aidl::android::hardware::security::keymint::IKeyMintDevice;
44 using KMV1_ErrorCode = ::aidl::android::hardware::security::keymint::ErrorCode;
45 using ::aidl::android::hardware::security::secureclock::ISecureClock;
46 using ::aidl::android::hardware::security::secureclock::TimeStampToken;
47 using ::aidl::android::hardware::security::sharedsecret::ISharedSecret;
48 using ::aidl::android::hardware::security::sharedsecret::SharedSecretParameters;
49 using ::aidl::android::security::compat::BnKeystoreCompatService;
50 using ::android::hardware::keymaster::V4_1::support::Keymaster;
51 using ::ndk::ScopedAStatus;
52 
53 class OperationSlots {
54   private:
55     uint8_t mNumFreeSlots;
56     std::mutex mNumFreeSlotsMutex;
57 
58   public:
59     void setNumFreeSlots(uint8_t numFreeSlots);
60     bool claimSlot();
61     void freeSlot();
62 };
63 
64 // An abstraction for a single operation slot.
65 // This contains logic to ensure that we do not free the slot multiple times,
66 // e.g., if we call abort twice on the same operation.
67 class OperationSlot {
68   private:
69     OperationSlots* mOperationSlots;
70     bool mIsActive;
71 
72   public:
OperationSlot(OperationSlots * slots,bool isActive)73     OperationSlot(OperationSlots* slots, bool isActive)
74         : mOperationSlots(slots), mIsActive(isActive) {}
75 
76     void freeSlot();
hasSlot()77     bool hasSlot() { return mIsActive; }
78 };
79 
80 class KeyMintDevice : public aidl::android::hardware::security::keymint::BnKeyMintDevice {
81   private:
82     ::android::sp<Keymaster> mDevice;
83     OperationSlots mOperationSlots;
84 
85   public:
86     explicit KeyMintDevice(::android::sp<Keymaster>, KeyMintSecurityLevel);
87     static std::shared_ptr<KeyMintDevice> createKeyMintDevice(KeyMintSecurityLevel securityLevel);
88 
89     ScopedAStatus getHardwareInfo(KeyMintHardwareInfo* _aidl_return) override;
90     ScopedAStatus addRngEntropy(const std::vector<uint8_t>& in_data) override;
91     ScopedAStatus generateKey(const std::vector<KeyParameter>& in_keyParams,
92                               const std::optional<AttestationKey>& in_attestationKey,
93                               KeyCreationResult* out_creationResult) override;
94     ScopedAStatus importKey(const std::vector<KeyParameter>& in_inKeyParams,
95                             KeyFormat in_inKeyFormat, const std::vector<uint8_t>& in_inKeyData,
96                             const std::optional<AttestationKey>& in_attestationKey,
97                             KeyCreationResult* out_creationResult) override;
98     ScopedAStatus importWrappedKey(const std::vector<uint8_t>& in_inWrappedKeyData,
99                                    const std::vector<uint8_t>& in_inWrappingKeyBlob,
100                                    const std::vector<uint8_t>& in_inMaskingKey,
101                                    const std::vector<KeyParameter>& in_inUnwrappingParams,
102                                    int64_t in_inPasswordSid, int64_t in_inBiometricSid,
103                                    KeyCreationResult* out_creationResult) override;
104     ScopedAStatus upgradeKey(const std::vector<uint8_t>& in_inKeyBlobToUpgrade,
105                              const std::vector<KeyParameter>& in_inUpgradeParams,
106                              std::vector<uint8_t>* _aidl_return) override;
107     ScopedAStatus deleteKey(const std::vector<uint8_t>& in_inKeyBlob) override;
108     ScopedAStatus deleteAllKeys() override;
109     ScopedAStatus destroyAttestationIds() override;
110     ScopedAStatus begin(KeyPurpose in_inPurpose, const std::vector<uint8_t>& in_inKeyBlob,
111                         const std::vector<KeyParameter>& in_inParams,
112                         const std::optional<HardwareAuthToken>& in_inAuthToken,
113                         BeginResult* _aidl_return) override;
114     ScopedAStatus deviceLocked(bool passwordOnly,
115                                const std::optional<TimeStampToken>& timestampToken) override;
116     ScopedAStatus earlyBootEnded() override;
117 
118     ScopedAStatus convertStorageKeyToEphemeral(const std::vector<uint8_t>& storageKeyBlob,
119                                                std::vector<uint8_t>* ephemeralKeyBlob) override;
120 
121     ScopedAStatus
122     getKeyCharacteristics(const std::vector<uint8_t>& storageKeyBlob,
123                           const std::vector<uint8_t>& appId, const std::vector<uint8_t>& appData,
124                           std::vector<KeyCharacteristics>* keyCharacteristics) override;
125 
126     // These are public to allow testing code to use them directly.
127     // This class should not be used publicly anyway.
128     std::variant<std::vector<Certificate>, KMV1_ErrorCode>
129     getCertificate(const std::vector<KeyParameter>& keyParams, const std::vector<uint8_t>& keyBlob);
130 
131     void setNumFreeSlots(uint8_t numFreeSlots);
132 
133   private:
134     std::optional<KMV1_ErrorCode> signCertificate(const std::vector<KeyParameter>& keyParams,
135                                                   const std::vector<uint8_t>& keyBlob, X509* cert);
136     KeyMintSecurityLevel securityLevel_;
137 
138     // Software-based KeyMint device used to implement ECDH.
139     std::shared_ptr<IKeyMintDevice> softKeyMintDevice_;
140 };
141 
142 class KeyMintOperation : public aidl::android::hardware::security::keymint::BnKeyMintOperation {
143   public:
KeyMintOperation(::android::sp<Keymaster> device,uint64_t operationHandle,OperationSlots * slots,bool isActive)144     KeyMintOperation(::android::sp<Keymaster> device, uint64_t operationHandle,
145                      OperationSlots* slots, bool isActive)
146         : mDevice(device), mOperationHandle(operationHandle), mOperationSlot(slots, isActive) {}
147     ~KeyMintOperation();
148 
149     ScopedAStatus updateAad(const std::vector<uint8_t>& input,
150                             const std::optional<HardwareAuthToken>& authToken,
151                             const std::optional<TimeStampToken>& timestampToken) override;
152 
153     ScopedAStatus update(const std::vector<uint8_t>& input,
154                          const std::optional<HardwareAuthToken>& authToken,
155                          const std::optional<TimeStampToken>& timestampToken,
156                          std::vector<uint8_t>* output) override;
157 
158     ScopedAStatus finish(const std::optional<std::vector<uint8_t>>& input,
159                          const std::optional<std::vector<uint8_t>>& signature,
160                          const std::optional<HardwareAuthToken>& authToken,
161                          const std::optional<TimeStampToken>& timeStampToken,
162                          const std::optional<std::vector<uint8_t>>& confirmationToken,
163                          std::vector<uint8_t>* output) override;
164 
165     ScopedAStatus abort();
166 
167   private:
168     /**
169      * Sets mUpdateBuffer to the given value.
170      * @param data
171      */
172     void setUpdateBuffer(std::vector<uint8_t> data);
173     /**
174      * If mUpdateBuffer is not empty, suffix is appended to mUpdateBuffer, and a reference to
175      * mUpdateBuffer is returned. Otherwise a reference to suffix is returned.
176      * @param suffix
177      * @return
178      */
179     const std::vector<uint8_t>& getExtendedUpdateBuffer(const std::vector<uint8_t>& suffix);
180 
181     std::vector<uint8_t> mUpdateBuffer;
182     ::android::sp<Keymaster> mDevice;
183     uint64_t mOperationHandle;
184     OperationSlot mOperationSlot;
185 };
186 
187 class SharedSecret : public aidl::android::hardware::security::sharedsecret::BnSharedSecret {
188   private:
189     ::android::sp<Keymaster> mDevice;
190 
191   public:
SharedSecret(::android::sp<Keymaster> device)192     SharedSecret(::android::sp<Keymaster> device) : mDevice(device) {}
193     static std::shared_ptr<SharedSecret> createSharedSecret(KeyMintSecurityLevel securityLevel);
194 
195     virtual ScopedAStatus getSharedSecretParameters(SharedSecretParameters* _aidl_return) override;
196     virtual ScopedAStatus computeSharedSecret(const std::vector<SharedSecretParameters>& in_params,
197                                               std::vector<uint8_t>* _aidl_return) override;
198 };
199 
200 class SecureClock : public aidl::android::hardware::security::secureclock::BnSecureClock {
201   private:
202     ::android::sp<Keymaster> mDevice;
203 
204   public:
SecureClock(::android::sp<Keymaster> device)205     SecureClock(::android::sp<Keymaster> device) : mDevice(device) {}
206     static std::shared_ptr<SecureClock> createSecureClock(KeyMintSecurityLevel securityLevel);
207 
208     ScopedAStatus generateTimeStamp(int64_t in_challenge, TimeStampToken* _aidl_return) override;
209 };
210 
211 class KeystoreCompatService : public BnKeystoreCompatService {
212   private:
213     std::unordered_map<KeyMintSecurityLevel, std::shared_ptr<IKeyMintDevice>> mDeviceCache;
214     std::unordered_map<KeyMintSecurityLevel, std::shared_ptr<ISharedSecret>> mSharedSecretCache;
215     std::shared_ptr<ISecureClock> mSecureClock;
216 
217   public:
KeystoreCompatService()218     KeystoreCompatService() {}
219     ScopedAStatus getKeyMintDevice(KeyMintSecurityLevel in_securityLevel,
220                                    std::shared_ptr<IKeyMintDevice>* _aidl_return) override;
221     ScopedAStatus getSharedSecret(KeyMintSecurityLevel in_securityLevel,
222                                   std::shared_ptr<ISharedSecret>* _aidl_return) override;
223     ScopedAStatus getSecureClock(std::shared_ptr<ISecureClock>* _aidl_return) override;
224 };
225