3 files changed, 214 insertions, 49 deletions

diff --git a/src/idevice.c b/src/idevice.c
index c605da3..4a6f544 100644
--- a/src/idevice.c
+++ b/src/idevice.c
@@ -668,7 +668,7 @@ idevice_error_t idevice_connection_enable_ssl(idevice_connection_t connection)
 	key_data_t root_cert = { NULL, 0 };
 	key_data_t root_privkey = { NULL, 0 };
 
-	userpref_error_t uerr = userpref_get_keys_and_certs(&root_privkey, &root_cert, NULL, NULL);
+	userpref_error_t uerr = userpref_device_record_get_keys_and_certs(connection->udid, &root_privkey, &root_cert, NULL, NULL);
 	if (uerr != USERPREF_E_SUCCESS) {
 		debug_info("Error %d when loading keys and certificates! %d", uerr);
 	}
diff --git a/src/lockdown.c b/src/lockdown.c
index b07366b..7c516c1 100644
--- a/src/lockdown.c
+++ b/src/lockdown.c
@@ -30,6 +30,7 @@
 #define __USE_GNU 1
 #include <stdio.h>
 #include <ctype.h>
+#include <unistd.h>
 #ifdef HAVE_OPENSSL
 #include <openssl/pem.h>
 #include <openssl/x509.h>
@@ -47,6 +48,11 @@
 #include "common/userpref.h"
 #include "asprintf.h"
 
+#ifdef WIN32
+#include <windows.h>
+#define sleep(x) Sleep(x*1000)
+#endif
+
 #define RESULT_SUCCESS 0
 #define RESULT_FAILURE 1
 
@@ -209,28 +215,18 @@ lockdownd_error_t lockdownd_stop_session(lockdownd_client_t client, const char *
 	return ret;
 }
 
-/**
- * Closes the lockdownd client session if one is running and frees up the
- * lockdownd_client struct.
- *
- * @param client The lockdown client
- *
- * @return LOCKDOWN_E_SUCCESS on success, NP_E_INVALID_ARG when client is NULL
- */
-lockdownd_error_t lockdownd_client_free(lockdownd_client_t client)
+static lockdownd_error_t lockdownd_client_free_simple(lockdownd_client_t client)
 {
 	if (!client)
 		return LOCKDOWN_E_INVALID_ARG;
+
 	lockdownd_error_t ret = LOCKDOWN_E_UNKNOWN_ERROR;
 
 	if (client->session_id) {
-		lockdownd_stop_session(client, client->session_id);
 		free(client->session_id);
 	}
 
 	if (client->parent) {
-		lockdownd_goodbye(client);
-
 		if (property_list_service_client_free(client->parent) == PROPERTY_LIST_SERVICE_E_SUCCESS) {
 			ret = LOCKDOWN_E_SUCCESS;
 		}
@@ -244,6 +240,36 @@ lockdownd_error_t lockdownd_client_free(lockdownd_client_t client)
 	}
 
 	free(client);
+
+	return ret;
+}
+
+/**
+ * Closes the lockdownd client session if one is running and frees up the
+ * lockdownd_client struct.
+ *
+ * @param client The lockdown client
+ *
+ * @return LOCKDOWN_E_SUCCESS on success, NP_E_INVALID_ARG when client is NULL
+ */
+lockdownd_error_t lockdownd_client_free(lockdownd_client_t client)
+{
+	if (!client)
+		return LOCKDOWN_E_INVALID_ARG;
+
+	lockdownd_error_t ret = LOCKDOWN_E_UNKNOWN_ERROR;
+
+
+	if (client->session_id) {
+		lockdownd_stop_session(client, client->session_id);
+	}
+
+	if (client->parent) {
+		lockdownd_goodbye(client);
+	}
+
+	ret = lockdownd_client_free_simple(client);
+
 	return ret;
 }
 
@@ -674,6 +700,33 @@ lockdownd_error_t lockdownd_client_new(idevice_t device, lockdownd_client_t *cli
 	return LOCKDOWN_E_SUCCESS;
 }
 
