Uprev libmtp to 1.1.12

src/mtpz.c

 /**
  * \file mtpz.c
  *
  * Copyright (C) 2011-2012 Sajid Anwar <sajidanwar94@gmail.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the
  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  * Boston, MA 02111-1307, USA.
  *
  * This file provides mtp zune cryptographic setup interfaces.
+ * It is also used with Windows Phone 7, but Microsoft/Nokiad seem
+ * to have discontinued MTPZ on Windows Phone 8.
  *
  * DISCLAIMER:
  *
  * The intention of this implementation is for users to be able
  * to interoperate with their devices, i.e. copy music to them in
  * operating systems other than Microsoft Windows, so it can be
  * played back on the device. We do not provide encryption keys
  * and constants in libmtp, we never will. You have to have these
  * on file in your home directory in $HOME/.mtpz-data, and we suggest
  * that you talk to Microsoft about providing the proper numbers if
@@ skipping 76 matching lines @@
                 bytes[i / 2] = u;
                 i += 2;
         }
 
         return bytes;
 }
 
 int mtpz_loaddata()
 {
         char *home = getenv("HOME");
+        int ret = -1;
         if (!home)
         {
-                LIBMTP_INFO("Error: Unable to determine user's home directory.\n");
+                LIBMTP_ERROR("Unable to determine user's home directory, MTPZ disabled.\n");
                 return -1;
         }
 
         int plen = strlen(home) + strlen("/.mtpz-data") + 1;
         char path[plen];
         sprintf(path, "%s/.mtpz-data", home);
 
         FILE *fdata = fopen(path, "r");
         if (!fdata)
-        {
-                LIBMTP_INFO("Error: Unable to open ~/.mtpz-data for reading.\n");
-                return -1;
-        }
+                return ret;
 
         // Should only be six characters in length, but fgets will encounter a newline and stop.
         MTPZ_PUBLIC_EXPONENT = (unsigned char *)fgets_strip((char *)malloc(8), 8, fdata);
         if (!MTPZ_PUBLIC_EXPONENT)
         {
-                LIBMTP_INFO("Error: Unable to read MTPZ public exponent from ~/.mtpz-data\n");
-                return -1;
+                LIBMTP_ERROR("Unable to read MTPZ public exponent from ~/.mtpz-data, MTPZ disabled.\n");
+                goto cleanup;
         }
 
         // Should only be 33 characters in length, but fgets will encounter a newline and stop.
-        char *hexenckey = (unsigned char *)fgets_strip((char *)malloc(35), 35, fdata);
+        char *hexenckey = fgets_strip((char *)malloc(35), 35, fdata);
         if (!hexenckey)
         {
-                LIBMTP_INFO("Error: Unable to read MTPZ encryption key from ~/.mtpz-data\n");
-                return -1;
+                LIBMTP_ERROR("Unable to read MTPZ encryption key from ~/.mtpz-data, MTPZ disabled.\n");
+                goto cleanup;
         }
+
         MTPZ_ENCRYPTION_KEY = hex_to_bytes(hexenckey, strlen(hexenckey));
         if (!MTPZ_ENCRYPTION_KEY)
         {
-                LIBMTP_INFO("Error: Unable to read MTPZ encryption key from ~/.mtpz-data\n");
+                LIBMTP_ERROR("Unable to read MTPZ encryption key from ~/.mtpz-data, MTPZ disabled.\n");
+                goto cleanup;
         }
 
         // Should only be 256 characters in length, but fgets will encounter a newline and stop.
         MTPZ_MODULUS = (unsigned char *)fgets_strip((char *)malloc(260), 260, fdata);
         if (!MTPZ_MODULUS)
         {
-                LIBMTP_INFO("Error: Unable to read MTPZ modulus from ~/.mtpz-data\n");
-                return -1;
+                LIBMTP_ERROR("Unable to read MTPZ modulus from ~/.mtpz-data, MTPZ disabled.\n");
+                goto cleanup;
         }
 
         // Should only be 256 characters in length, but fgets will encounter a newline and stop.
         MTPZ_PRIVATE_KEY = (unsigned char *)fgets_strip((char *)malloc(260), 260, fdata);
         if (!MTPZ_PRIVATE_KEY)
         {
-                LIBMTP_INFO("Error: Unable to read MTPZ private key from ~/.mtpz-data\n");
-                return -1;
+                LIBMTP_ERROR("Unable to read MTPZ private key from ~/.mtpz-data, MTPZ disabled.\n");
+                goto cleanup;
         }
 
         // Should only be 1258 characters in length, but fgets will encounter the end of the file and stop.
         char *hexcerts = fgets_strip((char *)malloc(1260), 1260, fdata);
         if (!hexcerts)
         {
-                LIBMTP_INFO("Error: Unable to read MTPZ certificates from ~/.mtpz-data\n");
-                return -1;
+                LIBMTP_ERROR("Unable to read MTPZ certificates from ~/.mtpz-data, MTPZ disabled.\n");
+                goto cleanup;
         }
+
         MTPZ_CERTIFICATES = hex_to_bytes(hexcerts, strlen(hexcerts));
         if (!MTPZ_CERTIFICATES)
         {
-                LIBMTP_INFO("Error: Unable to parse MTPZ certificates from ~/.mtpz-data\n");
-                return -1;
+                LIBMTP_ERROR("Unable to parse MTPZ certificates from ~/.mtpz-data, MTPZ disabled.\n");
+                goto cleanup;
         }
-
-        return 0;
+        // If all done without errors, drop the fail
+        ret = 0;
+cleanup:
+        fclose(fdata);
+        return ret;
 }
 /* MTPZ RSA */
 
 typedef struct mtpz_rsa_struct
 {
         gcry_sexp_t privkey;
         gcry_sexp_t pubkey;
 } mtpz_rsa_t;
 
 mtpz_rsa_t *mtpz_rsa_init(const unsigned char *modulus, const unsigned char *priv_key, const unsigned char *pub_exp);
