keystore: remove old implementation and test. (4424dd7d) · Commits · e / os / android_frameworks_native-old

cmds/keystore/certtool.h

deleted100644 → 0

+0 −89

Original line number	Diff line number	Diff line
		/*
		**
		** 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.
		*/

		#ifndef __CERTTOOL_H__
		#define __CERTTOOL_H__

		#include <stdio.h>
		#include <string.h>
		#include <cutils/sockets.h>
		#include <cutils/log.h>

		#include "common.h"
		#include "netkeystore.h"

		#define CERT_NAME_LEN (2 * MAX_KEY_NAME_LENGTH + 2)

		/*
		* The specific function 'get_cert' is used in daemons to get the key value
		* from keystore. Caller should allocate the buffer and the length of the buffer
		* should be MAX_KEY_VALUE_LENGTH.
		*/
		static inline int get_cert(const char certname, unsigned char value, int *size)
		{
		int count, fd, ret = -1;
		LPC_MARSHAL cmd;
		char delimiter[] = "_";
		char *p = NULL;
		char *context = NULL;
		char cname = (char)cmd.data;

		if ((certname == NULL) \|\| (value == NULL)) {
		LOGE("get_cert: certname or value is null\n");
		return -1;
		}

		if (strlcpy(cname, certname, CERT_NAME_LEN) >= CERT_NAME_LEN) {
		LOGE("get_cert: keyname is too long\n");
		return -1;
		}

		fd = socket_local_client(SOCKET_PATH,
		ANDROID_SOCKET_NAMESPACE_RESERVED,
		SOCK_STREAM);
		if (fd == -1) {
		LOGE("Keystore service is not up and running.\n");
		return -1;
		}

		cmd.opcode = GET;
		p = strstr(cname, delimiter);
		cmd.len = strlen(certname) + 1;
		if (p == NULL) goto err;
		*p = 0; // replace the delimiter with \0 .

		if (write_marshal(fd, &cmd)) {
		LOGE("Incorrect command or command line is too long.\n");
		goto err;
		}
		if (read_marshal(fd, &cmd)) {
		LOGE("Failed to read the result.\n");
		goto err;
		}

		// copy the result if succeeded.
		if (!cmd.retcode && cmd.len <= BUFFER_MAX) {
		memcpy(value, cmd.data, cmd.len);
		ret = 0;
		*size = cmd.len;
		}
		err:
		close(fd);
		return ret;
		}

		#endif

cmds/keystore/common.h

deleted100644 → 0

+0 −60

Original line number	Diff line number	Diff line
		/*
		**
		** 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.
		*/

		#ifndef __COMMON_H__
		#define __COMMON_H__

		#define SOCKET_PATH "keystore"
		#define KEYSTORE_DIR "/data/misc/keystore/"

		#define READ_TIMEOUT 3
		#define MAX_KEY_NAME_LENGTH 64
		#define MAX_NAMESPACE_LENGTH MAX_KEY_NAME_LENGTH
		#define MAX_KEY_VALUE_LENGTH 4096

		#define BUFFER_MAX MAX_KEY_VALUE_LENGTH

		typedef enum {
		BOOTUP,
		UNINITIALIZED,
		LOCKED,
		UNLOCKED,
		} KEYSTORE_STATE;

		typedef enum {
		LOCK,
		UNLOCK,
		PASSWD,
		GETSTATE,
		LISTKEYS,
		GET,
		PUT,
		REMOVE,
		RESET,
		MAX_OPCODE
		} KEYSTORE_OPCODE;

		typedef struct {
		uint32_t len;
		union {
		uint32_t opcode;
		uint32_t retcode;
		};
		unsigned char data[BUFFER_MAX + 1];
		} LPC_MARSHAL;

		#endif

cmds/keystore/keymgmt.c

deleted100644 → 0

+0 −421

Original line number	Diff line number	Diff line
		/*
		** 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;
		}

cmds/keystore/keymgmt.h

deleted100644 → 0

+0 −83

Original line number	Diff line number	Diff line
		/*
		** 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.
		*/

		#ifndef __KEYMGMT_H__
		#define __KEYMGMT_H__

		#define MASTER_KEY_TAG "master_key"
		#define MASTER_KEY ".keymaster"
		#define MAX_PATH_LEN 128
		#define SALT "Android Keystore 0.1"
		#define NAME_DELIMITER "_"
		#define KEYFILE_NAME "%s"NAME_DELIMITER"%s"
		#define KEYGEN_ITER 1024
		#define AES_KEY_LEN 128
		#define USER_KEY_LEN (AES_KEY_LEN/8)
		#define IV_LEN USER_KEY_LEN
		#define MAX_RETRY_COUNT 6
		#define MIN_PASSWD_LENGTH 8

		#define gen_key(passwd, key, len) \
		PKCS5_PBKDF2_HMAC_SHA1(passwd, strlen(passwd), \
		(unsigned char*)SALT, \
		strlen(SALT), KEYGEN_ITER, \
		len, key)

		#define KEYFILE_LEN MAX_NAMESPACE_LENGTH + MAX_KEY_NAME_LENGTH + 6

		#define get_blob_size(blob) \
		(((blob->value_size + sizeof(uint32_t) + MAX_KEY_NAME_LENGTH \
		+ USER_KEY_LEN - 1) / USER_KEY_LEN) * USER_KEY_LEN)

		#define MAX_BLOB_LEN ((MAX_KEY_VALUE_LENGTH + MAX_KEY_NAME_LENGTH + \
		sizeof(uint32_t) + USER_KEY_LEN - 1) / USER_KEY_LEN)\
		* USER_KEY_LEN

		#define data_blob_size(blob) USER_KEY_LEN + sizeof(uint32_t) + blob->blob_size

		typedef struct {
		unsigned char iv[USER_KEY_LEN];
		uint32_t blob_size;
		union {
		unsigned char blob[1];
		struct {
		uint32_t value_size;
		char keyname[MAX_KEY_NAME_LENGTH];
		unsigned char value[MAX_KEY_VALUE_LENGTH];
		} __attribute__((packed));
		};
		} DATA_BLOB;

		typedef struct {
		char tag[USER_KEY_LEN];
		unsigned char master_key[USER_KEY_LEN];
		} MASTER_BLOB;

		int put_key(const char namespace, const char keyname,
		unsigned char *data, int size);
		int get_key(const char namespace, const char keyname,
		unsigned char data, int size);
		int remove_key(const char namespace, const char keyname);
		int list_keys(const char *namespace, char reply[BUFFER_MAX]);
		int new_passwd(char *password);
		int change_passwd(char old_pass, char new_pass);
		int lock();
		int unlock(char *passwd);
		KEYSTORE_STATE get_state();
		int reset_keystore();
		int init_keystore(const char *dir);

		#endif

cmds/keystore/netkeystore.c

deleted100644 → 0

+0 −429

File deleted.

Preview size limit exceeded, changes collapsed.