+static lockdownd_error_t lockdownd_client_reconnect(idevice_t device, lockdownd_client_t *client, const char *label)
+{
+	lockdownd_error_t ret = LOCKDOWN_E_SUCCESS;
+	int attempts = 3;
+	char *udid = NULL;
+
+	/* free resources of lockownd_client */
+	ret = lockdownd_client_free_simple(*client);
+	*client = NULL;
+
+	/* try to reconnect */
+	do {
+		debug_info("reconnecting to udid %s, %d remaining attempts", udid, attempts);
+		ret = lockdownd_client_new(device, client, label);
+		if (ret == LOCKDOWN_E_SUCCESS) {
+			debug_info("reconnected to lockdownd with err %d", ret);
+			break;
+		}
+		sleep(1);
+	} while(attempts--);
+
+	free(udid);
+	udid = NULL;
+
+	return ret;
+}
+
 /**
  * Creates a new lockdownd client for the device and starts initial handshake.
  * The handshake consists out of query_type, validate_pair, pair and
@@ -698,8 +751,10 @@ lockdownd_error_t lockdownd_client_new_with_handshake(idevice_t device, lockdown
 
 	lockdownd_error_t ret = LOCKDOWN_E_SUCCESS;
 	lockdownd_client_t client_loc = NULL;
+	char *system_buid = NULL;
 	char *host_id = NULL;
 	char *type = NULL;
+	int product_version_major = 0;
 
 	ret = lockdownd_client_new(device, &client_loc, label);
 	if (LOCKDOWN_E_SUCCESS != ret) {
@@ -719,22 +774,55 @@ lockdownd_error_t lockdownd_client_new_with_handshake(idevice_t device, lockdown
 			free(type);
 	}
 
-	userpref_get_host_id(&host_id);
+	/* get product version */
+	plist_t product_version_node = NULL;
+	char* product_version = NULL;
+	lockdownd_get_value(client_loc, NULL, "ProductVersion", &product_version_node);
+	if (product_version_node && plist_get_node_type(product_version_node) == PLIST_STRING) {
+		plist_get_string_val(product_version_node, &product_version);
+		product_version_major = strtol(product_version, NULL, 10);
+	}
+
+	if (product_version_major >= 7) {
+		userpref_get_system_buid(&system_buid);
+
+		/* set our BUID for the trust dialog so the next pairing can succeed */
+		lockdownd_set_value(client_loc, NULL, "UntrustedHostBUID", plist_new_string(system_buid));
+		free(system_buid);
+		system_buid = NULL;
+	}
+
+	userpref_device_record_get_host_id(client_loc->udid, &host_id);
 	if (LOCKDOWN_E_SUCCESS == ret && !host_id) {
 		ret = LOCKDOWN_E_INVALID_CONF;
 	}
 
-	if (LOCKDOWN_E_SUCCESS == ret && !userpref_has_device_public_key(client_loc->udid))
+	if (LOCKDOWN_E_SUCCESS == ret && !userpref_has_device_record(client_loc->udid)) {
+		/* attempt pairing */
 		ret = lockdownd_pair(client_loc, NULL);
 
+		if (ret == LOCKDOWN_E_SUCCESS && product_version_major >= 7) {
+			/* the trust dialog was dissmissed, thus the device will reconnect after pairing */
+			lockdownd_client_reconnect(device, &client_loc, label);
+		}
+	}
+
 	/* in any case, we need to validate pairing to receive trusted host status */
 	ret = lockdownd_validate_pair(client_loc, NULL);
 
 	/* if not paired yet, let's do it now */
 	if (LOCKDOWN_E_INVALID_HOST_ID == ret) {
 		ret = lockdownd_pair(client_loc, NULL);
+
+		if (ret == LOCKDOWN_E_SUCCESS && product_version_major >= 7) {
+			/* the trust dialog was dissmissed, thus the device will reconnect after pairing */
+			lockdownd_client_reconnect(device, &client_loc, label);
+		}
+
 		if (LOCKDOWN_E_SUCCESS == ret) {
 			ret = lockdownd_validate_pair(client_loc, NULL);
+		} else if (LOCKDOWN_E_PAIRING_DIALOG_PENDING == ret) {
+			debug_info("Device shows the pairing dialog.");
 		}
 	}
 