@@ skipping 32 matching lines @@
 unsigned int mtpz_aes_gb11[];
 unsigned int mtpz_aes_gb14[];
 unsigned int mtpz_aes_gb13[];
 unsigned int mtpz_aes_gb9[];
 
 #define MTPZ_ENCRYPTIONLOBYTE(val) (((val) >> 24) & 0xFF)
 #define MTPZ_ENCRYPTIONBYTE1(val) (((val) >> 16) & 0xFF)
 #define MTPZ_ENCRYPTIONBYTE2(val) (((val) >>  8) & 0xFF)
 #define MTPZ_ENCRYPTIONBYTE3(val) (((val) >>  0) & 0xFF)
 
-#define MTPZ_SWAP(x) __builtin_bswap32(x)
+#define MTPZ_SWAP(x) mtpz_bswap32(x)
 
 void mtpz_encryption_cipher(unsigned char *data, unsigned int len, char encrypt);
 void mtpz_encryption_cipher_advanced(unsigned char *key, unsigned int key_len, unsigned char *data, unsigned int data_len, char encrypt);
 unsigned char *mtpz_encryption_expand_key(unsigned char *constant, int key_len, int count, int *out_len);
 void mtpz_encryption_expand_key_inner(unsigned char *constant, int key_len, unsigned char **out, int *out_len);
 void mtpz_encryption_inv_mix_columns(unsigned char *expanded, int offset, int rounds);
 void mtpz_encryption_decrypt_custom(unsigned char *data, unsigned char *seed, unsigned char *expanded);
 void mtpz_encryption_encrypt_custom(unsigned char *data, unsigned char *seed, unsigned char *expanded);
 void mtpz_encryption_encrypt_mac(unsigned char *hash, unsigned int hash_length, unsigned char *seed, unsigned int seed_len, unsigned char *out);
 
 
