| /* |
| ** Copyright 2009, 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 <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <sys/stat.h> |
| #include <sys/types.h> |
| #include <ctype.h> |
| #include <fcntl.h> |
| #include <dirent.h> |
| #include <errno.h> |
| #include <openssl/aes.h> |
| #include <openssl/evp.h> |
| #include <cutils/log.h> |
| |
| #include "common.h" |
| #include "keymgmt.h" |
| |
| static int retry_count = 0; |
| static unsigned char iv[IV_LEN]; |
| static KEYSTORE_STATE state = BOOTUP; |
| static AES_KEY encryptKey, decryptKey; |
| |
| inline void unlock_keystore(unsigned char *master_key) |
| { |
| AES_set_encrypt_key(master_key, AES_KEY_LEN, &encryptKey); |
| AES_set_decrypt_key(master_key, AES_KEY_LEN, &decryptKey); |
| memset(master_key, 0, sizeof(master_key)); |
| state = UNLOCKED; |
| } |
| |
| inline void lock_keystore() |
| { |
| memset(&encryptKey, 0 , sizeof(AES_KEY)); |
| memset(&decryptKey, 0 , sizeof(AES_KEY)); |
| state = LOCKED; |
| } |
| |
| inline void get_encrypt_key(char *passwd, AES_KEY *key) |
| { |
| unsigned char user_key[USER_KEY_LEN]; |
| gen_key(passwd, user_key, USER_KEY_LEN); |
| AES_set_encrypt_key(user_key, AES_KEY_LEN, key); |
| } |
| |
| inline void get_decrypt_key(char *passwd, AES_KEY *key) |
| { |
| unsigned char user_key[USER_KEY_LEN]; |
| gen_key(passwd, user_key, USER_KEY_LEN); |
| AES_set_decrypt_key(user_key, AES_KEY_LEN, key); |
| } |
| |
| static int gen_random_blob(unsigned char *key, int size) |
| { |
| int ret = 0; |
| int fd = open("/dev/urandom", O_RDONLY); |
| if (fd == -1) return -1; |
| if (read(fd, key, size) != size) ret = -1; |
| close(fd); |
| return ret; |
| } |
| |
| static int encrypt_n_save(AES_KEY *enc_key, DATA_BLOB *blob, |
| const char *keyfile) |
| { |
| int size, fd, ret = -1; |
| unsigned char enc_blob[MAX_BLOB_LEN]; |
| char tmpfile[KEYFILE_LEN]; |
| |
| if ((keyfile == NULL) || (strlen(keyfile) >= (KEYFILE_LEN - 4))) { |
| LOGE("keyfile name is too long or null"); |
| return -1; |
| } |
| strcpy(tmpfile, keyfile); |
| strcat(tmpfile, ".tmp"); |
| |
| // prepare the blob |
| if (IV_LEN > USER_KEY_LEN) { |
| LOGE("iv length is too long."); |
| return -1; |
| } |
| memcpy(blob->iv, iv, IV_LEN); |
| blob->blob_size = get_blob_size(blob); |
| if (blob->blob_size > MAX_BLOB_LEN) { |
| LOGE("blob data size is too large."); |
| return -1; |
| } |
| memcpy(enc_blob, blob->blob, blob->blob_size); |
| AES_cbc_encrypt((unsigned char *)enc_blob, (unsigned char *)blob->blob, |
| blob->blob_size, enc_key, iv, AES_ENCRYPT); |
| // write to keyfile |
| size = data_blob_size(blob); |
| if ((fd = open(tmpfile, O_CREAT|O_RDWR)) == -1) return -1; |
| if (write(fd, blob, size) == size) ret = 0; |
| close(fd); |
| if (!ret) { |
| unlink(keyfile); |
| rename(tmpfile, keyfile); |
| chmod(keyfile, 0440); |
| } |
| return ret; |
| } |
| |
| static int load_n_decrypt(const char *keyname, const char *keyfile, |
| AES_KEY *key, DATA_BLOB *blob) |
| { |
| int fd, ret = -1; |
| if ((fd = open(keyfile, O_RDONLY)) == -1) return -1; |
| // get the encrypted blob and iv |
| if ((read(fd, blob->iv, sizeof(blob->iv)) != sizeof(blob->iv)) || |
| (read(fd, &blob->blob_size, sizeof(uint32_t)) != sizeof(uint32_t)) || |
| (blob->blob_size > MAX_BLOB_LEN)) { |
| goto err; |
| } else { |
| unsigned char enc_blob[MAX_BLOB_LEN]; |
| if (read(fd, enc_blob, blob->blob_size) != |
| (int) blob->blob_size) goto err; |
| // decrypt the blob |
| AES_cbc_encrypt((unsigned char *)enc_blob, (unsigned char*)blob->blob, |
| blob->blob_size, key, blob->iv, AES_DECRYPT); |
| if (strcmp(keyname, (char*)blob->keyname) == 0) ret = 0; |
| } |
| err: |
| close(fd); |
| return ret; |
| } |
| |
| static int store_master_key(char *upasswd, unsigned char *master_key) |
| { |
| AES_KEY key; |
| DATA_BLOB blob; |
| |
| // prepare the blob |
| if (strlen(MASTER_KEY_TAG) >= USER_KEY_LEN) return -1; |
| strlcpy(blob.keyname, MASTER_KEY_TAG, USER_KEY_LEN); |
| blob.value_size = USER_KEY_LEN; |
| if (USER_KEY_LEN > MAX_KEY_VALUE_LENGTH) { |
| LOGE("master_key length is too long."); |
| return -1; |
| } |
| memcpy((void*)blob.value, (const void*)master_key, USER_KEY_LEN); |
| |
| // generate the encryption key |
| get_encrypt_key(upasswd, &key); |
| return encrypt_n_save(&key, &blob, MASTER_KEY); |
| } |
| |
| static int get_master_key(char *upasswd, unsigned char *master_key) |
| { |
| AES_KEY key; |
| int size, ret = 0; |
| DATA_BLOB blob; |
| |
| get_decrypt_key(upasswd, &key); |
| ret = load_n_decrypt(MASTER_KEY_TAG, MASTER_KEY, &key, &blob); |
| if (blob.value_size > USER_KEY_LEN) { |
| LOGE("the blob's value size is too large"); |
| return -1; |
| } |
| if (!ret) memcpy(master_key, blob.value, blob.value_size); |
| return ret; |
| } |
| |
| static int create_master_key(char *upasswd) |
| { |
| int ret; |
| unsigned char mpasswd[AES_KEY_LEN]; |
| unsigned char master_key[USER_KEY_LEN]; |
| |
| gen_random_blob(mpasswd, AES_KEY_LEN); |
| gen_key((char*)mpasswd, master_key, USER_KEY_LEN); |
| if ((ret = store_master_key(upasswd, master_key)) == 0) { |
| unlock_keystore(master_key); |
| } |
| memset(master_key, 0, USER_KEY_LEN); |
| memset(mpasswd, 0, AES_KEY_LEN); |
| |
| return ret; |
| } |
| |
| int change_passwd(char *old_pass, char *new_pass) |
| { |
| unsigned char master_key[USER_KEY_LEN]; |
| int ret; |
| |
| if (state == UNINITIALIZED) return -1; |
| if ((strlen(old_pass) < MIN_PASSWD_LENGTH) || |
| (strlen(new_pass) < MIN_PASSWD_LENGTH)) return -1; |
| |
| if ((ret = get_master_key(old_pass, master_key)) == 0) { |
| ret = store_master_key(new_pass, master_key); |
| retry_count = 0; |
| } else { |
| ret = MAX_RETRY_COUNT - ++retry_count; |
| if (ret == 0) { |
| retry_count = 0; |
| LOGE("passwd:reach max retry count, reset the keystore now."); |
| reset_keystore(); |
| return -1; |
| } |
| |
| } |
| return ret; |
| } |
| |
| int remove_key(const char *namespace, const char *keyname) |
| { |
| char keyfile[KEYFILE_LEN]; |
| |
| if (state != UNLOCKED) return -state; |
| if ((strlen(namespace) >= MAX_KEY_NAME_LENGTH) || |
| (strlen(keyname) >= MAX_KEY_NAME_LENGTH)) { |
| LOGE("keyname is too long."); |
| return -1; |
| } |
| sprintf(keyfile, KEYFILE_NAME, namespace, keyname); |
| return unlink(keyfile); |
| } |
| |
| int put_key(const char *namespace, const char *keyname, |
| unsigned char *data, int size) |
| { |
| DATA_BLOB blob; |
| uint32_t real_size; |
| char keyfile[KEYFILE_LEN]; |
| |
| if (state != UNLOCKED) { |
| LOGE("Can not store key with current state %d\n", state); |
| return -state; |
| } |
| if ((strlen(namespace) >= MAX_KEY_NAME_LENGTH) || |
| (strlen(keyname) >= MAX_KEY_NAME_LENGTH)) { |
| LOGE("keyname is too long."); |
| return -1; |
| } |
| sprintf(keyfile, KEYFILE_NAME, namespace, keyname); |
| strcpy(blob.keyname, keyname); |
| blob.value_size = size; |
| if (size > MAX_KEY_VALUE_LENGTH) { |
| LOGE("the data size is too large."); |
| return -1; |
| } |
| memcpy(blob.value, data, size); |
| return encrypt_n_save(&encryptKey, &blob, keyfile); |
| } |
| |
| int get_key(const char *namespace, const char *keyname, |
| unsigned char *data, int *size) |
| { |
| int ret; |
| DATA_BLOB blob; |
| uint32_t blob_size; |
| char keyfile[KEYFILE_LEN]; |
| |
| if (state != UNLOCKED) { |
| LOGE("Can not retrieve key value with current state %d\n", state); |
| return -state; |
| } |
| if ((strlen(namespace) >= MAX_KEY_NAME_LENGTH) || |
| (strlen(keyname) >= MAX_KEY_NAME_LENGTH)) { |
| LOGE("keyname is too long."); |
| return -1; |
| } |
| sprintf(keyfile, KEYFILE_NAME, namespace, keyname); |
| ret = load_n_decrypt(keyname, keyfile, &decryptKey, &blob); |
| if (!ret) { |
| if ((blob.value_size > MAX_KEY_VALUE_LENGTH)) { |
| LOGE("blob value size is too large."); |
| ret = -1; |
| } else { |
| *size = blob.value_size; |
| memcpy(data, blob.value, *size); |
| } |
| } |
| return ret; |
| } |
| |
| int list_keys(const char *namespace, char reply[BUFFER_MAX]) |
| { |
| DIR *d; |
| struct dirent *de; |
| |
| if (state != UNLOCKED) { |
| LOGE("Can not list key with current state %d\n", state); |
| return -1; |
| } |
| |
| if (!namespace || ((d = opendir("."))) == NULL) { |
| LOGE("cannot open keystore dir or namespace is null\n"); |
| return -1; |
| } |
| |
| if (strlen(namespace) >= MAX_KEY_NAME_LENGTH) { |
| LOGE("namespace is too long."); |
| return -1; |
| } |
| |
| reply[0] = 0; |
| while ((de = readdir(d))) { |
| char *prefix, *name, *keyfile = de->d_name; |
| char *context = NULL; |
| |
| if (de->d_type != DT_REG) continue; |
| if ((prefix = strtok_r(keyfile, NAME_DELIMITER, &context)) |
| == NULL) continue; |
| if (strcmp(prefix, namespace)) continue; |
| if ((name = strtok_r(NULL, NAME_DELIMITER, &context)) == NULL) continue; |
| // append the key name into reply |
| if (reply[0] != 0) strlcat(reply, " ", BUFFER_MAX); |
| if (strlcat(reply, name, BUFFER_MAX) >= BUFFER_MAX) { |
| LOGE("too many files under keystore directory\n"); |
| return -1; |
| } |
| } |
| closedir(d); |
| return 0; |
| } |
| |
| int new_passwd(char *password) |
| { |
| int passwdlen = strlen(password); |
| |
| if ((state != UNINITIALIZED) || (passwdlen < MIN_PASSWD_LENGTH)) return -1; |
| return create_master_key(password); |
| } |
| |
| int lock() |
| { |
| switch(state) { |
| case UNLOCKED: |
| lock_keystore(); |
| case LOCKED: |
| return 0; |
| default: |
| return -1; |
| } |
| } |
| |
| int unlock(char *passwd) |
| { |
| unsigned char master_key[USER_KEY_LEN]; |
| int ret = get_master_key(passwd, master_key); |
| if (!ret) { |
| unlock_keystore(master_key); |
| retry_count = 0; |
| } else { |
| ret = MAX_RETRY_COUNT - ++retry_count; |
| if (ret == 0) { |
| retry_count = 0; |
| LOGE("unlock:reach max retry count, reset the keystore now."); |
| reset_keystore(); |
| return -1; |
| } |
| } |
| return ret; |
| } |
| |
| KEYSTORE_STATE get_state() |
| { |
| return state; |
| } |
| |
| int reset_keystore() |
| { |
| int ret = 0; |
| DIR *d; |
| struct dirent *de; |
| |
| if ((d = opendir(".")) == NULL) { |
| LOGE("cannot open keystore dir\n"); |
| return -1; |
| } |
| while ((de = readdir(d))) { |
| char *dirname = de->d_name; |
| if (strcmp(".", dirname) == 0) continue; |
| if (strcmp("..", dirname) == 0) continue; |
| if (unlink(dirname) != 0) ret = -1; |
| } |
| closedir(d); |
| state = UNINITIALIZED; |
| if (ret == 0) { |
| LOGI("keystore is reset."); |
| } else { |
| LOGI("keystore can not be cleaned up entirely."); |
| } |
| return ret; |
| } |
| |
| int init_keystore(const char *dir) |
| { |
| int fd; |
| |
| if (dir) mkdir(dir, 0770); |
| if (!dir || chdir(dir)) { |
| LOGE("Can not open/create the keystore directory %s\n", |
| dir ? dir : "(null)"); |
| return -1; |
| } |
| gen_random_blob(iv, IV_LEN); |
| if ((fd = open(MASTER_KEY, O_RDONLY)) == -1) { |
| state = UNINITIALIZED; |
| return 0; |
| } |
| close(fd); |
| state = LOCKED; |
| return 0; |
| } |