@@ -772,19 +860,13 @@ static plist_t lockdownd_pair_record_to_plist(lockdownd_pair_record_t pair_recor
 	if (!pair_record)
 		return NULL;
 
-	char *host_id_loc = pair_record->host_id;
-
 	/* setup request plist */
 	plist_t dict = plist_new_dict();
 	plist_dict_insert_item(dict, "DeviceCertificate", plist_new_data(pair_record->device_certificate, strlen(pair_record->device_certificate)));
 	plist_dict_insert_item(dict, "HostCertificate", plist_new_data(pair_record->host_certificate, strlen(pair_record->host_certificate)));
-	if (!pair_record->host_id)
-		userpref_get_host_id(&host_id_loc);
-	plist_dict_insert_item(dict, "HostID", plist_new_string(host_id_loc));
+	plist_dict_insert_item(dict, "HostID", plist_new_string(pair_record->host_id));
 	plist_dict_insert_item(dict, "RootCertificate", plist_new_data(pair_record->root_certificate, strlen(pair_record->root_certificate)));
-
-	if (!pair_record->host_id)
-		free(host_id_loc);
+	plist_dict_insert_item(dict, "SystemBUID", plist_new_string(pair_record->system_buid));
 
 	return dict;
 }
@@ -800,7 +882,7 @@ static plist_t lockdownd_pair_record_to_plist(lockdownd_pair_record_t pair_recor
  *
  * @return LOCKDOWN_E_SUCCESS on success
  */
-static lockdownd_error_t generate_pair_record_plist(key_data_t public_key, char *host_id, plist_t *pair_record_plist)
+static lockdownd_error_t generate_pair_record_plist(const char *udid, char* system_buid, char *host_id, key_data_t public_key, plist_t *pair_record_plist)
 {
 	lockdownd_error_t ret = LOCKDOWN_E_UNKNOWN_ERROR;
 
@@ -808,25 +890,18 @@ static lockdownd_error_t generate_pair_record_plist(key_data_t public_key, char
 	key_data_t host_cert = { NULL, 0 };
 	key_data_t root_cert = { NULL, 0 };
 
-	ret = lockdownd_gen_pair_cert(public_key, &device_cert, &host_cert, &root_cert);
+	ret = lockdownd_gen_pair_cert_for_udid(udid, public_key, &device_cert, &host_cert, &root_cert);
 	if (ret != LOCKDOWN_E_SUCCESS) {
 		return ret;
 	}
 
-	char *host_id_loc = host_id;
-
-	if (!host_id)
-		userpref_get_host_id(&host_id_loc);
-
 	/* setup request plist */
 	*pair_record_plist = plist_new_dict();
 	plist_dict_insert_item(*pair_record_plist, "DeviceCertificate", plist_new_data((const char*)device_cert.data, device_cert.size));
 	plist_dict_insert_item(*pair_record_plist, "HostCertificate", plist_new_data((const char*)host_cert.data, host_cert.size));
-	plist_dict_insert_item(*pair_record_plist, "HostID", plist_new_string(host_id_loc));
+	plist_dict_insert_item(*pair_record_plist, "HostID", plist_new_string(host_id));
 	plist_dict_insert_item(*pair_record_plist, "RootCertificate", plist_new_data((const char*)root_cert.data, root_cert.size));
-
-	if (!host_id)
-		free(host_id_loc);
+	plist_dict_insert_item(*pair_record_plist, "SystemBUID", plist_new_string(system_buid));
 
 	if (device_cert.data)
 		free(device_cert.data);
@@ -863,8 +938,10 @@ static lockdownd_error_t lockdownd_do_pair(lockdownd_client_t client, lockdownd_
 	plist_t dict_record = NULL;
 	key_data_t public_key = { NULL, 0 };
 	int pairing_mode = 0; /* 0 = libimobiledevice, 1 = external */
+	char* host_id = NULL;
+	char* system_buid = NULL;
 
-	if (pair_record && pair_record->host_id) {
+	if (pair_record && pair_record->system_buid && pair_record->host_id) {
 		/* valid pair_record passed? */
 		if (!pair_record->device_certificate || !pair_record->host_certificate || !pair_record->root_certificate) {
 			return LOCKDOWN_E_PLIST_ERROR;
@@ -883,34 +960,73 @@ static lockdownd_error_t lockdownd_do_pair(lockdownd_client_t client, lockdownd_
 			return ret;
 		}
 		debug_info("device public key follows:\n%.*s", public_key.size, public_key.data);
+
 		/* get libimobiledevice pair_record */
-		ret = generate_pair_record_plist(public_key, NULL, &dict_record);
+		userpref_get_system_buid(&system_buid);
+		userpref_device_record_get_host_id(client->udid, &host_id);
+		userpref_device_record_set_value(client->udid, USERPREF_SYSTEM_BUID_KEY, plist_new_string(system_buid));
+
+		ret = generate_pair_record_plist(client->udid, system_buid, host_id, public_key, &dict_record);
+
+		if (host_id)
+			free(host_id);
+		if (system_buid)
+			free(system_buid);
+
 		if (ret != LOCKDOWN_E_SUCCESS) {
+			if (public_key.data)
+				free(public_key.data);
 			if (dict_record)
 				plist_free(dict_record);
 			return ret;
 		}
 	}
 
-	/* Setup Pair request plist */
+	if (!strcmp("Pair", verb)) {
+		/* get wifi mac */
+		plist_t wifi_mac_node = NULL;
+		lockdownd_get_value(client, NULL, "WiFiAddress", &wifi_mac_node);
+
+		/* save wifi mac address in config */
+		if (wifi_mac_node) {
+			userpref_device_record_set_value(client->udid, USERPREF_WIFI_MAC_ADDRESS_KEY, plist_copy(wifi_mac_node));
+			plist_free(wifi_mac_node);
+			wifi_mac_node = NULL;
+		}
+	}
+
+	/* setup pair request plist */
 	dict = plist_new_dict();
 	plist_dict_add_label(dict, client->label);
-	plist_dict_insert_item(dict,"PairRecord", dict_record);
+	plist_dict_insert_item(dict, "PairRecord", plist_copy(dict_record));
 	plist_dict_insert_item(dict, "Request", plist_new_string(verb));
+	plist_dict_insert_item(dict, "ProtocolVersion", plist_new_string(LOCKDOWN_PROTOCOL_VERSION));
+
+	plist_t options = plist_new_dict();
+	plist_dict_insert_item(options, "ExtendedPairingErrors", plist_new_bool(1));
+	plist_dict_insert_item(dict, "PairingOptions", options);
 
 	/* send to device */
 	ret = lockdownd_send(client, dict);
 	plist_free(dict);
 	dict = NULL;
 
-	if (ret != LOCKDOWN_E_SUCCESS)
+	if (ret != LOCKDOWN_E_SUCCESS) {
+		if (public_key.data)
+			free(public_key.data);
+		plist_free(dict_record);
 		return ret;
+	}
 
 	/* Now get device's answer */
 	ret = lockdownd_receive(client, &dict);
 
-	if (ret != LOCKDOWN_E_SUCCESS)
+	if (ret != LOCKDOWN_E_SUCCESS) {
+		if (public_key.data)
+			free(public_key.data);
+		plist_free(dict_record);
 		return ret;
+	}
 
 	if (strcmp(verb, "Unpair") == 0) {
 		/* workaround for Unpair giving back ValidatePair,
@@ -928,13 +1044,25 @@ static lockdownd_error_t lockdownd_do_pair(lockdownd_client_t client, lockdownd_
 	if (ret == LOCKDOWN_E_SUCCESS) {
 		debug_info("%s success", verb);
 		if (!pairing_mode) {
+			debug_info("internal pairing mode");
 			if (!strcmp("Unpair", verb)) {
 				/* remove public key from config */
-				userpref_remove_device_public_key(client->udid);
+				userpref_remove_device_record(client->udid);
 			} else {
-				/* store public key in config */
-				userpref_set_device_public_key(client->udid, public_key);
+				if (!strcmp("Pair", verb)) {
+					debug_info("getting EscrowBag from response");
+
+					/* add returned escrow bag if available */
+					plist_t escrow_bag = plist_dict_get_item(dict, "EscrowBag");
+					if (escrow_bag && plist_get_node_type(escrow_bag) == PLIST_DATA) {
+						userpref_device_record_set_value(client->udid, USERPREF_ESCROW_BAG_KEY, plist_copy(escrow_bag));
+						plist_free(escrow_bag);
+						escrow_bag = NULL;
+					}
+				}
 			}
+		} else {
+			debug_info("external pairing mode");
 		}
 	} else {
 		debug_info("%s failure", verb);
@@ -950,6 +1078,10 @@ static lockdownd_error_t lockdownd_do_pair(lockdownd_client_t client, lockdownd_
 					ret = LOCKDOWN_E_PASSWORD_PROTECTED;
 				} else if (!strcmp(value, "InvalidHostID")) {
 					ret = LOCKDOWN_E_INVALID_HOST_ID;
+				} else if (!strcmp(value, "UserDeniedPairing")) {
+					ret = LOCKDOWN_E_USER_DENIED_PAIRING;
+				} else if (!strcmp(value, "PairingDialogResponsePending")) {
+					ret = LOCKDOWN_E_PAIRING_DIALOG_PENDING;
 				}
 				free(value);
 			}
@@ -958,10 +1090,18 @@ static lockdownd_error_t lockdownd_do_pair(lockdownd_client_t client, lockdownd_
 			error_node = NULL;
 		}
 	}
+
+	if (dict_record) {
+		plist_free(dict_record);
+		dict_record = NULL;
+	}
+
 	plist_free(dict);
 	dict = NULL;
+
 	if (public_key.data)
 		free(public_key.data);
+
 	return ret;
 }
 
@@ -1115,11 +1255,12 @@ lockdownd_error_t lockdownd_goodbye(lockdownd_client_t client)
  *  system failed, LOCKDOWN_E_SSL_ERROR if the certificates could not be
  *  generated
  */
-lockdownd_error_t lockdownd_gen_pair_cert(key_data_t public_key, key_data_t * odevice_cert,
+lockdownd_error_t lockdownd_gen_pair_cert_for_udid(const char *udid, key_data_t public_key, key_data_t * odevice_cert,
 									   key_data_t * ohost_cert, key_data_t * oroot_cert)
 {
 	if (!public_key.data || !odevice_cert || !ohost_cert || !oroot_cert)
 		return LOCKDOWN_E_INVALID_ARG;
+
 	lockdownd_error_t ret = LOCKDOWN_E_UNKNOWN_ERROR;
 	userpref_error_t uret = USERPREF_E_UNKNOWN_ERROR;
 
@@ -1148,7 +1289,7 @@ lockdownd_error_t lockdownd_gen_pair_cert(key_data_t public_key, key_data_t * od
 	host_privkey.data = NULL;
 	host_privkey.size = 0;
 
-	uret = userpref_get_keys_and_certs(&root_privkey, &root_cert, &host_privkey, &host_cert);
+	uret = userpref_device_record_get_keys_and_certs(udid, &root_privkey, &root_cert, &host_privkey, &host_cert);
 	if (USERPREF_E_SUCCESS == uret) {
 		/* generate device certificate */
 		ASN1_INTEGER* sn = ASN1_INTEGER_new();
@@ -1209,7 +1350,7 @@ lockdownd_error_t lockdownd_gen_pair_cert(key_data_t public_key, key_data_t * od
 			key_data_t pem_root_cert = { NULL, 0 };
 			key_data_t pem_host_cert = { NULL, 0 };
 
-			uret = userpref_get_certs_as_pem(&pem_root_cert, &pem_host_cert);
+			uret = userpref_device_record_get_certs_as_pem(udid, &pem_root_cert, &pem_host_cert);
 			if (USERPREF_E_SUCCESS == uret) {
 				/* copy buffer for output */
 				membp = BIO_new(BIO_s_mem());
@@ -1395,6 +1536,10 @@ lockdownd_error_t lockdownd_gen_pair_cert(key_data_t public_key, key_data_t * od
 
 	gnutls_free(der_pub_key.data);
 #endif
+	/* save device cert in config */
+	if (odevice_cert->size) {
+		userpref_device_record_set_value(udid, USERPREF_DEVICE_CERTIFICATE_KEY, plist_new_data((char*)odevice_cert->data, (uint64_t)odevice_cert->size));
+	}
 
 	return ret;
 }
@@ -1429,9 +1574,24 @@ lockdownd_error_t lockdownd_start_session(lockdownd_client_t client, const char
 	/* setup request plist */
 	dict = plist_new_dict();
 	plist_dict_add_label(dict, client->label);
-	plist_dict_insert_item(dict,"HostID", plist_new_string(host_id));
 	plist_dict_insert_item(dict,"Request", plist_new_string("StartSession"));
 
+	/* add host id */
+	if (host_id) {
+		plist_dict_insert_item(dict, "HostID", plist_new_string(host_id));
+	}
+
+	/* add system buid */
+	char *system_buid = NULL;
+	userpref_get_system_buid(&system_buid);
+	if (system_buid) {
+		plist_dict_insert_item(dict, "SystemBUID", plist_new_string(system_buid));
+		if (system_buid) {
+			free(system_buid);
+			system_buid = NULL;
+		}
+	}
+
 	ret = lockdownd_send(client, dict);
 	plist_free(dict);
 	dict = NULL;
@@ -1471,6 +1631,7 @@ lockdownd_error_t lockdownd_start_session(lockdownd_client_t client, const char
 		if (session_node && (plist_get_node_type(session_node) == PLIST_STRING)) {
 			plist_get_string_val(session_node, &client->session_id);
 		}
+
 		if (client->session_id) {
 			debug_info("SessionID: %s", client->session_id);
 			if (session_id != NULL)
@@ -1478,7 +1639,9 @@ lockdownd_error_t lockdownd_start_session(lockdownd_client_t client, const char
 		} else {
 			debug_info("Failed to get SessionID!");
 		}
+
 		debug_info("Enable SSL Session: %s", (use_ssl?"true":"false"));
+
 		if (use_ssl) {
 			ret = property_list_service_enable_ssl(client->parent);
 			if (ret == PROPERTY_LIST_SERVICE_E_SUCCESS) {
@@ -1523,7 +1686,7 @@ lockdownd_error_t lockdownd_start_service(lockdownd_client_t client, const char
 	}
 
 	char *host_id = NULL;
-	userpref_get_host_id(&host_id);
+	userpref_device_record_get_host_id(client->udid, &host_id);
 	if (!host_id)
 		return LOCKDOWN_E_INVALID_CONF;
 	if (!client->session_id)
diff --git a/src/lockdown.h b/src/lockdown.h
index 30ebc15..9c2be44 100644
--- a/src/lockdown.h
+++ b/src/lockdown.h
@@ -27,6 +27,8 @@
 #include "libimobiledevice/lockdown.h"
 #include "property_list_service.h"
 
+#define LOCKDOWN_PROTOCOL_VERSION "2"
+
 struct lockdownd_client_private {
 	property_list_service_client_t parent;
 	int ssl_enabled;
@@ -36,6 +38,6 @@ struct lockdownd_client_private {
 };
 
 lockdownd_error_t lockdownd_get_device_public_key(lockdownd_client_t client, key_data_t * public_key);
-lockdownd_error_t lockdownd_gen_pair_cert(key_data_t public_key, key_data_t * device_cert, key_data_t * host_cert, key_data_t * root_cert);
+lockdownd_error_t lockdownd_gen_pair_cert_for_udid(const char *udid, key_data_t public_key, key_data_t * device_cert, key_data_t * host_cert, key_data_t * root_cert);
 
 #endif