Revert "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_ERROR("Unable to determine user's home directory, MTPZ disabled.\n");
+                LIBMTP_INFO("Error: Unable to determine user's home directory.\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)
-                return ret;
+        {
+                LIBMTP_INFO("Error: Unable to open ~/.mtpz-data for reading.\n");
+                return -1;
+        }
 
         // 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_ERROR("Unable to read MTPZ public exponent from ~/.mtpz-data, MTPZ disabled.\n");
-                goto cleanup;
+                LIBMTP_INFO("Error: Unable to read MTPZ public exponent from ~/.mtpz-data\n");
+                return -1;
         }
 
         // Should only be 33 characters in length, but fgets will encounter a newline and stop.
-        char *hexenckey = fgets_strip((char *)malloc(35), 35, fdata);
+        char *hexenckey = (unsigned char *)fgets_strip((char *)malloc(35), 35, fdata);
         if (!hexenckey)
         {
-                LIBMTP_ERROR("Unable to read MTPZ encryption key from ~/.mtpz-data, MTPZ disabled.\n");
-                goto cleanup;
+                LIBMTP_INFO("Error: Unable to read MTPZ encryption key from ~/.mtpz-data\n");
+                return -1;
         }
-
         MTPZ_ENCRYPTION_KEY = hex_to_bytes(hexenckey, strlen(hexenckey));
         if (!MTPZ_ENCRYPTION_KEY)
         {
-                LIBMTP_ERROR("Unable to read MTPZ encryption key from ~/.mtpz-data, MTPZ disabled.\n");
-                goto cleanup;
+                LIBMTP_INFO("Error: Unable to read MTPZ encryption key from ~/.mtpz-data\n");
         }
 
         // 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_ERROR("Unable to read MTPZ modulus from ~/.mtpz-data, MTPZ disabled.\n");
-                goto cleanup;
+                LIBMTP_INFO("Error: Unable to read MTPZ modulus from ~/.mtpz-data\n");
+                return -1;
         }
 
         // 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_ERROR("Unable to read MTPZ private key from ~/.mtpz-data, MTPZ disabled.\n");
-                goto cleanup;
+                LIBMTP_INFO("Error: Unable to read MTPZ private key from ~/.mtpz-data\n");
+                return -1;
         }
 
         // 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_ERROR("Unable to read MTPZ certificates from ~/.mtpz-data, MTPZ disabled.\n");
-                goto cleanup;
+                LIBMTP_INFO("Error: Unable to read MTPZ certificates from ~/.mtpz-data\n");
+                return -1;
         }
-
         MTPZ_CERTIFICATES = hex_to_bytes(hexcerts, strlen(hexcerts));
         if (!MTPZ_CERTIFICATES)
         {
-                LIBMTP_ERROR("Unable to parse MTPZ certificates from ~/.mtpz-data, MTPZ disabled.\n");
-                goto cleanup;
+                LIBMTP_INFO("Error: Unable to parse MTPZ certificates from ~/.mtpz-data\n");
+                return -1;
         }
-        // If all done without errors, drop the fail
-        ret = 0;
-cleanup:
-        fclose(fdata);
-        return ret;
+
+        return 0;
 }
 /* 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) mtpz_bswap32(x)
+#define MTPZ_SWAP(x) __builtin_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 = calloc(1, sizeof(mtpz_rsa_t));
-        if (rsa == NULL)
-                return NULL;
+        mtpz_rsa_t *rsa = (mtpz_rsa_t *)malloc(sizeof(mtpz_rsa_t));
+        memset(rsa, 0, sizeof(rsa));
 
         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)
         {
-                LIBMTP_INFO ("(MTPZ) Failure - did not receive device's response.\n");
-                return ret;
-        }
+                char *reader = (char *)response;
+                int i;
 
-        char *reader = (char *)response;
-        int i;
+                if (*(reader++) != '\x02')
+                {
+                        return -1;
+                }
 
-        if (*(reader++) != '\x02')
-        {
-                return -1;
-        }
+                if (*(reader++) != '\x02')
+                {
+                        return -1;
+                }
 
-        if (*(reader++) != '\x02')
-        {
-                return -1;
-        }
+                // Message is always 128 bytes.
+                reader++;
+                if (*(reader++) != '\x80')
+                {
+                        return -1;
+                }
 
-        // Message is always 128 bytes.
-        reader++;
-        if (*(reader++) != '\x80')
-        {
-                return -1;
-        }
+                char *message = (char *)malloc(128);
+                memcpy(message, reader, 128);
+                reader += 128;
 
-        char *message = (char *)malloc(128);
-        memcpy(message, reader, 128);
-        reader += 128;
+                // Decrypt the hash-key-message..
+                char *msg_dec = (char *)malloc(128);
+                memset(msg_dec, 0, 128);
 
-        // Decrypt the hash-key-message..
-        char *msg_dec = (char *)malloc(128);
-        memset(msg_dec, 0, 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;
+                }
 
-        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;
-        }
+                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");
 
-        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);
+                        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;
 
                 free(message);
                 free(msg_dec);
-                mtpz_rsa_free(rsa);
-                return -1;
+                free(state);
+                free(v10);
+                free(v11);
+                free(act_msg);
         }
-
-        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')
+        else
         {
-                return -1;
+                LIBMTP_INFO ("(MTPZ) Failure - did not receive device's response.\n");
         }
 
-        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,
-                MTPZ_SWAP(hashparams[0]), MTPZ_SWAP(hashparams[1]),
-                MTPZ_SWAP(hashparams[2]), MTPZ_SWAP(hashparams[3]));
+                __builtin_bswap32(hashparams[0]), __builtin_bswap32(hashparams[1]),
+                __builtin_bswap32(hashparams[2]), __builtin_bswap32(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;
 }