X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fveritysetup.c;h=04691baee439a9ceefbdc805b6b85f149f2c212c;hb=b684fffdaf0ba1adf6a2656bbea8f24da8c58255;hp=c84f2064a0604869fdbc19cb66bd4d87d4c03744;hpb=62f334cfa58f9a21b24facdec35fc99e4cb1a4a0;p=platform%2Fupstream%2Fcryptsetup.git

diff --git a/src/veritysetup.c b/src/veritysetup.c
index c84f206..04691ba 100644
--- a/src/veritysetup.c
+++ b/src/veritysetup.c
@@ -40,7 +40,7 @@ static int data_block_size = DEFAULT_VERITY_DATA_BLOCK;
 static int hash_block_size = DEFAULT_VERITY_HASH_BLOCK;
 static uint64_t data_blocks = 0;
 static const char *salt_string = NULL;
-static uint64_t hash_start = 0;
+static uint64_t hash_offset = 0;
 static const char *opt_uuid = NULL;
 
 static int opt_verbose = 0;
@@ -50,21 +50,6 @@ static int opt_version_mode = 0;
 static const char **action_argv;
 static int action_argc;
 
-static size_t hex_to_bytes(const char *hex, char *result)
-{
-	char buf[3] = "xx\0", *endp;
-	size_t i, len;
-
-	len = strlen(hex) / 2;
-	for (i = 0; i < len; i++) {
-		memcpy(buf, &hex[i * 2], 2);
-		result[i] = strtoul(buf, &endp, 16);
-		if (endp != &buf[2])
-			return -EINVAL;
-	}
-	return i;
-}
-
 __attribute__((format(printf, 5, 6)))
 static void clogger(struct crypt_device *cd, int level, const char *file,
 		   int line, const char *format, ...)
@@ -118,7 +103,8 @@ static int _prepare_format(struct crypt_params_verity *params,
 			   const char *data_device,
 			   uint32_t flags)
 {
-	static char salt_bytes[512];
+	char *salt = NULL;
+	int len;
 
 	params->hash_name = hash_algorithm ?: DEFAULT_VERITY_HASH;
 	params->data_device = data_device;
@@ -127,19 +113,22 @@ static int _prepare_format(struct crypt_params_verity *params,
 		params->salt_size = 0;
 		params->salt = NULL;
 	} else if (salt_string) {
-		if (hex_to_bytes(salt_string, salt_bytes) * 2 != strlen(salt_string)) {
+		len = crypt_hex_to_bytes(salt_string, &salt, 0);
+		if (len < 0) {
 			log_err(_("Invalid salt string specified.\n"));
 			return -EINVAL;
 		}
-		params->salt_size = strlen(salt_string) / 2;
-		params->salt = salt_bytes;
-	} else
+		params->salt_size = len;
+		params->salt = salt;
+	} else {
 		params->salt_size = DEFAULT_VERITY_SALT_SIZE;
+		params->salt = NULL;
+	}
 
 	params->data_block_size = data_block_size;
 	params->hash_block_size = hash_block_size;
 	params->data_size = data_blocks;
-	params->hash_area_offset = hash_start;
+	params->hash_area_offset = hash_offset;
 	params->hash_type = hash_type;
 	params->flags = flags;
 
@@ -168,6 +157,7 @@ static int action_format(int arg)
 		crypt_dump(cd);
 out:
 	crypt_free(cd);
+	free(CONST_CAST(char*)params.salt);
 	return r;
 }
 
@@ -180,8 +170,8 @@ static int _activate(const char *dm_device,
 	struct crypt_device *cd = NULL;
 	struct crypt_params_verity params = {};
 	uint32_t activate_flags = CRYPT_ACTIVATE_READONLY;
-	char root_hash_bytes[128];
-	size_t hash_size;
+	char *root_hash_bytes = NULL;
+	ssize_t hash_size;
 	int r;
 
 	if ((r = crypt_init(&cd, hash_device)))
@@ -189,7 +179,7 @@ static int _activate(const char *dm_device,
 
 	if (use_superblock) {
 		params.flags = flags;
-		params.hash_area_offset = hash_start;
+		params.hash_area_offset = hash_offset;
 		r = crypt_load(cd, CRYPT_VERITY, &params);
 	} else {
 		r = _prepare_format(&params, data_device, flags | CRYPT_VERITY_NO_HEADER);
@@ -204,8 +194,7 @@ static int _activate(const char *dm_device,
 		goto out;
 
 	hash_size = crypt_get_volume_key_size(cd);
-	if (hash_size * 2 != strlen(root_hash) ||
-	    hex_to_bytes(root_hash, root_hash_bytes) != hash_size) {
+	if (crypt_hex_to_bytes(root_hash, &root_hash_bytes, 0) != hash_size) {
 		log_err(_("Invalid root hash string specified.\n"));
 		r = -EINVAL;
 		goto out;
@@ -216,6 +205,8 @@ static int _activate(const char *dm_device,
 					 activate_flags);
 out:
 	crypt_free(cd);
+	free(root_hash_bytes);
+	free(CONST_CAST(char*)params.salt);
 	return r;
 }
 
@@ -349,7 +340,7 @@ static int action_dump(int arg)
 	if ((r = crypt_init(&cd, action_argv[0])))
 		return r;
 
-	params.hash_area_offset = hash_start;
+	params.hash_area_offset = hash_offset;
 	r = crypt_load(cd, CRYPT_VERITY, &params);
 	if (!r)
 		crypt_dump(cd);
@@ -506,7 +497,7 @@ int main(int argc, const char **argv)
 		{ "data-block-size", 0,    POPT_ARG_INT,  &data_block_size,  0, N_("Block size on the data device"), N_("bytes") },
 		{ "hash-block-size", 0,    POPT_ARG_INT,  &hash_block_size,  0, N_("Block size on the hash device"), N_("bytes") },
 		{ "data-blocks",     0,    POPT_ARG_STRING, &popt_tmp,       1, N_("The number of blocks in the data file"), N_("blocks") },
-		{ "hash-start",      0,    POPT_ARG_STRING, &popt_tmp,       2, N_("Starting block on the hash device"), N_("512-byte sectors") },
+		{ "hash-offset",     0,    POPT_ARG_STRING, &popt_tmp,       2, N_("Starting offset on the hash device"), N_("bytes") },
 		{ "hash",            'h',  POPT_ARG_STRING, &hash_algorithm, 0, N_("Hash algorithm"), N_("string") },
 		{ "salt",            's',  POPT_ARG_STRING, &salt_string,    0, N_("Salt"), N_("hex string") },
 		{ "uuid",            '\0', POPT_ARG_STRING, &opt_uuid,       0, N_("UUID for device to use."), NULL },
@@ -544,9 +535,7 @@ int main(int argc, const char **argv)
 				data_blocks = ull_value;
 				break;
 			case 2:
-				hash_start = ull_value * 512;
-				if (hash_start / 512 != ull_value)
-					r = POPT_ERROR_BADNUMBER;
+				hash_offset = ull_value;
 				break;
 		}