| /* |
| * Copyright (C) 2015 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. |
| */ |
| |
| #define LOG_TAG "keystore" |
| |
| #include <arpa/inet.h> |
| #include <errno.h> |
| #include <fcntl.h> |
| #include <string.h> |
| |
| #include <log/log.h> |
| |
| #include "blob.h" |
| |
| #include "keystore_utils.h" |
| |
| #include <openssl/evp.h> |
| #include <openssl/rand.h> |
| |
| #include <istream> |
| #include <ostream> |
| #include <streambuf> |
| #include <string> |
| |
| #include <android-base/logging.h> |
| |
| namespace { |
| |
| constexpr size_t kGcmIvSizeBytes = 96 / 8; |
| |
| template <typename T, void (*FreeFunc)(T*)> struct OpenSslObjectDeleter { |
| void operator()(T* p) { FreeFunc(p); } |
| }; |
| |
| #define DEFINE_OPENSSL_OBJECT_POINTER(name) \ |
| typedef OpenSslObjectDeleter<name, name##_free> name##_Delete; \ |
| typedef std::unique_ptr<name, name##_Delete> name##_Ptr; |
| |
| DEFINE_OPENSSL_OBJECT_POINTER(EVP_CIPHER_CTX); |
| |
| #if defined(__clang__) |
| #define OPTNONE __attribute__((optnone)) |
| #elif defined(__GNUC__) |
| #define OPTNONE __attribute__((optimize("O0"))) |
| #else |
| #error Need a definition for OPTNONE |
| #endif |
| |
| class ArrayEraser { |
| public: |
| ArrayEraser(uint8_t* arr, size_t size) : mArr(arr), mSize(size) {} |
| OPTNONE ~ArrayEraser() { std::fill(mArr, mArr + mSize, 0); } |
| |
| private: |
| volatile uint8_t* mArr; |
| size_t mSize; |
| }; |
| |
| /** |
| * Returns a EVP_CIPHER appropriate for the given key, based on the key's size. |
| */ |
| const EVP_CIPHER* getAesCipherForKey(const std::vector<uint8_t>& key) { |
| const EVP_CIPHER* cipher = EVP_aes_256_gcm(); |
| if (key.size() == kAes128KeySizeBytes) { |
| cipher = EVP_aes_128_gcm(); |
| } |
| return cipher; |
| } |
| |
| /* |
| * Encrypt 'len' data at 'in' with AES-GCM, using 128-bit or 256-bit key at 'key', 96-bit IV at |
| * 'iv' and write output to 'out' (which may be the same location as 'in') and 128-bit tag to |
| * 'tag'. |
| */ |
| ResponseCode AES_gcm_encrypt(const uint8_t* in, uint8_t* out, size_t len, |
| const std::vector<uint8_t>& key, const uint8_t* iv, uint8_t* tag) { |
| |
| // There can be 128-bit and 256-bit keys |
| const EVP_CIPHER* cipher = getAesCipherForKey(key); |
| |
| EVP_CIPHER_CTX_Ptr ctx(EVP_CIPHER_CTX_new()); |
| |
| EVP_EncryptInit_ex(ctx.get(), cipher, nullptr /* engine */, key.data(), iv); |
| EVP_CIPHER_CTX_set_padding(ctx.get(), 0 /* no padding needed with GCM */); |
| |
| std::unique_ptr<uint8_t[]> out_tmp(new uint8_t[len]); |
| uint8_t* out_pos = out_tmp.get(); |
| int out_len; |
| |
| EVP_EncryptUpdate(ctx.get(), out_pos, &out_len, in, len); |
| out_pos += out_len; |
| EVP_EncryptFinal_ex(ctx.get(), out_pos, &out_len); |
| out_pos += out_len; |
| if (out_pos - out_tmp.get() != static_cast<ssize_t>(len)) { |
| ALOGD("Encrypted ciphertext is the wrong size, expected %zu, got %zd", len, |
| out_pos - out_tmp.get()); |
| return ResponseCode::SYSTEM_ERROR; |
| } |
| |
| std::copy(out_tmp.get(), out_pos, out); |
| EVP_CIPHER_CTX_ctrl(ctx.get(), EVP_CTRL_GCM_GET_TAG, kGcmTagLength, tag); |
| |
| return ResponseCode::NO_ERROR; |
| } |
| |
| /* |
| * Decrypt 'len' data at 'in' with AES-GCM, using 128-bit or 256-bit key at 'key', 96-bit IV at |
| * 'iv', checking 128-bit tag at 'tag' and writing plaintext to 'out'(which may be the same |
| * location as 'in'). |
| */ |
| ResponseCode AES_gcm_decrypt(const uint8_t* in, uint8_t* out, size_t len, |
| const std::vector<uint8_t> key, const uint8_t* iv, |
| const uint8_t* tag) { |
| |
| // There can be 128-bit and 256-bit keys |
| const EVP_CIPHER* cipher = getAesCipherForKey(key); |
| |
| EVP_CIPHER_CTX_Ptr ctx(EVP_CIPHER_CTX_new()); |
| |
| EVP_DecryptInit_ex(ctx.get(), cipher, nullptr /* engine */, key.data(), iv); |
| EVP_CIPHER_CTX_set_padding(ctx.get(), 0 /* no padding needed with GCM */); |
| EVP_CIPHER_CTX_ctrl(ctx.get(), EVP_CTRL_GCM_SET_TAG, kGcmTagLength, const_cast<uint8_t*>(tag)); |
| |
| std::unique_ptr<uint8_t[]> out_tmp(new uint8_t[len]); |
| ArrayEraser out_eraser(out_tmp.get(), len); |
| uint8_t* out_pos = out_tmp.get(); |
| int out_len; |
| |
| EVP_DecryptUpdate(ctx.get(), out_pos, &out_len, in, len); |
| out_pos += out_len; |
| if (!EVP_DecryptFinal_ex(ctx.get(), out_pos, &out_len)) { |
| ALOGD("Failed to decrypt blob; ciphertext or tag is likely corrupted"); |
| return ResponseCode::VALUE_CORRUPTED; |
| } |
| out_pos += out_len; |
| if (out_pos - out_tmp.get() != static_cast<ssize_t>(len)) { |
| ALOGD("Encrypted plaintext is the wrong size, expected %zu, got %zd", len, |
| out_pos - out_tmp.get()); |
| return ResponseCode::VALUE_CORRUPTED; |
| } |
| |
| std::copy(out_tmp.get(), out_pos, out); |
| |
| return ResponseCode::NO_ERROR; |
| } |
| |
| class ArrayStreamBuffer : public std::streambuf { |
| public: |
| template <typename T, size_t size> explicit ArrayStreamBuffer(const T (&data)[size]) { |
| static_assert(sizeof(T) == 1, "Array element size too large"); |
| std::streambuf::char_type* d = const_cast<std::streambuf::char_type*>( |
| reinterpret_cast<const std::streambuf::char_type*>(&data[0])); |
| setg(d, d, d + size); |
| setp(d, d + size); |
| } |
| |
| protected: |
| pos_type seekoff(off_type off, std::ios_base::seekdir dir, |
| std::ios_base::openmode which = std::ios_base::in | |
| std::ios_base::out) override { |
| bool in = which & std::ios_base::in; |
| bool out = which & std::ios_base::out; |
| if ((!in && !out) || (in && out && dir == std::ios_base::cur)) return -1; |
| std::streambuf::char_type* newPosPtr; |
| switch (dir) { |
| case std::ios_base::beg: |
| newPosPtr = pbase(); |
| break; |
| case std::ios_base::cur: |
| // if dir == cur then in xor out due to |
| // if ((!in && !out) || (in && out && dir == std::ios_base::cur)) return -1; above |
| if (in) |
| newPosPtr = gptr(); |
| else |
| newPosPtr = pptr(); |
| break; |
| case std::ios_base::end: |
| // in and out bounds are the same and cannot change, so we can take either range |
| // regardless of the value of "which" |
| newPosPtr = epptr(); |
| break; |
| } |
| newPosPtr += off; |
| if (newPosPtr < pbase() || newPosPtr > epptr()) return -1; |
| if (in) { |
| gbump(newPosPtr - gptr()); |
| } |
| if (out) { |
| pbump(newPosPtr - pptr()); |
| } |
| return newPosPtr - pbase(); |
| } |
| }; |
| |
| } // namespace |
| |
| Blob::Blob(const uint8_t* value, size_t valueLength, const uint8_t* info, uint8_t infoLength, |
| BlobType type) { |
| mBlob = std::make_unique<blobv3>(); |
| memset(mBlob.get(), 0, sizeof(blobv3)); |
| if (valueLength > kValueSize) { |
| valueLength = kValueSize; |
| ALOGW("Provided blob length too large"); |
| } |
| if (infoLength + valueLength > kValueSize) { |
| infoLength = kValueSize - valueLength; |
| ALOGW("Provided info length too large"); |
| } |
| mBlob->length = valueLength; |
| memcpy(mBlob->value, value, valueLength); |
| |
| mBlob->info = infoLength; |
| memcpy(mBlob->value + valueLength, info, infoLength); |
| |
| mBlob->version = CURRENT_BLOB_VERSION; |
| mBlob->type = uint8_t(type); |
| |
| if (type == TYPE_MASTER_KEY || type == TYPE_MASTER_KEY_AES256) { |
| mBlob->flags = KEYSTORE_FLAG_ENCRYPTED; |
| } else { |
| mBlob->flags = KEYSTORE_FLAG_NONE; |
| } |
| } |
| |
| Blob::Blob(blobv3 b) { |
| mBlob = std::make_unique<blobv3>(b); |
| } |
| |
| Blob::Blob() { |
| if (mBlob) *mBlob = {}; |
| } |
| |
| Blob::Blob(const Blob& rhs) { |
| if (rhs.mBlob) { |
| mBlob = std::make_unique<blobv3>(*rhs.mBlob); |
| } |
| } |
| |
| Blob::Blob(Blob&& rhs) : mBlob(std::move(rhs.mBlob)) {} |
| |
| Blob& Blob::operator=(const Blob& rhs) { |
| if (&rhs != this) { |
| if (mBlob) *mBlob = {}; |
| if (rhs) { |
| mBlob = std::make_unique<blobv3>(*rhs.mBlob); |
| } else { |
| mBlob = {}; |
| } |
| } |
| return *this; |
| } |
| |
| Blob& Blob::operator=(Blob&& rhs) { |
| if (mBlob) *mBlob = {}; |
| mBlob = std::move(rhs.mBlob); |
| return *this; |
| } |
| |
| template <typename BlobType> static bool rawBlobIsEncrypted(const BlobType& blob) { |
| if (blob.version < 2) return true; |
| |
| return blob.flags & (KEYSTORE_FLAG_ENCRYPTED | KEYSTORE_FLAG_SUPER_ENCRYPTED); |
| } |
| |
| bool Blob::isEncrypted() const { |
| if (mBlob->version < 2) { |
| return true; |
| } |
| |
| return mBlob->flags & KEYSTORE_FLAG_ENCRYPTED; |
| } |
| |
| bool Blob::isSuperEncrypted() const { |
| return mBlob->flags & KEYSTORE_FLAG_SUPER_ENCRYPTED; |
| } |
| |
| bool Blob::isCriticalToDeviceEncryption() const { |
| return mBlob->flags & KEYSTORE_FLAG_CRITICAL_TO_DEVICE_ENCRYPTION; |
| } |
| |
| inline uint8_t setFlag(uint8_t flags, bool set, KeyStoreFlag flag) { |
| return set ? (flags | flag) : (flags & ~flag); |
| } |
| |
| void Blob::setEncrypted(bool encrypted) { |
| mBlob->flags = setFlag(mBlob->flags, encrypted, KEYSTORE_FLAG_ENCRYPTED); |
| } |
| |
| void Blob::setSuperEncrypted(bool superEncrypted) { |
| mBlob->flags = setFlag(mBlob->flags, superEncrypted, KEYSTORE_FLAG_SUPER_ENCRYPTED); |
| } |
| |
| void Blob::setCriticalToDeviceEncryption(bool critical) { |
| mBlob->flags = setFlag(mBlob->flags, critical, KEYSTORE_FLAG_CRITICAL_TO_DEVICE_ENCRYPTION); |
| } |
| |
| void Blob::setFallback(bool fallback) { |
| if (fallback) { |
| mBlob->flags |= KEYSTORE_FLAG_FALLBACK; |
| } else { |
| mBlob->flags &= ~KEYSTORE_FLAG_FALLBACK; |
| } |
| } |
| |
| static ResponseCode writeBlob(const std::string& filename, Blob blob, blobv3* rawBlob, |
| const std::vector<uint8_t>& aes_key, State state) { |
| ALOGV("writing blob %s", filename.c_str()); |
| |
| const size_t dataLength = rawBlob->length; |
| rawBlob->length = htonl(rawBlob->length); |
| |
| if (blob.isEncrypted() || blob.isSuperEncrypted()) { |
| if (state != STATE_NO_ERROR) { |
| ALOGD("couldn't insert encrypted blob while not unlocked"); |
| return ResponseCode::LOCKED; |
| } |
| |
| memset(rawBlob->initialization_vector, 0, AES_BLOCK_SIZE); |
| if (!RAND_bytes(rawBlob->initialization_vector, kGcmIvSizeBytes)) { |
| ALOGW("Could not read random data for: %s", filename.c_str()); |
| return ResponseCode::SYSTEM_ERROR; |
| } |
| |
| auto rc = AES_gcm_encrypt(rawBlob->value /* in */, rawBlob->value /* out */, dataLength, |
| aes_key, rawBlob->initialization_vector, rawBlob->aead_tag); |
| if (rc != ResponseCode::NO_ERROR) return rc; |
| } |
| |
| size_t fileLength = offsetof(blobv3, value) + dataLength + rawBlob->info; |
| |
| int out = |
| TEMP_FAILURE_RETRY(open(filename.c_str(), O_WRONLY | O_TRUNC | O_CREAT, S_IRUSR | S_IWUSR)); |
| if (out < 0) { |
| ALOGW("could not open file: %s: %s", filename.c_str(), strerror(errno)); |
| return ResponseCode::SYSTEM_ERROR; |
| } |
| |
| const size_t writtenBytes = writeFully(out, reinterpret_cast<uint8_t*>(rawBlob), fileLength); |
| if (close(out) != 0) { |
| return ResponseCode::SYSTEM_ERROR; |
| } |
| if (writtenBytes != fileLength) { |
| ALOGW("blob not fully written %zu != %zu", writtenBytes, fileLength); |
| unlink(filename.c_str()); |
| return ResponseCode::SYSTEM_ERROR; |
| } |
| return ResponseCode::NO_ERROR; |
| } |
| |
| ResponseCode LockedKeyBlobEntry::writeBlobs(Blob keyBlob, Blob characteristicsBlob, |
| const std::vector<uint8_t>& aes_key, |
| State state) const { |
| if (entry_ == nullptr) { |
| return ResponseCode::SYSTEM_ERROR; |
| } |
| ResponseCode rc; |
| if (keyBlob) { |
| blobv3* rawBlob = keyBlob.mBlob.get(); |
| rc = writeBlob(entry_->getKeyBlobPath(), std::move(keyBlob), rawBlob, aes_key, state); |
| if (rc != ResponseCode::NO_ERROR) { |
| return rc; |
| } |
| } |
| |
| if (characteristicsBlob) { |
| blobv3* rawBlob = characteristicsBlob.mBlob.get(); |
| rc = writeBlob(entry_->getCharacteristicsBlobPath(), std::move(characteristicsBlob), |
| rawBlob, aes_key, state); |
| } |
| return rc; |
| } |
| |
| ResponseCode Blob::readBlob(const std::string& filename, const std::vector<uint8_t>& aes_key, |
| State state) { |
| ResponseCode rc; |
| ALOGV("reading blob %s", filename.c_str()); |
| std::unique_ptr<blobv3> rawBlob = std::make_unique<blobv3>(); |
| |
| const int in = TEMP_FAILURE_RETRY(open(filename.c_str(), O_RDONLY)); |
| if (in < 0) { |
| return (errno == ENOENT) ? ResponseCode::KEY_NOT_FOUND : ResponseCode::SYSTEM_ERROR; |
| } |
| |
| // fileLength may be less than sizeof(mBlob) |
| const size_t fileLength = readFully(in, (uint8_t*)rawBlob.get(), sizeof(blobv3)); |
| if (close(in) != 0) { |
| return ResponseCode::SYSTEM_ERROR; |
| } |
| |
| if (fileLength == 0) { |
| return ResponseCode::VALUE_CORRUPTED; |
| } |
| |
| if (rawBlobIsEncrypted(*rawBlob)) { |
| if (state == STATE_LOCKED) { |
| mBlob = std::move(rawBlob); |
| return ResponseCode::LOCKED; |
| } |
| if (state == STATE_UNINITIALIZED) return ResponseCode::UNINITIALIZED; |
| } |
| |
| if (fileLength < offsetof(blobv3, value)) return ResponseCode::VALUE_CORRUPTED; |
| |
| if (rawBlob->version == 3) { |
| const ssize_t encryptedLength = ntohl(rawBlob->length); |
| |
| if (rawBlobIsEncrypted(*rawBlob)) { |
| rc = AES_gcm_decrypt(rawBlob->value /* in */, rawBlob->value /* out */, encryptedLength, |
| aes_key, rawBlob->initialization_vector, rawBlob->aead_tag); |
| if (rc != ResponseCode::NO_ERROR) { |
| // If the blob was superencrypted and decryption failed, it is |
| // almost certain that decryption is failing due to a user's |
| // changed master key. |
| if ((rawBlob->flags & KEYSTORE_FLAG_SUPER_ENCRYPTED) && |
| (rc == ResponseCode::VALUE_CORRUPTED)) { |
| return ResponseCode::KEY_PERMANENTLY_INVALIDATED; |
| } |
| return rc; |
| } |
| } |
| } else if (rawBlob->version < 3) { |
| blobv2& v2blob = reinterpret_cast<blobv2&>(*rawBlob); |
| const size_t headerLength = offsetof(blobv2, encrypted); |
| const ssize_t encryptedLength = fileLength - headerLength - v2blob.info; |
| if (encryptedLength < 0) return ResponseCode::VALUE_CORRUPTED; |
| |
| if (rawBlobIsEncrypted(*rawBlob)) { |
| if (encryptedLength % AES_BLOCK_SIZE != 0) { |
| return ResponseCode::VALUE_CORRUPTED; |
| } |
| |
| AES_KEY key; |
| AES_set_decrypt_key(aes_key.data(), kAesKeySize * 8, &key); |
| AES_cbc_encrypt(v2blob.encrypted, v2blob.encrypted, encryptedLength, &key, |
| v2blob.vector, AES_DECRYPT); |
| key = {}; // clear key |
| |
| uint8_t computedDigest[MD5_DIGEST_LENGTH]; |
| ssize_t digestedLength = encryptedLength - MD5_DIGEST_LENGTH; |
| MD5(v2blob.digested, digestedLength, computedDigest); |
| if (memcmp(v2blob.digest, computedDigest, MD5_DIGEST_LENGTH) != 0) { |
| return ResponseCode::VALUE_CORRUPTED; |
| } |
| } |
| } |
| |
| const ssize_t maxValueLength = fileLength - offsetof(blobv3, value) - rawBlob->info; |
| rawBlob->length = ntohl(rawBlob->length); |
| if (rawBlob->length < 0 || rawBlob->length > maxValueLength || |
| rawBlob->length + rawBlob->info + AES_BLOCK_SIZE > |
| static_cast<ssize_t>(sizeof(rawBlob->value))) { |
| return ResponseCode::VALUE_CORRUPTED; |
| } |
| |
| if (rawBlob->info != 0 && rawBlob->version < 3) { |
| // move info from after padding to after data |
| memmove(rawBlob->value + rawBlob->length, rawBlob->value + maxValueLength, rawBlob->info); |
| } |
| |
| mBlob = std::move(rawBlob); |
| return ResponseCode::NO_ERROR; |
| } |
| |
| std::tuple<ResponseCode, Blob, Blob> |
| LockedKeyBlobEntry::readBlobs(const std::vector<uint8_t>& aes_key, State state) const { |
| std::tuple<ResponseCode, Blob, Blob> result; |
| auto& [rc, keyBlob, characteristicsBlob] = result; |
| if (entry_ == nullptr) return rc = ResponseCode::SYSTEM_ERROR, result; |
| |
| rc = keyBlob.readBlob(entry_->getKeyBlobPath(), aes_key, state); |
| if (rc != ResponseCode::NO_ERROR && rc != ResponseCode::UNINITIALIZED) { |
| return result; |
| } |
| |
| if (entry_->hasCharacteristicsBlob()) { |
| characteristicsBlob.readBlob(entry_->getCharacteristicsBlobPath(), aes_key, state); |
| } |
| return result; |
| } |
| |
| ResponseCode LockedKeyBlobEntry::deleteBlobs() const { |
| if (entry_ == nullptr) return ResponseCode::NO_ERROR; |
| |
| // always try to delete both |
| ResponseCode rc1 = (unlink(entry_->getKeyBlobPath().c_str()) && errno != ENOENT) |
| ? ResponseCode::SYSTEM_ERROR |
| : ResponseCode::NO_ERROR; |
| if (rc1 != ResponseCode::NO_ERROR) { |
| ALOGW("Failed to delete key blob file \"%s\"", entry_->getKeyBlobPath().c_str()); |
| } |
| ResponseCode rc2 = (unlink(entry_->getCharacteristicsBlobPath().c_str()) && errno != ENOENT) |
| ? ResponseCode::SYSTEM_ERROR |
| : ResponseCode::NO_ERROR; |
| if (rc2 != ResponseCode::NO_ERROR) { |
| ALOGW("Failed to delete key characteristics file \"%s\"", |
| entry_->getCharacteristicsBlobPath().c_str()); |
| } |
| // then report the first error that occured |
| if (rc1 != ResponseCode::NO_ERROR) return rc1; |
| return rc2; |
| } |
| |
| keystore::SecurityLevel Blob::getSecurityLevel() const { |
| return keystore::flagsToSecurityLevel(mBlob->flags); |
| } |
| |
| void Blob::setSecurityLevel(keystore::SecurityLevel secLevel) { |
| mBlob->flags &= ~(KEYSTORE_FLAG_FALLBACK | KEYSTORE_FLAG_STRONGBOX); |
| mBlob->flags |= keystore::securityLevelToFlags(secLevel); |
| } |
| |
| std::tuple<bool, keystore::AuthorizationSet, keystore::AuthorizationSet> |
| Blob::getKeyCharacteristics() const { |
| std::tuple<bool, keystore::AuthorizationSet, keystore::AuthorizationSet> result; |
| auto& [success, hwEnforced, swEnforced] = result; |
| success = false; |
| ArrayStreamBuffer buf(mBlob->value); |
| std::istream in(&buf); |
| |
| // only the characteristics cache has both sets |
| if (getType() == TYPE_KEY_CHARACTERISTICS_CACHE) { |
| hwEnforced.Deserialize(&in); |
| } else if (getType() != TYPE_KEY_CHARACTERISTICS) { |
| // if its not the cache and not the legacy characteristics file we have no business |
| // here |
| return result; |
| } |
| swEnforced.Deserialize(&in); |
| success = !in.bad(); |
| |
| return result; |
| } |
| bool Blob::putKeyCharacteristics(const keystore::AuthorizationSet& hwEnforced, |
| const keystore::AuthorizationSet& swEnforced) { |
| if (!mBlob) mBlob = std::make_unique<blobv3>(); |
| mBlob->version = CURRENT_BLOB_VERSION; |
| ArrayStreamBuffer buf(mBlob->value); |
| std::ostream out(&buf); |
| hwEnforced.Serialize(&out); |
| swEnforced.Serialize(&out); |
| if (out.bad()) return false; |
| setType(TYPE_KEY_CHARACTERISTICS_CACHE); |
| mBlob->length = out.tellp(); |
| return true; |
| } |
| |
| void LockedKeyBlobEntry::put(const KeyBlobEntry& entry) { |
| std::unique_lock<std::mutex> lock(locked_blobs_mutex_); |
| locked_blobs_.erase(entry); |
| lock.unlock(); |
| locked_blobs_mutex_cond_var_.notify_all(); |
| } |
| |
| LockedKeyBlobEntry::~LockedKeyBlobEntry() { |
| if (entry_ != nullptr) put(*entry_); |
| } |
| |
| LockedKeyBlobEntry LockedKeyBlobEntry::get(KeyBlobEntry entry) { |
| std::unique_lock<std::mutex> lock(locked_blobs_mutex_); |
| locked_blobs_mutex_cond_var_.wait( |
| lock, [&] { return locked_blobs_.find(entry) == locked_blobs_.end(); }); |
| auto [iterator, success] = locked_blobs_.insert(std::move(entry)); |
| if (!success) return {}; |
| return LockedKeyBlobEntry(*iterator); |
| } |
| |
| std::set<KeyBlobEntry> LockedKeyBlobEntry::locked_blobs_; |
| std::mutex LockedKeyBlobEntry::locked_blobs_mutex_; |
| std::condition_variable LockedKeyBlobEntry::locked_blobs_mutex_cond_var_; |
| |
| /* Here is the encoding of key names. This is necessary in order to allow arbitrary |
| * characters in key names. Characters in [0-~] are not encoded. Others are encoded |
| * into two bytes. The first byte is one of [+-.] which represents the first |
| * two bits of the character. The second byte encodes the rest of the bits into |
| * [0-o]. Therefore in the worst case the length of a key gets doubled. Note |
| * that Base64 cannot be used here due to the need of prefix match on keys. */ |
| |
| std::string encodeKeyName(const std::string& keyName) { |
| std::string encodedName; |
| encodedName.reserve(keyName.size() * 2); |
| auto in = keyName.begin(); |
| while (in != keyName.end()) { |
| // Input character needs to be encoded. |
| if (*in < '0' || *in > '~') { |
| // Encode the two most-significant bits of the input char in the first |
| // output character, by counting up from 43 ('+'). |
| encodedName.append(1, '+' + (uint8_t(*in) >> 6)); |
| // Encode the six least-significant bits of the input char in the second |
| // output character, by counting up from 48 ('0'). |
| // This is safe because the maximum value is 112, which is the |
| // character 'p'. |
| encodedName.append(1, '0' + (*in & 0x3F)); |
| } else { |
| // No need to encode input char - append as-is. |
| encodedName.append(1, *in); |
| } |
| ++in; |
| } |
| return encodedName; |
| } |
| |
| std::string decodeKeyName(const std::string& encodedName) { |
| std::string decodedName; |
| decodedName.reserve(encodedName.size()); |
| auto in = encodedName.begin(); |
| bool multichar = false; |
| char c; |
| while (in != encodedName.end()) { |
| if (multichar) { |
| // Second part of a multi-character encoding. Turn off the multichar |
| // flag and set the six least-significant bits of c to the value originally |
| // encoded by counting up from '0'. |
| multichar = false; |
| decodedName.append(1, c | (uint8_t(*in) - '0')); |
| } else if (*in >= '+' && *in <= '.') { |
| // First part of a multi-character encoding. Set the multichar flag |
| // and set the two most-significant bits of c to be the two bits originally |
| // encoded by counting up from '+'. |
| multichar = true; |
| c = (*in - '+') << 6; |
| } else { |
| // Regular character, append as-is. |
| decodedName.append(1, *in); |
| } |
| ++in; |
| } |
| // mulitchars at the end get truncated |
| return decodedName; |
| } |
| |
| std::string KeyBlobEntry::getKeyBlobBaseName() const { |
| std::stringstream s; |
| if (masterkey_) { |
| s << alias_; |
| } else { |
| s << uid_ << "_" << encodeKeyName(alias_); |
| } |
| return s.str(); |
| } |
| |
| std::string KeyBlobEntry::getKeyBlobPath() const { |
| std::stringstream s; |
| if (masterkey_) { |
| s << user_dir_ << "/" << alias_; |
| } else { |
| s << user_dir_ << "/" << uid_ << "_" << encodeKeyName(alias_); |
| } |
| return s.str(); |
| } |
| |
| std::string KeyBlobEntry::getCharacteristicsBlobBaseName() const { |
| std::stringstream s; |
| if (!masterkey_) s << "." << uid_ << "_chr_" << encodeKeyName(alias_); |
| return s.str(); |
| } |
| |
| std::string KeyBlobEntry::getCharacteristicsBlobPath() const { |
| std::stringstream s; |
| if (!masterkey_) |
| s << user_dir_ << "/" |
| << "." << uid_ << "_chr_" << encodeKeyName(alias_); |
| return s.str(); |
| } |
| |
| bool KeyBlobEntry::hasKeyBlob() const { |
| int trys = 3; |
| while (trys--) { |
| if (!access(getKeyBlobPath().c_str(), R_OK | W_OK)) return true; |
| if (errno == ENOENT) return false; |
| LOG(WARNING) << "access encountered " << strerror(errno) << " (" << errno << ")" |
| << " while checking for key blob"; |
| if (errno != EAGAIN) break; |
| } |
| return false; |
| } |
| |
| bool KeyBlobEntry::hasCharacteristicsBlob() const { |
| int trys = 3; |
| while (trys--) { |
| if (!access(getCharacteristicsBlobPath().c_str(), R_OK | W_OK)) return true; |
| if (errno == ENOENT) return false; |
| LOG(WARNING) << "access encountered " << strerror(errno) << " (" << errno << ")" |
| << " while checking for key characteristics blob"; |
| if (errno != EAGAIN) break; |
| } |
| return false; |
| } |
| |
| static std::tuple<bool, uid_t, std::string> filename2UidAlias(const std::string& filepath) { |
| std::tuple<bool, uid_t, std::string> result; |
| |
| auto& [success, uid, alias] = result; |
| |
| success = false; |
| |
| auto filenamebase = filepath.find_last_of('/'); |
| std::string filename = |
| filenamebase == std::string::npos ? filepath : filepath.substr(filenamebase + 1); |
| |
| if (filename[0] == '.') return result; |
| |
| auto sep = filename.find('_'); |
| if (sep == std::string::npos) return result; |
| |
| std::stringstream s(filename.substr(0, sep)); |
| s >> uid; |
| if (!s) return result; |
| |
| alias = decodeKeyName(filename.substr(sep + 1)); |
| success = true; |
| return result; |
| } |
| |
| std::tuple<ResponseCode, std::list<LockedKeyBlobEntry>> |
| LockedKeyBlobEntry::list(const std::string& user_dir, |
| std::function<bool(uid_t, const std::string&)> filter) { |
| std::list<LockedKeyBlobEntry> matches; |
| |
| // This is a fence against any concurrent database accesses during database iteration. |
| // Only the keystore thread can lock entries. So it cannot be starved |
| // by workers grabbing new individual locks. We just wait here until all |
| // workers have relinquished their locked files. |
| std::unique_lock<std::mutex> lock(locked_blobs_mutex_); |
| locked_blobs_mutex_cond_var_.wait(lock, [&] { return locked_blobs_.empty(); }); |
| |
| DIR* dir = opendir(user_dir.c_str()); |
| if (!dir) { |
| ALOGW("can't open directory for user: %s", strerror(errno)); |
| return std::tuple<ResponseCode, std::list<LockedKeyBlobEntry>&&>{ResponseCode::SYSTEM_ERROR, |
| std::move(matches)}; |
| } |
| |
| struct dirent* file; |
| while ((file = readdir(dir)) != nullptr) { |
| // We only care about files. |
| if (file->d_type != DT_REG) { |
| continue; |
| } |
| |
| // Skip anything that starts with a "." |
| if (file->d_name[0] == '.') { |
| continue; |
| } |
| |
| auto [success, uid, alias] = filename2UidAlias(file->d_name); |
| |
| if (!success) { |
| ALOGW("could not parse key filename \"%s\"", file->d_name); |
| continue; |
| } |
| |
| if (!filter(uid, alias)) continue; |
| |
| auto [iterator, dummy] = locked_blobs_.emplace(alias, user_dir, uid); |
| matches.push_back(*iterator); |
| } |
| closedir(dir); |
| return std::tuple<ResponseCode, std::list<LockedKeyBlobEntry>&&>{ResponseCode::NO_ERROR, |
| std::move(matches)}; |
| } |