+static inline uint32_t mtpz_bswap32(uint32_t x)
+{
+#if defined __GNUC__ && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) || defined(__clang__)
+        return __builtin_bswap32(x);
+#else
+        return (x >> 24) |
+               ((x >> 8) & 0x0000ff00) |
+               ((x << 8) & 0x00ff0000) |
+               (x << 24);
+#endif
+}
 
 
 /* MTPZ RSA implementation */
 mtpz_rsa_t *mtpz_rsa_init(const unsigned char *str_modulus, const unsigned char *str_privkey, const unsigned char *str_pubexp)
 {
-        mtpz_rsa_t *rsa = (mtpz_rsa_t *)malloc(sizeof(mtpz_rsa_t));
-        memset(rsa, 0, sizeof(rsa));
+        mtpz_rsa_t *rsa = calloc(1, sizeof(mtpz_rsa_t));
+        if (rsa == NULL)
+                return NULL;
 
         gcry_mpi_t mpi_modulus, mpi_privkey, mpi_pubexp;
 
         gcry_mpi_scan(&mpi_modulus, GCRYMPI_FMT_HEX, str_modulus, 0, NULL);
         gcry_mpi_scan(&mpi_privkey, GCRYMPI_FMT_HEX, str_privkey, 0, NULL);
         gcry_mpi_scan(&mpi_pubexp, GCRYMPI_FMT_HEX, str_pubexp, 0, NULL);
 
         gcry_sexp_build(&rsa->privkey, NULL, "(private-key (rsa (n %m) (e %m) (d %m)))", mpi_modulus, mpi_pubexp, mpi_privkey);
         gcry_sexp_build(&rsa->pubkey, NULL, "(public-key (rsa (n %m) (e %m)))", mpi_modulus, mpi_pubexp);
 
@@ skipping 1218 matching lines @@
 };
 
 static uint16_t
 ptp_mtpz_validatehandshakeresponse (PTPParams* params, unsigned char *random, unsigned char **calculatedHash)
 {
         uint16_t ret;
         unsigned int len;
         unsigned char* response = NULL;
 
         ret = ptp_mtpz_getwmdrmpdappresponse (params, &response, &len);
-        if (ret == PTP_RC_OK)
+        if (ret != PTP_RC_OK)
         {
-                char *reader = (char *)response;
-                int i;
+                LIBMTP_INFO ("(MTPZ) Failure - did not receive device's response.\n");
+                return ret;
+        }
 
-                if (*(reader++) != '\x02')
-                {
-                        return -1;
-                }
+        char *reader = (char *)response;
+        int i;
 
-                if (*(reader++) != '\x02')
-                {
-                        return -1;
-                }
+        if (*(reader++) != '\x02')
+        {
+                return -1;
+        }
 
-                // Message is always 128 bytes.
-                reader++;
-                if (*(reader++) != '\x80')
-                {
-                        return -1;
-                }
+        if (*(reader++) != '\x02')
+        {
+                return -1;
+        }
 
-                char *message = (char *)malloc(128);
-                memcpy(message, reader, 128);
-                reader += 128;
+        // Message is always 128 bytes.
+        reader++;
+        if (*(reader++) != '\x80')
+        {
+                return -1;
+        }
 
-                // Decrypt the hash-key-message..
-                char *msg_dec = (char *)malloc(128);
-                memset(msg_dec, 0, 128);
+        char *message = (char *)malloc(128);
+        memcpy(message, reader, 128);
+        reader += 128;
 
-                mtpz_rsa_t *rsa = mtpz_rsa_init(MTPZ_MODULUS, MTPZ_PRIVATE_KEY, MTPZ_PUBLIC_EXPONENT);
-                if (!rsa)
-                {
-                        LIBMTP_INFO ("(MTPZ) Failure - could not instantiate RSA object.\n");
-                        free(message);
-                        free(msg_dec);
-                        return -1;
-                }
+        // Decrypt the hash-key-message..
+        char *msg_dec = (char *)malloc(128);
+        memset(msg_dec, 0, 128);
 
-                if (mtpz_rsa_decrypt(128, (unsigned char *)message, 128, (unsigned char *)msg_dec, rsa) == 0)
-                {
-                        LIBMTP_INFO ("(MTPZ) Failure - could not perform RSA decryption.\n");
+        mtpz_rsa_t *rsa = mtpz_rsa_init(MTPZ_MODULUS, MTPZ_PRIVATE_KEY, MTPZ_PUBLIC_EXPONENT);
+        if (!rsa)
+        {
+                LIBMTP_INFO ("(MTPZ) Failure - could not instantiate RSA object.\n");
+                free(message);
+                free(msg_dec);
+                return -1;
+        }
 
-                        free(message);
-                        free(msg_dec);
-                        mtpz_rsa_free(rsa);
-                        return -1;
-                }
-
-                mtpz_rsa_free(rsa);
-                rsa = NULL;
-
-                char *state = mtpz_hash_init_state();
-                char *hash_key = (char *)malloc(16);
-                char *v10 = mtpz_hash_custom6A5DC(state, msg_dec + 21, 107, 20);
-
-                for (i = 0; i < 20; i++)
-                        msg_dec[i + 1] ^= v10[i];
-
-                char *v11 = mtpz_hash_custom6A5DC(state, msg_dec + 1, 20, 107);
-
-                for (i = 0; i < 107; i++)
-                        msg_dec[i + 21] ^= v11[i];
-
-                memcpy(hash_key, msg_dec + 112, 16);
-
-                // Encrypted message is 0x340 bytes.
-                reader += 2;
-                if (*(reader++) != '\x03' || *(reader++) != '\x40')
-                {
-                        return -1;
-                }
-
-                unsigned char *act_msg = (unsigned char *)malloc(832);
-                unsigned char *act_reader = act_msg;
-                memcpy(act_msg, reader, 832);
-                reader = NULL;
-
-                mtpz_encryption_cipher_advanced((unsigned char *)hash_key, 16, act_msg, 832, 0);
-
-                act_reader++;
-                unsigned int certs_length = __builtin_bswap32(*(unsigned int *)(act_reader));
-                act_reader += 4;
-                act_reader += certs_length;
-
-                unsigned int rand_length = __builtin_bswap32(*(unsigned short *)(act_reader) << 16);
-                act_reader += 2;
-                unsigned char *rand_data = (unsigned char *)malloc(rand_length);
-                memcpy(rand_data, act_reader, rand_length);
-                if (memcmp(rand_data, random, 16) != 0)
-                {
-                        free(rand_data);
-                        return -1;
-                }
-                free(rand_data);
-                act_reader += rand_length;
-
-                unsigned int dev_rand_length = __builtin_bswap32(*(unsigned short *)(act_reader) << 16);
-                act_reader += 2;
-                act_reader += dev_rand_length;
-
-                act_reader++;
-
-                unsigned int sig_length = __builtin_bswap32(*(unsigned short *)(act_reader) << 16);
-                act_reader += 2;
-                act_reader += sig_length;
-
-                act_reader++;
-
-                unsigned int machash_length = __builtin_bswap32(*(unsigned short *)(act_reader) << 16);
-                act_reader += 2;
-                unsigned char *machash_data = (unsigned char *)malloc(machash_length);
-                memcpy(machash_data, act_reader, machash_length);
-                act_reader += machash_length;
-
-                *calculatedHash = machash_data;
+        if (mtpz_rsa_decrypt(128, (unsigned char *)message, 128, (unsigned char *)msg_dec, rsa) == 0)
+        {
+                LIBMTP_INFO ("(MTPZ) Failure - could not perform RSA decryption.\n");
 
                 free(message);
                 free(msg_dec);
-                free(state);
-                free(v10);
-                free(v11);
-                free(act_msg);
+                mtpz_rsa_free(rsa);
+                return -1;
         }
-        else
+
+        mtpz_rsa_free(rsa);
+        rsa = NULL;
+
+        char *state = mtpz_hash_init_state();
+        char *hash_key = (char *)malloc(16);
+        char *v10 = mtpz_hash_custom6A5DC(state, msg_dec + 21, 107, 20);
+
+        for (i = 0; i < 20; i++)
+                msg_dec[i + 1] ^= v10[i];
+
+        char *v11 = mtpz_hash_custom6A5DC(state, msg_dec + 1, 20, 107);
+
+        for (i = 0; i < 107; i++)
+                msg_dec[i + 21] ^= v11[i];
+
+        memcpy(hash_key, msg_dec + 112, 16);
+
+        // Encrypted message is 0x340 bytes.
+        reader += 2;
+        if (*(reader++) != '\x03' || *(reader++) != '\x40')
         {
-                LIBMTP_INFO ("(MTPZ) Failure - did not receive device's response.\n");
+                return -1;
         }
 
+        unsigned char *act_msg = (unsigned char *)malloc(832);
+        unsigned char *act_reader = act_msg;
+        memcpy(act_msg, reader, 832);
+        reader = NULL;
+
+        mtpz_encryption_cipher_advanced((unsigned char *)hash_key, 16, act_msg, 832, 0);
+
+        act_reader++;
+        unsigned int certs_length = MTPZ_SWAP(*(unsigned int *)(act_reader));
+        act_reader += 4;
+        act_reader += certs_length;
+
+        unsigned int rand_length = MTPZ_SWAP(*(unsigned short *)(act_reader) << 16);
+        act_reader += 2;
+        unsigned char *rand_data = (unsigned char *)malloc(rand_length);
+        memcpy(rand_data, act_reader, rand_length);
+        if (memcmp(rand_data, random, 16) != 0)
+        {
+                free(rand_data);
+                return -1;
+        }
+        free(rand_data);
+        act_reader += rand_length;
+
+        unsigned int dev_rand_length = MTPZ_SWAP(*(unsigned short *)(act_reader) << 16);
+        act_reader += 2;
+        act_reader += dev_rand_length;
+
+        act_reader++;
+
+        unsigned int sig_length = MTPZ_SWAP(*(unsigned short *)(act_reader) << 16);
+        act_reader += 2;
+        act_reader += sig_length;
+
+        act_reader++;
+
+        unsigned int machash_length = MTPZ_SWAP(*(unsigned short *)(act_reader) << 16);
+        act_reader += 2;
+        unsigned char *machash_data = (unsigned char *)malloc(machash_length);
+        memcpy(machash_data, act_reader, machash_length);
+        act_reader += machash_length;
+
+        *calculatedHash = machash_data;
+
+        free(message);
+        free(msg_dec);
+        free(state);
+        free(v10);
+        free(v11);
+        free(act_msg);
+
         return ret;
 }
 
 static uint16_t
 ptp_mtpz_opensecuresyncsession (PTPParams* params, unsigned char *hash)
 {
         unsigned char   mch[16];
         uint32_t        *hashparams = (unsigned int *)mch;
         unsigned int    macCount = *(unsigned int *)(hash + 16);
         uint16_t        ret;
 
         mtpz_encryption_encrypt_mac(hash, 16, (unsigned char *)(&macCount), 4, mch);
 
         ret = ptp_mtpz_wmdrmpd_enabletrustedfilesoperations(params,
-                __builtin_bswap32(hashparams[0]), __builtin_bswap32(hashparams[1]),
-                __builtin_bswap32(hashparams[2]), __builtin_bswap32(hashparams[3]));
+                MTPZ_SWAP(hashparams[0]), MTPZ_SWAP(hashparams[1]),
+                MTPZ_SWAP(hashparams[2]), MTPZ_SWAP(hashparams[3]));
         return ret;
 };
 
 static unsigned char *
 ptp_mtpz_makeapplicationcertificatemessage (unsigned int *out_len, unsigned char **out_random)
 {
         *out_len = 785;
 
         unsigned char *acm = (unsigned char *)malloc(785);
         unsigned char *target = acm;
@@ skipping 154 matching lines @@
         free (message);
 
         LIBMTP_INFO ("(MTPZ) Opening secure sync session.\n");
         ret = ptp_mtpz_opensecuresyncsession(params, hash);
 free_hash:
         free(hash);
 free_random:
         free(random);
         return ret;
 }