开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
drms.c
资源名称：vlc-1.0.5.zip　[点击查看]
上传用户：kjfoods
上传日期：2020-07-06
资源大小：29949k
文件大小：62k
源码类别：

midi

开发平台：

Unix_Linux

drms.c：源码内容
  1. /*****************************************************************************
  2.  * drms.c: DRMS
  3.  *****************************************************************************
  4.  * Copyright (C) 2004 the VideoLAN team
  5.  * $Id: ca4d9c63982b4456f09903aaf171d09924a94e0e $
  6.  *
  7.  * Authors: Jon Lech Johansen <jon-vl@nanocrew.net>
  8.  *          Sam Hocevar <sam@zoy.org>
  9.  *
  10.  * This program is free software; you can redistribute it and/or modify
  11.  * it under the terms of the GNU General Public License as published by
  12.  * the Free Software Foundation; either version 2 of the License, or
  13.  * (at your option) any later version.
  14.  *
  15.  * This program is distributed in the hope that it will be useful,
  16.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.  * GNU General Public License for more details.
  19.  *
  20.  * You should have received a copy of the GNU General Public License
  21.  * along with this program; if not, write to the Free Software
  22.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23.  *****************************************************************************/
  25. #ifdef __LIBVLC__
  26. #ifdef HAVE_CONFIG_H
  27. # include "config.h"
  28. #endif
  30. #   include <vlc_common.h>
  31. #   include <vlc_md5.h>
  32. #   include "libmp4.h"
  33. #   include <vlc_charset.h>
  34. #else
  35. #   include "drmsvl.h"
  36. #endif
  38. #ifdef WIN32
  39. #   include <io.h>
  40. #else
  41. #   include <stdio.h>
  42. #endif
  44. #include <errno.h>
  46. #ifdef WIN32
  47. #   if !defined( UNDER_CE )
  48. #       include <direct.h>
  49. #   endif
  50. #   include <tchar.h>
  51. #   include <shlobj.h>
  52. #   include <windows.h>
  53. #endif
  55. #ifdef HAVE_SYS_STAT_H
  56. #   include <sys/stat.h>
  57. #endif
  58. #ifdef HAVE_SYS_TYPES_H
  59. #   include <sys/types.h>
  60. #endif
  62. /* In Solaris (and perhaps others) PATH_MAX is in limits.h. */
  63. #include <limits.h>
  65. #ifdef __APPLE__
  66. #   include <mach/mach.h>
  67. #   include <IOKit/IOKitLib.h>
  68. #   include <CoreFoundation/CFNumber.h>
  69. #endif
  71. #ifdef HAVE_SYSFS_LIBSYSFS_H
  72. #   include <sysfs/libsysfs.h>
  73. #endif
  75. #include "drms.h"
  76. #include "drmstables.h"
  78. #if !defined( UNDER_CE )
  79. /*****************************************************************************
  80.  * aes_s: AES keys structure
  81.  *****************************************************************************
  82.  * This structure stores a set of keys usable for encryption and decryption
  83.  * with the AES/Rijndael algorithm.
  84.  *****************************************************************************/
  85. struct aes_s
  86. {
  87.     uint32_t pp_enc_keys[ AES_KEY_COUNT + 1 ][ 4 ];
  88.     uint32_t pp_dec_keys[ AES_KEY_COUNT + 1 ][ 4 ];
  89. };
  91. #ifdef __LIBVLC__
  92. # define Digest DigestMD5
  93. #else
  94. /*****************************************************************************
  95.  * md5_s: MD5 message structure
  96.  *****************************************************************************
  97.  * This structure stores the static information needed to compute an MD5
  98.  * hash. It has an extra data buffer to allow non-aligned writes.
  99.  *****************************************************************************/
  100. struct md5_s
  101. {
  102.     uint64_t i_bits;      /* Total written bits */
  103.     uint32_t p_digest[4]; /* The MD5 digest */
  104.     uint32_t p_data[16];  /* Buffer to cache non-aligned writes */
  105. };
  106. #endif
  108. /*****************************************************************************
  109.  * shuffle_s: shuffle structure
  110.  *****************************************************************************
  111.  * This structure stores the static information needed to shuffle data using
  112.  * a custom algorithm.
  113.  *****************************************************************************/
  114. struct shuffle_s
  115. {
  116.     uint32_t i_version;
  117.     uint32_t p_commands[ 20 ];
  118.     uint32_t p_bordel[ 16 ];
  119. };
  121. #define SWAP( a, b ) { (a) ^= (b); (b) ^= (a); (a) ^= (b); }
  123. /*****************************************************************************
  124.  * drms_s: DRMS structure
  125.  *****************************************************************************
  126.  * This structure stores the static information needed to decrypt DRMS data.
  127.  *****************************************************************************/
  128. struct drms_s
  129. {
  130.     uint32_t i_user;
  131.     uint32_t i_key;
  132.     uint8_t  p_iviv[ 16 ];
  133.     uint8_t *p_name;
  135.     uint32_t p_key[ 4 ];
  136.     struct aes_s aes;
  138.     char     psz_homedir[ PATH_MAX ];
  139. };
  141. /*****************************************************************************
  142.  * Local prototypes
  143.  *****************************************************************************/
  144. static void InitAES       ( struct aes_s *, uint32_t * );
  145. static void DecryptAES    ( struct aes_s *, uint32_t *, const uint32_t * );
  147. #ifndef __LIBVLC__
  148. static void InitMD5       ( struct md5_s * );
  149. static void AddMD5        ( struct md5_s *, const uint8_t *, uint32_t );
  150. static void EndMD5        ( struct md5_s * );
  151. static void Digest        ( struct md5_s *, uint32_t * );
  152. #endif
  154. static void InitShuffle   ( struct shuffle_s *, uint32_t *, uint32_t );
  155. static void DoShuffle     ( struct shuffle_s *, uint32_t *, uint32_t );
  157. static uint32_t FirstPass ( uint32_t * );
  158. static void SecondPass    ( uint32_t *, uint32_t );
  159. static void ThirdPass     ( uint32_t * );
  160. static void FourthPass    ( uint32_t * );
  161. static void TinyShuffle1  ( uint32_t * );
  162. static void TinyShuffle2  ( uint32_t * );
  163. static void TinyShuffle3  ( uint32_t * );
  164. static void TinyShuffle4  ( uint32_t * );
  165. static void TinyShuffle5  ( uint32_t * );
  166. static void TinyShuffle6  ( uint32_t * );
  167. static void TinyShuffle7  ( uint32_t * );
  168. static void TinyShuffle8  ( uint32_t * );
  169. static void DoExtShuffle  ( uint32_t * );
  171. static int GetSystemKey   ( uint32_t *, bool );
  172. static int WriteUserKey   ( void *, uint32_t * );
  173. static int ReadUserKey    ( void *, uint32_t * );
  174. static int GetUserKey     ( void *, uint32_t * );
  176. static int GetSCIData     ( char *, uint32_t **, uint32_t * );
  177. static int HashSystemInfo ( uint32_t * );
  178. static int GetiPodID      ( int64_t * );
  180. #ifdef WORDS_BIGENDIAN
  181. /*****************************************************************************
  182.  * Reverse: reverse byte order
  183.  *****************************************************************************/
  184. static inline void Reverse( uint32_t *p_buffer, int n )
  185. {
  186.     int i;
  188.     for( i = 0; i < n; i++ )
  189.     {
  190.         p_buffer[ i ] = GetDWLE(&p_buffer[ i ]);
  191.     }
  192. }
  193. #    define REVERSE( p, n ) Reverse( p, n )
  194. #else
  195. #    define REVERSE( p, n )
  196. #endif
  198. /*****************************************************************************
  199.  * BlockXOR: XOR two 128 bit blocks
  200.  *****************************************************************************/
  201. static inline void BlockXOR( uint32_t *p_dest, uint32_t *p_s1, uint32_t *p_s2 )
  202. {
  203.     int i;
  205.     for( i = 0; i < 4; i++ )
  206.     {
  207.         p_dest[ i ] = p_s1[ i ] ^ p_s2[ i ];
  208.     }
  209. }
  211. /*****************************************************************************
  212.  * drms_alloc: allocate a DRMS structure
  213.  *****************************************************************************/
  214. void *drms_alloc( const char *psz_homedir )
  215. {
  216.     struct drms_s *p_drms;
  218.     p_drms = calloc( 1, sizeof(struct drms_s) );
  219.     if( !p_drms )
  220.         return NULL;
  222.     strncpy( p_drms->psz_homedir, psz_homedir, PATH_MAX );
  223.     p_drms->psz_homedir[ PATH_MAX - 1 ] = '';
  225.     return (void *)p_drms;
  226. }
  228. /*****************************************************************************
  229.  * drms_free: free a previously allocated DRMS structure
  230.  *****************************************************************************/
  231. void drms_free( void *_p_drms )
  232. {
  233.     struct drms_s *p_drms = (struct drms_s *)_p_drms;
  235.     free( (void *)p_drms->p_name );
  236.     free( p_drms );
  237. }
  239. /*****************************************************************************
  240.  * drms_decrypt: unscramble a chunk of data
  241.  *****************************************************************************/
  242. void drms_decrypt( void *_p_drms, uint32_t *p_buffer, uint32_t i_bytes, uint32_t *p_key )
  243. {
  244.     struct drms_s *p_drms = (struct drms_s *)_p_drms;
  245.     uint32_t p_key_buf[ 4 ];
  246.     unsigned int i_blocks;
  248.     /* AES is a block cypher, round down the byte count */
  249.     i_blocks = i_bytes / 16;
  250.     i_bytes = i_blocks * 16;
  252.     /* Initialise the key */
  253.     if( !p_key )
  254.     {
  255.         p_key = p_key_buf;
  256.         memcpy( p_key, p_drms->p_key, 16 );
  257.     }
  259.     /* Unscramble */
  260.     while( i_blocks-- )
  261.     {
  262.         uint32_t p_tmp[ 4 ];
  264.         REVERSE( p_buffer, 4 );
  265.         DecryptAES( &p_drms->aes, p_tmp, p_buffer );
  266.         BlockXOR( p_tmp, p_key, p_tmp );
  268.         /* Use the previous scrambled data as the key for next block */
  269.         memcpy( p_key, p_buffer, 16 );
  271.         /* Copy unscrambled data back to the buffer */
  272.         memcpy( p_buffer, p_tmp, 16 );
  273.         REVERSE( p_buffer, 4 );
  275.         p_buffer += 4;
  276.     }
  277. }
  279. /*****************************************************************************
  280.  * drms_get_p_key: copy the p_key into user buffer
  281.  ****************************************************************************/
  282. void drms_get_p_key( void *_p_drms, uint32_t *p_key )
  283. {
  284.     struct drms_s *p_drms = (struct drms_s *)_p_drms;
  286.     memcpy( p_key, p_drms->p_key, 16 );
  287. }
  289. /*****************************************************************************
  290.  * drms_init: initialise a DRMS structure
  291.  *****************************************************************************
  292.  * Return values:
  293.  *  0: success
  294.  * -1: unimplemented
  295.  * -2: invalid argument
  296.  * -3: could not get system key
  297.  * -4: could not get SCI data
  298.  * -5: no user key found in SCI data
  299.  * -6: invalid user key
  300.  *****************************************************************************/
  301. int drms_init( void *_p_drms, uint32_t i_type,
  302.                uint8_t *p_info, uint32_t i_len )
  303. {
  304.     struct drms_s *p_drms = (struct drms_s *)_p_drms;
  305.     int i_ret = 0;
  307.     switch( i_type )
  308.     {
  309.         case FOURCC_user:
  310.             if( i_len < sizeof(p_drms->i_user) )
  311.             {
  312.                 i_ret = -2;
  313.                 break;
  314.             }
  316.             p_drms->i_user = U32_AT( p_info );
  317.             break;
  319.         case FOURCC_key:
  320.             if( i_len < sizeof(p_drms->i_key) )
  321.             {
  322.                 i_ret = -2;
  323.                 break;
  324.             }
  326.             p_drms->i_key = U32_AT( p_info );
  327.             break;
  329.         case FOURCC_iviv:
  330.             if( i_len < sizeof(p_drms->p_key) )
  331.             {
  332.                 i_ret = -2;
  333.                 break;
  334.             }
  336.             memcpy( p_drms->p_iviv, p_info, 16 );
  337.             break;
  339.         case FOURCC_name:
  340.             p_drms->p_name = (uint8_t*) strdup( (char *)p_info );
  342.             if( p_drms->p_name == NULL )
  343.             {
  344.                 i_ret = -2;
  345.             }
  346.             break;
  348.         case FOURCC_priv:
  349.         {
  350.             uint32_t p_priv[ 64 ];
  351.             struct md5_s md5;
  353.             if( i_len < 64 )
  354.             {
  355.                 i_ret = -2;
  356.                 break;
  357.             }
  359.             InitMD5( &md5 );
  360.             AddMD5( &md5, p_drms->p_name, strlen( (char *)p_drms->p_name ) );
  361.             AddMD5( &md5, p_drms->p_iviv, 16 );
  362.             EndMD5( &md5 );
  364.             if( p_drms->i_user == 0 && p_drms->i_key == 0 )
  365.             {
  366.                 static const char p_secret[] = "tr1-th3n.y00_by3";
  367.                 memcpy( p_drms->p_key, p_secret, 16 );
  368.                 REVERSE( p_drms->p_key, 4 );
  369.             }
  370.             else
  371.             {
  372.                 i_ret = GetUserKey( p_drms, p_drms->p_key );
  373.                 if( i_ret )
  374.                 {
  375.                     break;
  376.                 }
  377.             }
  379.             InitAES( &p_drms->aes, p_drms->p_key );
  381.             memcpy( p_priv, p_info, 64 );
  382.             memcpy( p_drms->p_key, md5.p_digest, 16 );
  383.             drms_decrypt( p_drms, p_priv, 64, NULL );
  384.             REVERSE( p_priv, 64 );
  386.             if( p_priv[ 0 ] != 0x6e757469 ) /* itun */
  387.             {
  388.                 i_ret = -6;
  389.                 break;
  390.             }
  392.             InitAES( &p_drms->aes, p_priv + 6 );
  393.             memcpy( p_drms->p_key, p_priv + 12, 16 );
  395.             free( (void *)p_drms->p_name );
  396.             p_drms->p_name = NULL;
  397.         }
  398.         break;
  399.     }
  401.     return i_ret;
  402. }
  404. /* The following functions are local */
  406. /*****************************************************************************
  407.  * InitAES: initialise AES/Rijndael encryption/decryption tables
  408.  *****************************************************************************
  409.  * The Advanced Encryption Standard (AES) is described in RFC 3268
  410.  *****************************************************************************/
  411. static void InitAES( struct aes_s *p_aes, uint32_t *p_key )
  412. {
  413.     unsigned int i, t;
  414.     uint32_t i_key, i_seed;
  416.     memset( p_aes->pp_enc_keys[1], 0, 16 );
  417.     memcpy( p_aes->pp_enc_keys[0], p_key, 16 );
  419.     /* Generate the key tables */
  420.     i_seed = p_aes->pp_enc_keys[ 0 ][ 3 ];
  422.     for( i_key = 0; i_key < AES_KEY_COUNT; i_key++ )
  423.     {
  424.         uint32_t j;
  426.         i_seed = AES_ROR( i_seed, 8 );
  428.         j = p_aes_table[ i_key ];
  430.         j ^= p_aes_encrypt[ (i_seed >> 24) & 0xff ]
  431.               ^ AES_ROR( p_aes_encrypt[ (i_seed >> 16) & 0xff ], 8 )
  432.               ^ AES_ROR( p_aes_encrypt[ (i_seed >> 8) & 0xff ], 16 )
  433.               ^ AES_ROR( p_aes_encrypt[ i_seed & 0xff ], 24 );
  435.         j ^= p_aes->pp_enc_keys[ i_key ][ 0 ];
  436.         p_aes->pp_enc_keys[ i_key + 1 ][ 0 ] = j;
  437.         j ^= p_aes->pp_enc_keys[ i_key ][ 1 ];
  438.         p_aes->pp_enc_keys[ i_key + 1 ][ 1 ] = j;
  439.         j ^= p_aes->pp_enc_keys[ i_key ][ 2 ];
  440.         p_aes->pp_enc_keys[ i_key + 1 ][ 2 ] = j;
  441.         j ^= p_aes->pp_enc_keys[ i_key ][ 3 ];
  442.         p_aes->pp_enc_keys[ i_key + 1 ][ 3 ] = j;
  444.         i_seed = j;
  445.     }
  447.     memcpy( p_aes->pp_dec_keys[ 0 ],
  448.             p_aes->pp_enc_keys[ 0 ], 16 );
  450.     for( i = 1; i < AES_KEY_COUNT; i++ )
  451.     {
  452.         for( t = 0; t < 4; t++ )
  453.         {
  454.             uint32_t j, k, l, m, n;
  456.             j = p_aes->pp_enc_keys[ i ][ t ];
  458.             k = (((j >> 7) & 0x01010101) * 27) ^ ((j & 0xff7f7f7f) << 1);
  459.             l = (((k >> 7) & 0x01010101) * 27) ^ ((k & 0xff7f7f7f) << 1);
  460.             m = (((l >> 7) & 0x01010101) * 27) ^ ((l & 0xff7f7f7f) << 1);
  462.             j ^= m;
  464.             n = AES_ROR( l ^ j, 16 ) ^ AES_ROR( k ^ j, 8 ) ^ AES_ROR( j, 24 );
  466.             p_aes->pp_dec_keys[ i ][ t ] = k ^ l ^ m ^ n;
  467.         }
  468.     }
  469. }
  471. /*****************************************************************************
  472.  * DecryptAES: decrypt an AES/Rijndael 128 bit block
  473.  *****************************************************************************/
  474. static void DecryptAES( struct aes_s *p_aes,
  475.                         uint32_t *p_dest, const uint32_t *p_src )
  476. {
  477.     uint32_t p_wtxt[ 4 ]; /* Working cyphertext */
  478.     uint32_t p_tmp[ 4 ];
  479.     unsigned int i_round, t;
  481.     for( t = 0; t < 4; t++ )
  482.     {
  483.         /* FIXME: are there any endianness issues here? */
  484.         p_wtxt[ t ] = p_src[ t ] ^ p_aes->pp_enc_keys[ AES_KEY_COUNT ][ t ];
  485.     }
  487.     /* Rounds 0 - 8 */
  488.     for( i_round = 0; i_round < (AES_KEY_COUNT - 1); i_round++ )
  489.     {
  490.         for( t = 0; t < 4; t++ )
  491.         {
  492.             p_tmp[ t ] = AES_XOR_ROR( p_aes_itable, p_wtxt );
  493.         }
  495.         for( t = 0; t < 4; t++ )
  496.         {
  497.             p_wtxt[ t ] = p_tmp[ t ]
  498.                     ^ p_aes->pp_dec_keys[ (AES_KEY_COUNT - 1) - i_round ][ t ];
  499.         }
  500.     }
  502.     /* Final round (9) */
  503.     for( t = 0; t < 4; t++ )
  504.     {
  505.         p_dest[ t ] = AES_XOR_ROR( p_aes_decrypt, p_wtxt );
  506.         p_dest[ t ] ^= p_aes->pp_dec_keys[ 0 ][ t ];
  507.     }
  508. }
  510. #ifndef __LIBVLC__
  511. /*****************************************************************************
  512.  * InitMD5: initialise an MD5 message
  513.  *****************************************************************************
  514.  * The MD5 message-digest algorithm is described in RFC 1321
  515.  *****************************************************************************/
  516. static void InitMD5( struct md5_s *p_md5 )
  517. {
  518.     p_md5->p_digest[ 0 ] = 0x67452301;
  519.     p_md5->p_digest[ 1 ] = 0xefcdab89;
  520.     p_md5->p_digest[ 2 ] = 0x98badcfe;
  521.     p_md5->p_digest[ 3 ] = 0x10325476;
  523.     memset( p_md5->p_data, 0, 64 );
  524.     p_md5->i_bits = 0;
  525. }
  527. /*****************************************************************************
  528.  * AddMD5: add i_len bytes to an MD5 message
  529.  *****************************************************************************/
  530. static void AddMD5( struct md5_s *p_md5, const uint8_t *p_src, uint32_t i_len )
  531. {
  532.     unsigned int i_current; /* Current bytes in the spare buffer */
  533.     unsigned int i_offset = 0;
  535.     i_current = (p_md5->i_bits / 8) & 63;
  537.     p_md5->i_bits += 8 * i_len;
  539.     /* If we can complete our spare buffer to 64 bytes, do it and add the
  540.      * resulting buffer to the MD5 message */
  541.     if( i_len >= (64 - i_current) )
  542.     {
  543.         memcpy( ((uint8_t *)p_md5->p_data) + i_current, p_src,
  544.                 (64 - i_current) );
  545.         Digest( p_md5, p_md5->p_data );
  547.         i_offset += (64 - i_current);
  548.         i_len -= (64 - i_current);
  549.         i_current = 0;
  550.     }
  552.     /* Add as many entire 64 bytes blocks as we can to the MD5 message */
  553.     while( i_len >= 64 )
  554.     {
  555.         uint32_t p_tmp[ 16 ];
  556.         memcpy( p_tmp, p_src + i_offset, 64 );
  557.         Digest( p_md5, p_tmp );
  558.         i_offset += 64;
  559.         i_len -= 64;
  560.     }
  562.     /* Copy our remaining data to the message's spare buffer */
  563.     memcpy( ((uint8_t *)p_md5->p_data) + i_current, p_src + i_offset, i_len );
  564. }
  566. /*****************************************************************************
  567.  * EndMD5: finish an MD5 message
  568.  *****************************************************************************
  569.  * This function adds adequate padding to the end of the message, and appends
  570.  * the bit count so that we end at a block boundary.
  571.  *****************************************************************************/
  572. static void EndMD5( struct md5_s *p_md5 )
  573. {
  574.     unsigned int i_current;
  576.     i_current = (p_md5->i_bits / 8) & 63;
  578.     /* Append 0x80 to our buffer. No boundary check because the temporary
  579.      * buffer cannot be full, otherwise AddMD5 would have emptied it. */
  580.     ((uint8_t *)p_md5->p_data)[ i_current++ ] = 0x80;
  582.     /* If less than 8 bytes are available at the end of the block, complete
  583.      * this 64 bytes block with zeros and add it to the message. We'll add
  584.      * our length at the end of the next block. */
  585.     if( i_current > 56 )
  586.     {
  587.         memset( ((uint8_t *)p_md5->p_data) + i_current, 0, (64 - i_current) );
  588.         Digest( p_md5, p_md5->p_data );
  589.         i_current = 0;
  590.     }
  592.     /* Fill the unused space in our last block with zeroes and put the
  593.      * message length at the end. */
  594.     memset( ((uint8_t *)p_md5->p_data) + i_current, 0, (56 - i_current) );
  595.     p_md5->p_data[ 14 ] = p_md5->i_bits & 0xffffffff;
  596.     p_md5->p_data[ 15 ] = (p_md5->i_bits >> 32);
  597.     REVERSE( &p_md5->p_data[ 14 ], 2 );
  599.     Digest( p_md5, p_md5->p_data );
  600. }
  602. #define F1( x, y, z ) ((z) ^ ((x) & ((y) ^ (z))))
  603. #define F2( x, y, z ) F1((z), (x), (y))
  604. #define F3( x, y, z ) ((x) ^ (y) ^ (z))
  605. #define F4( x, y, z ) ((y) ^ ((x) | ~(z)))
  607. #define MD5_DO( f, w, x, y, z, data, s ) 
  608.     ( w += f(x, y, z) + data,  w = w<<s | w>>(32-s),  w += x )
  610. /*****************************************************************************
  611.  * Digest: update the MD5 digest with 64 bytes of data
  612.  *****************************************************************************/
  613. static void Digest( struct md5_s *p_md5, uint32_t *p_input )
  614. {
  615.     uint32_t a, b, c, d;
  617.     REVERSE( p_input, 16 );
  619.     a = p_md5->p_digest[ 0 ];
  620.     b = p_md5->p_digest[ 1 ];
  621.     c = p_md5->p_digest[ 2 ];
  622.     d = p_md5->p_digest[ 3 ];
  624.     MD5_DO( F1, a, b, c, d, p_input[  0 ] + 0xd76aa478,  7 );
  625.     MD5_DO( F1, d, a, b, c, p_input[  1 ] + 0xe8c7b756, 12 );
  626.     MD5_DO( F1, c, d, a, b, p_input[  2 ] + 0x242070db, 17 );
  627.     MD5_DO( F1, b, c, d, a, p_input[  3 ] + 0xc1bdceee, 22 );
  628.     MD5_DO( F1, a, b, c, d, p_input[  4 ] + 0xf57c0faf,  7 );
  629.     MD5_DO( F1, d, a, b, c, p_input[  5 ] + 0x4787c62a, 12 );
  630.     MD5_DO( F1, c, d, a, b, p_input[  6 ] + 0xa8304613, 17 );
  631.     MD5_DO( F1, b, c, d, a, p_input[  7 ] + 0xfd469501, 22 );
  632.     MD5_DO( F1, a, b, c, d, p_input[  8 ] + 0x698098d8,  7 );
  633.     MD5_DO( F1, d, a, b, c, p_input[  9 ] + 0x8b44f7af, 12 );
  634.     MD5_DO( F1, c, d, a, b, p_input[ 10 ] + 0xffff5bb1, 17 );
  635.     MD5_DO( F1, b, c, d, a, p_input[ 11 ] + 0x895cd7be, 22 );
  636.     MD5_DO( F1, a, b, c, d, p_input[ 12 ] + 0x6b901122,  7 );
  637.     MD5_DO( F1, d, a, b, c, p_input[ 13 ] + 0xfd987193, 12 );
  638.     MD5_DO( F1, c, d, a, b, p_input[ 14 ] + 0xa679438e, 17 );
  639.     MD5_DO( F1, b, c, d, a, p_input[ 15 ] + 0x49b40821, 22 );
  641.     MD5_DO( F2, a, b, c, d, p_input[  1 ] + 0xf61e2562,  5 );
  642.     MD5_DO( F2, d, a, b, c, p_input[  6 ] + 0xc040b340,  9 );
  643.     MD5_DO( F2, c, d, a, b, p_input[ 11 ] + 0x265e5a51, 14 );
  644.     MD5_DO( F2, b, c, d, a, p_input[  0 ] + 0xe9b6c7aa, 20 );
  645.     MD5_DO( F2, a, b, c, d, p_input[  5 ] + 0xd62f105d,  5 );
  646.     MD5_DO( F2, d, a, b, c, p_input[ 10 ] + 0x02441453,  9 );
  647.     MD5_DO( F2, c, d, a, b, p_input[ 15 ] + 0xd8a1e681, 14 );
  648.     MD5_DO( F2, b, c, d, a, p_input[  4 ] + 0xe7d3fbc8, 20 );
  649.     MD5_DO( F2, a, b, c, d, p_input[  9 ] + 0x21e1cde6,  5 );
  650.     MD5_DO( F2, d, a, b, c, p_input[ 14 ] + 0xc33707d6,  9 );
  651.     MD5_DO( F2, c, d, a, b, p_input[  3 ] + 0xf4d50d87, 14 );
  652.     MD5_DO( F2, b, c, d, a, p_input[  8 ] + 0x455a14ed, 20 );
  653.     MD5_DO( F2, a, b, c, d, p_input[ 13 ] + 0xa9e3e905,  5 );
  654.     MD5_DO( F2, d, a, b, c, p_input[  2 ] + 0xfcefa3f8,  9 );
  655.     MD5_DO( F2, c, d, a, b, p_input[  7 ] + 0x676f02d9, 14 );
  656.     MD5_DO( F2, b, c, d, a, p_input[ 12 ] + 0x8d2a4c8a, 20 );
  658.     MD5_DO( F3, a, b, c, d, p_input[  5 ] + 0xfffa3942,  4 );
  659.     MD5_DO( F3, d, a, b, c, p_input[  8 ] + 0x8771f681, 11 );
  660.     MD5_DO( F3, c, d, a, b, p_input[ 11 ] + 0x6d9d6122, 16 );
  661.     MD5_DO( F3, b, c, d, a, p_input[ 14 ] + 0xfde5380c, 23 );
  662.     MD5_DO( F3, a, b, c, d, p_input[  1 ] + 0xa4beea44,  4 );
  663.     MD5_DO( F3, d, a, b, c, p_input[  4 ] + 0x4bdecfa9, 11 );
  664.     MD5_DO( F3, c, d, a, b, p_input[  7 ] + 0xf6bb4b60, 16 );
  665.     MD5_DO( F3, b, c, d, a, p_input[ 10 ] + 0xbebfbc70, 23 );
  666.     MD5_DO( F3, a, b, c, d, p_input[ 13 ] + 0x289b7ec6,  4 );
  667.     MD5_DO( F3, d, a, b, c, p_input[  0 ] + 0xeaa127fa, 11 );
  668.     MD5_DO( F3, c, d, a, b, p_input[  3 ] + 0xd4ef3085, 16 );
  669.     MD5_DO( F3, b, c, d, a, p_input[  6 ] + 0x04881d05, 23 );
  670.     MD5_DO( F3, a, b, c, d, p_input[  9 ] + 0xd9d4d039,  4 );
  671.     MD5_DO( F3, d, a, b, c, p_input[ 12 ] + 0xe6db99e5, 11 );
  672.     MD5_DO( F3, c, d, a, b, p_input[ 15 ] + 0x1fa27cf8, 16 );
  673.     MD5_DO( F3, b, c, d, a, p_input[  2 ] + 0xc4ac5665, 23 );
  675.     MD5_DO( F4, a, b, c, d, p_input[  0 ] + 0xf4292244,  6 );
  676.     MD5_DO( F4, d, a, b, c, p_input[  7 ] + 0x432aff97, 10 );
  677.     MD5_DO( F4, c, d, a, b, p_input[ 14 ] + 0xab9423a7, 15 );
  678.     MD5_DO( F4, b, c, d, a, p_input[  5 ] + 0xfc93a039, 21 );
  679.     MD5_DO( F4, a, b, c, d, p_input[ 12 ] + 0x655b59c3,  6 );
  680.     MD5_DO( F4, d, a, b, c, p_input[  3 ] + 0x8f0ccc92, 10 );
  681.     MD5_DO( F4, c, d, a, b, p_input[ 10 ] + 0xffeff47d, 15 );
  682.     MD5_DO( F4, b, c, d, a, p_input[  1 ] + 0x85845dd1, 21 );
  683.     MD5_DO( F4, a, b, c, d, p_input[  8 ] + 0x6fa87e4f,  6 );
  684.     MD5_DO( F4, d, a, b, c, p_input[ 15 ] + 0xfe2ce6e0, 10 );
  685.     MD5_DO( F4, c, d, a, b, p_input[  6 ] + 0xa3014314, 15 );
  686.     MD5_DO( F4, b, c, d, a, p_input[ 13 ] + 0x4e0811a1, 21 );
  687.     MD5_DO( F4, a, b, c, d, p_input[  4 ] + 0xf7537e82,  6 );
  688.     MD5_DO( F4, d, a, b, c, p_input[ 11 ] + 0xbd3af235, 10 );
  689.     MD5_DO( F4, c, d, a, b, p_input[  2 ] + 0x2ad7d2bb, 15 );
  690.     MD5_DO( F4, b, c, d, a, p_input[  9 ] + 0xeb86d391, 21 );
  692.     p_md5->p_digest[ 0 ] += a;
  693.     p_md5->p_digest[ 1 ] += b;
  694.     p_md5->p_digest[ 2 ] += c;
  695.     p_md5->p_digest[ 3 ] += d;
  696. }
  697. #endif
  699. /*****************************************************************************
  700.  * InitShuffle: initialise a shuffle structure
  701.  *****************************************************************************
  702.  * This function initialises tables in the p_shuffle structure that will be
  703.  * used later by DoShuffle. The only external parameter is p_sys_key.
  704.  *****************************************************************************/
  705. static void InitShuffle( struct shuffle_s *p_shuffle, uint32_t *p_sys_key,
  706.                          uint32_t i_version )
  707. {
  708.     char p_secret1[] = "Tv!*";
  709.     static const char p_secret2[] = "____v8rhvsaAvOKM____FfUH%798=[;."
  710.                                     "____f8677680a634____ba87fnOIf)(*";
  711.     unsigned int i;
  713.     p_shuffle->i_version = i_version;
  715.     /* Fill p_commands using the key and a secret seed */
  716.     for( i = 0; i < 20; i++ )
  717.     {
  718.         struct md5_s md5;
  719.         int32_t i_hash;
  721.         InitMD5( &md5 );
  722.         AddMD5( &md5, (const uint8_t *)p_sys_key, 16 );
  723.         AddMD5( &md5, (const uint8_t *)p_secret1, 4 );
  724.         EndMD5( &md5 );
  726.         p_secret1[ 3 ]++;
  728.         REVERSE( md5.p_digest, 1 );
  729.         i_hash = ((int32_t)U32_AT(md5.p_digest)) % 1024;
  731.         p_shuffle->p_commands[ i ] = i_hash < 0 ? i_hash * -1 : i_hash;
  732.     }
  734.     /* Fill p_bordel with completely meaningless initial values. */
  735.     memcpy( p_shuffle->p_bordel, p_secret2, 64 );
  736.     for( i = 0; i < 4; i++ )
  737.     {
  738.         p_shuffle->p_bordel[ 4 * i ] = U32_AT(p_sys_key + i);
  739.         REVERSE( p_shuffle->p_bordel + 4 * i + 1, 3 );
  740.     }
  741. }
  743. /*****************************************************************************
  744.  * DoShuffle: shuffle buffer
  745.  *****************************************************************************
  746.  * This is so ugly and uses so many MD5 checksums that it is most certainly
  747.  * one-way, though why it needs to be so complicated is beyond me.
  748.  *****************************************************************************/
  749. static void DoShuffle( struct shuffle_s *p_shuffle,
  750.                        uint32_t *p_buffer, uint32_t i_size )
  751. {
  752.     struct md5_s md5;
  753.     uint32_t p_big_bordel[ 16 ];
  754.     uint32_t *p_bordel = p_shuffle->p_bordel;
  755.     unsigned int i;
  757.     static const uint32_t p_secret3[] =
  758.     {
  759.         0xAAAAAAAA, 0x01757700, 0x00554580, 0x01724500, 0x00424580,
  760.         0x01427700, 0x00000080, 0xC1D59D01, 0x80144981, 0x815C8901,
  761.         0x80544981, 0x81D45D01, 0x00000080, 0x81A3BB03, 0x00A2AA82,
  762.         0x01A3BB03, 0x0022A282, 0x813BA202, 0x00000080, 0x6D575737,
  763.         0x4A5275A5, 0x6D525725, 0x4A5254A5, 0x6B725437, 0x00000080,
  764.         0xD5DDB938, 0x5455A092, 0x5D95A013, 0x4415A192, 0xC5DD393A,
  765.         0x00000080, 0x55555555
  766.     };
  767.     static const uint32_t i_secret3 = sizeof(p_secret3)/sizeof(p_secret3[0]);
  769.     static const char p_secret4[] =
  770.         "pbclevtug (p) Nccyr Pbzchgre, Vap.  Nyy Evtugf Erfreirq.";
  771.     static const uint32_t i_secret4 = sizeof(p_secret4)/sizeof(p_secret4[0]); /* It include the terminal '' */
  773.     /* Using the MD5 hash of a memory block is probably not one-way enough
  774.      * for the iTunes people. This function randomises p_bordel depending on
  775.      * the values in p_commands to make things even more messy in p_bordel. */
  776.     for( i = 0; i < 20; i++ )
  777.     {
  778.         uint8_t i_command, i_index;
  780.         if( !p_shuffle->p_commands[ i ] )
  781.         {
  782.             continue;
  783.         }
  785.         i_command = (p_shuffle->p_commands[ i ] & 0x300) >> 8;
  786.         i_index = p_shuffle->p_commands[ i ] & 0xff;
  788.         switch( i_command )
  789.         {
  790.         case 0x3:
  791.             p_bordel[ i_index & 0xf ] = p_bordel[ i_index >> 4 ]
  792.                                       + p_bordel[ ((i_index + 0x10) >> 4) & 0xf ];
  793.             break;
  794.         case 0x2:
  795.             p_bordel[ i_index >> 4 ] ^= p_shuffle_xor[ 0xff - i_index ];
  796.             break;
  797.         case 0x1:
  798.             p_bordel[ i_index >> 4 ] -= p_shuffle_sub[ 0xff - i_index ];
  799.             break;
  800.         default:
  801.             p_bordel[ i_index >> 4 ] += p_shuffle_add[ 0xff - i_index ];
  802.             break;
  803.         }
  804.     }
  806.     if( p_shuffle->i_version == 0x01000300 )
  807.     {
  808.         DoExtShuffle( p_bordel );
  809.     }
  811.     /* Convert our newly randomised p_bordel to big endianness and take
  812.      * its MD5 hash. */
  813.     InitMD5( &md5 );
  814.     for( i = 0; i < 16; i++ )
  815.     {
  816.         p_big_bordel[ i ] = U32_AT(p_bordel + i);
  817.     }
  818.     AddMD5( &md5, (const uint8_t *)p_big_bordel, 64 );
  819.     if( p_shuffle->i_version == 0x01000300 )
  820.     {
  821.         uint32_t p_tmp3[i_secret3];
  822.         char     p_tmp4[i_secret4];
  824.         memcpy( p_tmp3, p_secret3, sizeof(p_secret3) );
  825.         REVERSE( p_tmp3, i_secret3 );
  827. #define ROT13(c) (((c)>='A'&&(c)<='Z')?(((c)-'A'+13)%26)+'A':
  828.                       ((c)>='a'&&(c)<='z')?(((c)-'a'+13)%26)+'a':c)
  829.         for( uint32_t i = 0; i < i_secret4; i++ )
  830.             p_tmp4[i] = ROT13( p_secret4[i] );
  831. #undef ROT13
  833.         AddMD5( &md5, (const uint8_t *)p_tmp3, sizeof(p_secret3) );
  834.         AddMD5( &md5, (const uint8_t *)p_tmp4, i_secret4 );
  835.     }
  836.     EndMD5( &md5 );
  838.     /* XOR our buffer with the computed checksum */
  839.     for( i = 0; i < i_size; i++ )
  840.     {
  841.         p_buffer[ i ] ^= md5.p_digest[ i ];
  842.     }
  843. }
  845. /*****************************************************************************
  846.  * DoExtShuffle: extended shuffle
  847.  *****************************************************************************
  848.  * This is even uglier.
  849.  *****************************************************************************/
  850. static void DoExtShuffle( uint32_t * p_bordel )
  851. {
  852.     uint32_t i_ret;
  854.     i_ret = FirstPass( p_bordel );
  856.     SecondPass( p_bordel, i_ret );
  858.     ThirdPass( p_bordel );
  860.     FourthPass( p_bordel );
  861. }
  863. static uint32_t FirstPass( uint32_t * p_bordel )
  864. {
  865.     uint32_t i, i_cmd, i_ret = 5;
  867.     TinyShuffle1( p_bordel );
  869.     for( ; ; )
  870.     {
  871.         for( ; ; )
  872.         {
  873.             p_bordel[ 1 ] += 0x10000000;
  874.             p_bordel[ 3 ] += 0x12777;
  876.             if( (p_bordel[ 10 ] & 1) && i_ret )
  877.             {
  878.                 i_ret--;
  879.                 p_bordel[ 1 ] -= p_bordel[ 2 ];
  880.                 p_bordel[ 11 ] += p_bordel[ 12 ];
  881.                 break;
  882.             }
  884.             if( (p_bordel[ 1 ] + p_bordel[ 2 ]) >= 0x7D0 )
  885.             {
  886.                 switch( ((p_bordel[ 3 ] ^ 0x567F) >> 2) & 7 )
  887.                 {
  888.                     case 0:
  889.                         for( i = 0; i < 3; i++ )
  890.                         {
  891.                             if( p_bordel[ i + 10 ] > 0x4E20 )
  892.                             {
  893.                                 p_bordel[ i + 1 ] += p_bordel[ i + 2 ];
  894.                             }
  895.                         }
  896.                         break;
  897.                     case 4:
  898.                         p_bordel[ 1 ] -= p_bordel[ 2 ];
  899.                         /* no break */
  900.                     case 3:
  901.                         p_bordel[ 11 ] += p_bordel[ 12 ];
  902.                         break;
  903.                     case 6:
  904.                         p_bordel[ 3 ] ^= p_bordel[ 4 ];
  905.                         /* no break */
  906.                     case 8:
  907.                         p_bordel[ 13 ] &= p_bordel[ 14 ];
  908.                         /* no break */
  909.                     case 1:
  910.                         p_bordel[ 0 ] |= p_bordel[ 1 ];
  911.                         if( i_ret )
  912.                         {
  913.                             return i_ret;
  914.                         }
  915.                         break;
  916.                 }
  918.                 break;
  919.             }
  920.         }
  922.         for( i = 0, i_cmd = 0; i < 16; i++ )
  923.         {
  924.             if( p_bordel[ i ] < p_bordel[ i_cmd ] )
  925.             {
  926.                 i_cmd = i;
  927.             }
  928.         }
  930.         if( i_ret && i_cmd != 5 )
  931.         {
  932.             i_ret--;
  933.         }
  934.         else
  935.         {
  936.             if( i_cmd == 5 )
  937.             {
  938.                 p_bordel[ 8 ] &= p_bordel[ 6 ] >> 1;
  939.                 p_bordel[ 3 ] <<= 1;
  940.             }
  942.             for( i = 0; i < 3; i++ )
  943.             {
  944.                 p_bordel[ 11 ] += 1;
  945.                 if( p_bordel[ 11 ] & 5 )
  946.                 {
  947.                     p_bordel[ 8 ] += p_bordel[ 9 ];
  948.                 }
  949.                 else if( i_ret )
  950.                 {
  951.                     i_ret--;
  952.                     i_cmd = 3;
  953.                     goto break2;
  954.                 }
  955.             }
  957.             i_cmd = (p_bordel[ 15 ] + 0x93) >> 3;
  958.             if( p_bordel[ 15 ] & 0x100 )
  959.             {
  960.                 i_cmd ^= 0xDEAD;
  961.             }
  962.         }
  964.         switch( i_cmd & 3 )
  965.         {
  966.             case 0:
  967.                 while( p_bordel[ 11 ] & 1 )
  968.                 {
  969.                     p_bordel[ 11 ] >>= 1;
  970.                     p_bordel[ 12 ] += 1;
  971.                 }
  972.                 /* no break */
  973.             case 2:
  974.                 p_bordel[ 14 ] -= 0x19FE;
  975.                 break;
  976.             case 3:
  977.                 if( i_ret )
  978.                 {
  979.                     i_ret--;
  980.                     p_bordel[ 5 ] += 5;
  981.                     continue;
  982.                 }
  983.                 break;
  984.         }
  986.         i_cmd = ((p_bordel[ 3 ] + p_bordel[ 4 ] + 10) >> 1) - p_bordel[ 4 ];
  987.         break;
  988.     }
  989. break2:
  991.     switch( i_cmd & 3 )
  992.     {
  993.         case 0:
  994.             p_bordel[ 14 ] >>= 1;
  995.             break;
  996.         case 1:
  997.             p_bordel[ 5 ] <<= 2;
  998.             break;
  999.         case 2:
  1000.             p_bordel[ 12 ] |= 5;
  1001.             break;
  1002.         case 3:
  1003.             p_bordel[ 15 ] &= 0x55;
  1004.             if( i_ret )
  1005.             {
  1006.                 p_bordel[ 2 ] &= 0xB62FC;
  1007.                 return i_ret;
  1008.             }
  1009.             break;
  1010.     }
  1012.     TinyShuffle2( p_bordel );
  1014.     return i_ret;
  1015. }
  1017. static void SecondPass( uint32_t * p_bordel, uint32_t i_tmp )
  1018. {
  1019.     uint32_t i, i_cmd, i_jc = 5;
  1021.     TinyShuffle3( p_bordel );
  1023.     for( i = 0, i_cmd = 0; i < 16; i++ )
  1024.     {
  1025.         if( p_bordel[ i ] > p_bordel[ i_cmd ] )
  1026.         {
  1027.             i_cmd = i;
  1028.         }
  1029.     }
  1031.     switch( i_cmd )
  1032.     {
  1033.         case 0:
  1034.             if( p_bordel[ 1 ] < p_bordel[ 8 ] )
  1035.             {
  1036.                 p_bordel[ 5 ] += 1;
  1037.             }
  1038.             break;
  1039.         case 4:
  1040.             if( (p_bordel[ 9 ] & 0x7777) == 0x3333 )
  1041.             {
  1042.                 p_bordel[ 5 ] -= 1;
  1043.             }
  1044.             else
  1045.             {
  1046.                 i_jc--;
  1047.                 if( p_bordel[ 1 ] < p_bordel[ 8 ] )
  1048.                 {
  1049.                     p_bordel[ 5 ] += 1;
  1050.                 }
  1051.                 break;
  1052.             }
  1053.             /* no break */
  1054.         case 7:
  1055.             p_bordel[ 2 ] -= 1;
  1056.             p_bordel[ 1 ] -= p_bordel[ 5 ];
  1057.             for( i = 0; i < 3; i++ )
  1058.             {
  1059.                 switch( p_bordel[ 1 ] & 3 )
  1060.                 {
  1061.                     case 0:
  1062.                         p_bordel[ 1 ] += 1;
  1063.                         /* no break */
  1064.                     case 1:
  1065.                         p_bordel[ 3 ] -= 8;
  1066.                         break;
  1067.                     case 2:
  1068.                         p_bordel[ 13 ] &= 0xFEFEFEF7;
  1069.                         break;
  1070.                     case 3:
  1071.                         p_bordel[ 8 ] |= 0x80080011;
  1072.                         break;
  1073.                 }
  1074.             }
  1075.             return;
  1076.         case 10:
  1077.             p_bordel[ 4 ] -= 1;
  1078.             p_bordel[ 5 ] += 1;
  1079.             p_bordel[ 6 ] -= 1;
  1080.             p_bordel[ 7 ] += 1;
  1081.             break;
  1082.         default:
  1083.             p_bordel[ 15 ] ^= 0x18547EFF;
  1084.             break;
  1085.     }
  1087.     for( i = 3; i--; )
  1088.     {
  1089.         switch( ( p_bordel[ 12 ] + p_bordel[ 13 ] + p_bordel[ 6 ] ) % 5 )
  1090.         {
  1091.             case 0:
  1092.                 p_bordel[ 12 ] -= 1;
  1093.                 /* no break */
  1094.             case 1:
  1095.                 p_bordel[ 12 ] -= 1;
  1096.                 p_bordel[ 13 ] += 1;
  1097.                 break;
  1098.             case 2:
  1099.                 p_bordel[ 13 ] += 4;
  1100.                 /* no break */
  1101.             case 3:
  1102.                 p_bordel[ 12 ] -= 1;
  1103.                 break;
  1104.             case 4:
  1105.                 i_jc--;
  1106.                 p_bordel[ 5 ] += 1;
  1107.                 p_bordel[ 6 ] -= 1;
  1108.                 p_bordel[ 7 ] += 1;
  1109.                 i = 3; /* Restart the whole loop */
  1110.                 break;
  1111.         }
  1112.     }
  1114.     TinyShuffle4( p_bordel );
  1116.     for( ; ; )
  1117.     {
  1118.         TinyShuffle5( p_bordel );
  1120.         switch( ( p_bordel[ 2 ] * 2 + 15 ) % 5 )
  1121.         {
  1122.             case 0:
  1123.                 if( ( p_bordel[ 3 ] + i_tmp ) <=
  1124.                     ( p_bordel[ 1 ] + p_bordel[ 15 ] ) )
  1125.                 {
  1126.                     p_bordel[ 3 ] += 1;
  1127.                 }
  1128.                 break;
  1129.             case 4:
  1130.                 p_bordel[ 10 ] -= 0x13;
  1131.                 break;
  1132.             case 3:
  1133.                 p_bordel[ 5 ] >>= 2;
  1134.                 break;
  1135.         }
  1137.         if( !( p_bordel[ 2 ] & 1 ) || i_jc == 0 )
  1138.         {
  1139.             break;
  1140.         }
  1142.         i_jc--;
  1143.         p_bordel[ 2 ] += 0x13;
  1144.         p_bordel[ 12 ] += 1;
  1145.     }
  1147.     p_bordel[ 2 ] &= 0x10076000;
  1148. }
  1150. static void ThirdPass( uint32_t * p_bordel )
  1151. {
  1152.     uint32_t i_cmd;
  1154.     i_cmd = ((p_bordel[ 7 ] + p_bordel[ 14 ] + 10) >> 1) - p_bordel[ 14 ];
  1155.     i_cmd = i_cmd % 10;
  1157.     switch( i_cmd )
  1158.     {
  1159.         case 0:
  1160.             p_bordel[ 1 ] <<= 1;
  1161.             p_bordel[ 2 ] <<= 2;
  1162.             p_bordel[ 3 ] <<= 3;
  1163.             break;
  1164.         case 6:
  1165.             p_bordel[ i_cmd + 3 ] &= 0x5EDE36B;
  1166.             p_bordel[ 5 ] += p_bordel[ 8 ];
  1167.             p_bordel[ 4 ] += p_bordel[ 7 ];
  1168.             p_bordel[ 3 ] += p_bordel[ 6 ];
  1169.             p_bordel[ 2 ] += p_bordel[ 5 ];
  1170.             /* no break */
  1171.         case 2:
  1172.             p_bordel[ 1 ] += p_bordel[ 4 ];
  1173.             p_bordel[ 0 ] += p_bordel[ 3 ];
  1174.             TinyShuffle6( p_bordel );
  1175.             return; /* jc = 4 */
  1176.         case 3:
  1177.             if( (p_bordel[ 11 ] & p_bordel[ 2 ]) > 0x211B )
  1178.             {
  1179.                 p_bordel[ 6 ] += 1;
  1180.             }
  1181.             break;
  1182.         case 4:
  1183.             p_bordel[ 7 ] += 1;
  1184.             /* no break */
  1185.         case 5:
  1186.             p_bordel[ 9 ] ^= p_bordel[ 2 ];
  1187.             break;
  1188.         case 7:
  1189.             p_bordel[ 2 ] ^= (p_bordel[ 1 ] & p_bordel[ 13 ]);
  1190.             break;
  1191.         case 8:
  1192.             p_bordel[ 0 ] -= p_bordel[ 11 ] & p_bordel[ 15 ];
  1193.             return; /* jc = 4 */
  1194.         case 9:
  1195.             p_bordel[ 6 ] >>= (p_bordel[ 14 ] & 3);
  1196.             break;
  1197.     }
  1199.     SWAP( p_bordel[ 0 ], p_bordel[ 10 ] );
  1201.     TinyShuffle6( p_bordel );
  1203.     return; /* jc = 5 */
  1204. }
  1206. static void FourthPass( uint32_t * p_bordel )
  1207. {
  1208.     uint32_t i, j;
  1210.     TinyShuffle7( p_bordel );
  1212.     switch( p_bordel[ 5 ] % 5)
  1213.     {
  1214.         case 0:
  1215.             p_bordel[ 0 ] += 1;
  1216.             break;
  1217.         case 2:
  1218.             p_bordel[ 11 ] ^= (p_bordel[ 3 ] + p_bordel[ 6 ] + p_bordel[ 8 ]);
  1219.             break;
  1220.         case 3:
  1221.             for( i = 4; i < 15 && (p_bordel[ i ] & 5) == 0; i++ )
  1222.             {
  1223.                 SWAP( p_bordel[ i ], p_bordel[ 15 - i ] );
  1224.             }
  1225.             break;
  1226.         case 4:
  1227.             p_bordel[ 12 ] -= 1;
  1228.             p_bordel[ 13 ] += 1;
  1229.             p_bordel[ 2 ] -= 0x64;
  1230.             p_bordel[ 3 ] += 0x64;
  1231.             TinyShuffle8( p_bordel );
  1232.             return;
  1233.     }
  1235.     for( i = 0, j = 0; i < 16; i++ )
  1236.     {
  1237.         if( p_bordel[ i ] > p_bordel[ j ] )
  1238.         {
  1239.             j = i;
  1240.         }
  1241.     }
  1243.     switch( p_bordel[ j ] % 100 )
  1244.     {
  1245.         case 0:
  1246.             SWAP( p_bordel[ 0 ], p_bordel[ j ] );
  1247.             break;
  1248.         case 8:
  1249.             p_bordel[ 1 ] >>= 1;
  1250.             p_bordel[ 2 ] <<= 1;
  1251.             p_bordel[ 14 ] >>= 3;
  1252.             p_bordel[ 15 ] <<= 4;
  1253.             break;
  1254.         case 57:
  1255.             p_bordel[ j ] += p_bordel[ 13 ];
  1256.             break;
  1257.         case 76:
  1258.             p_bordel[ 1 ] += 0x20E;
  1259.             p_bordel[ 5 ] += 0x223D;
  1260.             p_bordel[ 13 ] -= 0x576;
  1261.             p_bordel[ 15 ] += 0x576;
  1262.             return;
  1263.         case 91:
  1264.             p_bordel[ 2 ] -= 0x64;
  1265.             p_bordel[ 3 ] += 0x64;
  1266.             p_bordel[ 12 ] -= 1;
  1267.             p_bordel[ 13 ] += 1;
  1268.             break;
  1269.         case 99:
  1270.             p_bordel[ 0 ] += 1;
  1271.             p_bordel[ j ] += p_bordel[ 13 ];
  1272.             break;
  1273.     }
  1275.     TinyShuffle8( p_bordel );
  1276. }
  1278. /*****************************************************************************
  1279.  * TinyShuffle[12345678]: tiny shuffle subroutines
  1280.  *****************************************************************************
  1281.  * These standalone functions are little helpers for the shuffling process.
  1282.  *****************************************************************************/
  1283. static void TinyShuffle1( uint32_t * p_bordel )
  1284. {
  1285.     uint32_t i_cmd = (p_bordel[ 5 ] + 10) >> 2;
  1287.     if( p_bordel[ 5 ] > 0x7D0 )
  1288.     {
  1289.         i_cmd -= 0x305;
  1290.     }
  1292.     switch( i_cmd & 3 )
  1293.     {
  1294.         case 0:
  1295.             p_bordel[ 5 ] += 5;
  1296.             break;
  1297.         case 1:
  1298.             p_bordel[ 4 ] -= 1;
  1299.             break;
  1300.         case 2:
  1301.             if( p_bordel[ 4 ] & 5 )
  1302.             {
  1303.                 p_bordel[ 1 ] ^= 0x4D;
  1304.             }
  1305.             /* no break */
  1306.         case 3:
  1307.             p_bordel[ 12 ] += 5;
  1308.             break;
  1309.     }
  1310. }
  1312. static void TinyShuffle2( uint32_t * p_bordel )
  1313. {
  1314.     uint32_t i, j;
  1316.     for( i = 0, j = 0; i < 16; i++ )
  1317.     {
  1318.         if( (p_bordel[ i ] & 0x777) > (p_bordel[ j ] & 0x777) )
  1319.         {
  1320.             j = i;
  1321.         }
  1322.     }
  1324.     if( j > 5 )
  1325.     {
  1326.         for( ; j < 15; j++ )
  1327.         {
  1328.             p_bordel[ j ] += p_bordel[ j + 1 ];
  1329.         }
  1330.     }
  1331.     else
  1332.     {
  1333.         p_bordel[ 2 ] &= 0xB62FC;
  1334.     }
  1335. }
  1337. static void TinyShuffle3( uint32_t * p_bordel )
  1338. {
  1339.     uint32_t i_cmd = p_bordel[ 6 ] + 0x194B;
  1341.     if( p_bordel[ 6 ] > 0x2710 )
  1342.     {
  1343.         i_cmd >>= 1;
  1344.     }
  1346.     switch( i_cmd & 3 )
  1347.     {
  1348.         case 1:
  1349.             p_bordel[ 3 ] += 0x19FE;
  1350.             break;
  1351.         case 2:
  1352.             p_bordel[ 7 ] -= p_bordel[ 3 ] >> 2;
  1353.             /* no break */
  1354.         case 0:
  1355.             p_bordel[ 5 ] ^= 0x248A;
  1356.             break;
  1357.     }
  1358. }
  1360. static void TinyShuffle4( uint32_t * p_bordel )
  1361. {
  1362.     uint32_t i, j;
  1364.     for( i = 0, j = 0; i < 16; i++ )
  1365.     {
  1366.         if( p_bordel[ i ] < p_bordel[ j ] )
  1367.         {
  1368.             j = i;
  1369.         }
  1370.     }
  1372.     if( (p_bordel[ j ] % (j + 1)) > 10 )
  1373.     {
  1374.         p_bordel[ 1 ] -= 1;
  1375.         p_bordel[ 2 ] += 0x13;
  1376.         p_bordel[ 12 ] += 1;
  1377.     }
  1378. }
  1380. static void TinyShuffle5( uint32_t * p_bordel )
  1381. {
  1382.     uint32_t i;
  1384.     p_bordel[ 2 ] &= 0x7F3F;
  1386.     for( i = 0; i < 5; i++ )
  1387.     {
  1388.         switch( ( p_bordel[ 2 ] + 10 + i ) % 5 )
  1389.         {
  1390.             case 0:
  1391.                 p_bordel[ 12 ] &= p_bordel[ 2 ];
  1392.                 /* no break */
  1393.             case 1:
  1394.                 p_bordel[ 3 ] ^= p_bordel[ 15 ];
  1395.                 break;
  1396.             case 2:
  1397.                 p_bordel[ 15 ] += 0x576;
  1398.                 /* no break */
  1399.             case 3:
  1400.                 p_bordel[ 7 ] -= 0x2D;
  1401.                 /* no break */
  1402.             case 4:
  1403.                 p_bordel[ 1 ] <<= 1;
  1404.                 break;
  1405.         }
  1406.     }
  1407. }
  1409. static void TinyShuffle6( uint32_t * p_bordel )
  1410. {
  1411.     uint32_t i, j;
  1413.     for( i = 0; i < 8; i++ )
  1414.     {
  1415.         j = p_bordel[ 3 ] & 0x7514 ? 5 : 7;
  1416.         SWAP( p_bordel[ i ], p_bordel[ i + j ] );
  1417.     }
  1418. }
  1420. static void TinyShuffle7( uint32_t * p_bordel )
  1421. {
  1422.     uint32_t i;
  1424.     i = (((p_bordel[ 9 ] + p_bordel[ 15 ] + 12) >> 2) - p_bordel[ 4 ]) & 7;
  1426.     while( i-- )
  1427.     {
  1428.         SWAP( p_bordel[ i ], p_bordel[ i + 3 ] );
  1429.     }
  1431.     SWAP( p_bordel[ 1 ], p_bordel[ 10 ] );
  1432. }
  1434. static void TinyShuffle8( uint32_t * p_bordel )
  1435. {
  1436.     uint32_t i;
  1438.     i = (p_bordel[ 0 ] & p_bordel[ 6 ]) & 0xF;
  1440.     switch( p_bordel[ i ] % 1000 )
  1441.     {
  1442.         case 7:
  1443.             if( (p_bordel[ i ] & 0x777) > (p_bordel[ 7 ] & 0x5555) )
  1444.             {
  1445.                 p_bordel[ i ] ^= p_bordel[ 5 ] & p_bordel[ 3 ];
  1446.             }
  1447.             break;
  1448.         case 19:
  1449.             p_bordel[ 15 ] &= 0x5555;
  1450.             break;
  1451.         case 93:
  1452.             p_bordel[ i ] ^= p_bordel[ 15 ];
  1453.             break;
  1454.         case 100:
  1455.             SWAP( p_bordel[ 0 ], p_bordel[ 3 ] );
  1456.             SWAP( p_bordel[ 1 ], p_bordel[ 6 ] );
  1457.             SWAP( p_bordel[ 3 ], p_bordel[ 6 ] );
  1458.             SWAP( p_bordel[ 4 ], p_bordel[ 9 ] );
  1459.             SWAP( p_bordel[ 5 ], p_bordel[ 8 ] );
  1460.             SWAP( p_bordel[ 6 ], p_bordel[ 7 ] );
  1461.             SWAP( p_bordel[ 13 ], p_bordel[ 14 ] );
  1462.             break;
  1463.         case 329:
  1464.             p_bordel[ i ] += p_bordel[ 1 ] ^ 0x80080011;
  1465.             p_bordel[ i ] += p_bordel[ 2 ] ^ 0xBEEFDEAD;
  1466.             p_bordel[ i ] += p_bordel[ 3 ] ^ 0x8765F444;
  1467.             p_bordel[ i ] += p_bordel[ 4 ] ^ 0x78145326;
  1468.             break;
  1469.         case 567:
  1470.             p_bordel[ 12 ] -= p_bordel[ i ];
  1471.             p_bordel[ 13 ] += p_bordel[ i ];
  1472.             break;
  1473.         case 612:
  1474.             p_bordel[ i ] += p_bordel[ 1 ];
  1475.             p_bordel[ i ] -= p_bordel[ 7 ];
  1476.             p_bordel[ i ] -= p_bordel[ 8 ];
  1477.             p_bordel[ i ] += p_bordel[ 9 ];
  1478.             p_bordel[ i ] += p_bordel[ 13 ];
  1479.             break;
  1480.         case 754:
  1481.             i = __MIN( i, 12 );
  1482.             p_bordel[ i + 1 ] >>= 1;
  1483.             p_bordel[ i + 2 ] <<= 4;
  1484.             p_bordel[ i + 3 ] >>= 3;
  1485.             break;
  1486.         case 777:
  1487.             p_bordel[ 1 ] += 0x20E;
  1488.             p_bordel[ 5 ] += 0x223D;
  1489.             p_bordel[ 13 ] -= 0x576;
  1490.             p_bordel[ 15 ] += 0x576;
  1491.             break;
  1492.         case 981:
  1493.             if( (p_bordel[ i ] ^ 0x8765F441) < 0x2710 )
  1494.             {
  1495.                 SWAP( p_bordel[ 0 ], p_bordel[ 1 ] );
  1496.             }
  1497.             else
  1498.             {
  1499.                 SWAP( p_bordel[ 1 ], p_bordel[ 11 ] );
  1500.             }
  1501.             break;
  1502.     }
  1503. }
  1505. /*****************************************************************************
  1506.  * GetSystemKey: get the system key
  1507.  *****************************************************************************
  1508.  * Compute the system key from various system information, see HashSystemInfo.
  1509.  *****************************************************************************/
  1510. static int GetSystemKey( uint32_t *p_sys_key, bool b_ipod )
  1511. {
  1512.     static const char p_secret5[ 8 ] = "YuaFlafu";
  1513.     static const char p_secret6[ 8 ] = "zPif98ga";
  1514.     struct md5_s md5;
  1515.     int64_t i_ipod_id;
  1516.     uint32_t p_system_hash[ 4 ];
  1518.     /* Compute the MD5 hash of our system info */
  1519.     if( ( !b_ipod && HashSystemInfo( p_system_hash ) ) ||
  1520.         (  b_ipod && GetiPodID( &i_ipod_id ) ) )
  1521.     {
  1522.         return -1;
  1523.     }
  1525.     /* Combine our system info hash with additional secret data. The resulting
  1526.      * MD5 hash will be our system key. */
  1527.     InitMD5( &md5 );
  1528.     AddMD5( &md5, (const uint8_t*)p_secret5, 8 );
  1530.     if( !b_ipod )
  1531.     {
  1532.         AddMD5( &md5, (const uint8_t *)p_system_hash, 6 );
  1533.         AddMD5( &md5, (const uint8_t *)p_system_hash, 6 );
  1534.         AddMD5( &md5, (const uint8_t *)p_system_hash, 6 );
  1535.         AddMD5( &md5, (const uint8_t *)p_secret6, 8 );
  1536.     }
  1537.     else
  1538.     {
  1539.         i_ipod_id = U64_AT(&i_ipod_id);
  1540.         AddMD5( &md5, (const uint8_t *)&i_ipod_id, sizeof(i_ipod_id) );
  1541.         AddMD5( &md5, (const uint8_t *)&i_ipod_id, sizeof(i_ipod_id) );
  1542.         AddMD5( &md5, (const uint8_t *)&i_ipod_id, sizeof(i_ipod_id) );
  1543.     }
  1545.     EndMD5( &md5 );
  1547.     memcpy( p_sys_key, md5.p_digest, 16 );
  1549.     return 0;
  1550. }
  1552. #ifdef WIN32
  1553. #   define DRMS_DIRNAME "drms"
  1554. #else
  1555. #   define DRMS_DIRNAME ".drms"
  1556. #endif
  1558. /*****************************************************************************
  1559.  * WriteUserKey: write the user key to hard disk
  1560.  *****************************************************************************
  1561.  * Write the user key to the hard disk so that it can be reused later or used
  1562.  * on operating systems other than Win32.
  1563.  *****************************************************************************/
  1564. static int WriteUserKey( void *_p_drms, uint32_t *p_user_key )
  1565. {
  1566.     struct drms_s *p_drms = (struct drms_s *)_p_drms;
  1567.     FILE *file;
  1568.     int i_ret = -1;
  1569.     char psz_path[ PATH_MAX ];
  1571.     snprintf( psz_path, PATH_MAX - 1,
  1572.               "%s/" DRMS_DIRNAME, p_drms->psz_homedir );
  1574. #if defined( WIN32 )
  1575.     if( !mkdir( psz_path ) || errno == EEXIST )
  1576. #else
  1577.     if( !mkdir( psz_path, 0755 ) || errno == EEXIST )
  1578. #endif
  1579.     {
  1580.         snprintf( psz_path, PATH_MAX - 1, "%s/" DRMS_DIRNAME "/%08X.%03d",
  1581.                   p_drms->psz_homedir, p_drms->i_user, p_drms->i_key );
  1583.         file = utf8_fopen( psz_path, "wb" );
  1584.         if( file != NULL )
  1585.         {
  1586.             i_ret = fwrite( p_user_key, sizeof(uint32_t),
  1587.                             4, file ) == 4 ? 0 : -1;
  1588.             fclose( file );
  1589.         }
  1590.     }
  1592.     return i_ret;
  1593. }
  1595. /*****************************************************************************
  1596.  * ReadUserKey: read the user key from hard disk
  1597.  *****************************************************************************
  1598.  * Retrieve the user key from the hard disk if available.
  1599.  *****************************************************************************/
  1600. static int ReadUserKey( void *_p_drms, uint32_t *p_user_key )
  1601. {
  1602.     struct drms_s *p_drms = (struct drms_s *)_p_drms;
  1603.     FILE *file;
  1604.     int i_ret = -1;
  1605.     char psz_path[ PATH_MAX ];
  1607.     snprintf( psz_path, PATH_MAX - 1,
  1608.               "%s/" DRMS_DIRNAME "/%08X.%03d", p_drms->psz_homedir,
  1609.               p_drms->i_user, p_drms->i_key );
  1611.     file = utf8_fopen( psz_path, "rb" );
  1612.     if( file != NULL )
  1613.     {
  1614.         i_ret = fread( p_user_key, sizeof(uint32_t),
  1615.                        4, file ) == 4 ? 0 : -1;
  1616.         fclose( file );
  1617.     }
  1619.     return i_ret;
  1620. }
  1622. /*****************************************************************************
  1623.  * GetUserKey: get the user key
  1624.  *****************************************************************************
  1625.  * Retrieve the user key from the hard disk if available, otherwise generate
  1626.  * it from the system key. If the key could be successfully generated, write
  1627.  * it to the hard disk for future use.
  1628.  *****************************************************************************/
  1629. static int GetUserKey( void *_p_drms, uint32_t *p_user_key )
  1630. {
  1631.     static const char p_secret7[] = "mUfnpognadfgf873";
  1632.     struct drms_s *p_drms = (struct drms_s *)_p_drms;
  1633.     struct aes_s aes;
  1634.     struct shuffle_s shuffle;
  1635.     uint32_t i, y;
  1636.     uint32_t *p_sci_data = NULL;
  1637.     uint32_t i_user, i_key;
  1638.     uint32_t p_sys_key[ 4 ];
  1639.     uint32_t i_sci_size = 0, i_blocks, i_remaining;
  1640.     uint32_t *p_sci0, *p_sci1, *p_buffer;
  1641.     uint32_t p_sci_key[ 4 ];
  1642.     char *psz_ipod;
  1643.     int i_ret = -5;
  1645.     if( ReadUserKey( p_drms, p_user_key ) == 0 )
  1646.     {
  1647.         REVERSE( p_user_key, 4 );
  1648.         return 0;
  1649.     }
  1651.     psz_ipod = getenv( "IPOD" );
  1653.     if( GetSystemKey( p_sys_key, psz_ipod ? true : false ) )
  1654.     {
  1655.         return -3;
  1656.     }
  1658.     if( GetSCIData( psz_ipod, &p_sci_data, &i_sci_size ) )
  1659.     {
  1660.         return -4;
  1661.     }
  1663.     /* Phase 1: unscramble the SCI data using the system key and shuffle
  1664.      *          it using DoShuffle(). */
  1666.     /* Skip the first 4 bytes (some sort of header). Decrypt the rest. */
  1667.     i_blocks = (i_sci_size - 4) / 16;
  1668.     i_remaining = (i_sci_size - 4) - (i_blocks * 16);
  1669.     p_buffer = p_sci_data + 1;
  1671.     /* Decrypt and shuffle our data at the same time */
  1672.     InitAES( &aes, p_sys_key );
  1673.     REVERSE( p_sys_key, 4 );
  1674.     REVERSE( p_sci_data, 1 );
  1675.     InitShuffle( &shuffle, p_sys_key, p_sci_data[ 0 ] );
  1677.     memcpy( p_sci_key, p_secret7, 16 );
  1678.     REVERSE( p_sci_key, 4 );
  1680.     while( i_blocks-- )
  1681.     {
  1682.         uint32_t p_tmp[ 4 ];
  1684.         REVERSE( p_buffer, 4 );
  1685.         DecryptAES( &aes, p_tmp, p_buffer );
  1686.         BlockXOR( p_tmp, p_sci_key, p_tmp );
  1688.         /* Use the previous scrambled data as the key for next block */
  1689.         memcpy( p_sci_key, p_buffer, 16 );
  1691.         /* Shuffle the decrypted data using a custom routine */
  1692.         DoShuffle( &shuffle, p_tmp, 4 );
  1694.         /* Copy this block back to p_buffer */
  1695.         memcpy( p_buffer, p_tmp, 16 );
  1697.         p_buffer += 4;
  1698.     }
  1700.     if( i_remaining >= 4 )
  1701.     {
  1702.         REVERSE( p_buffer, i_remaining / 4 );
  1703.         DoShuffle( &shuffle, p_buffer, i_remaining / 4 );
  1704.     }
  1706.     /* Phase 2: look for the user key in the generated data. I must admit I
  1707.      *          do not understand what is going on here, because it almost
  1708.      *          looks like we are browsing data that makes sense, even though
  1709.      *          the DoShuffle() part made it completely meaningless. */
  1711.     y = 0;
  1712.     REVERSE( p_sci_data + 5, 1 );
  1713.     i = U32_AT( p_sci_data + 5 );
  1714.     i_sci_size -= 22 * sizeof(uint32_t);
  1715.     p_sci1 = p_sci_data + 22;
  1716.     p_sci0 = NULL;
  1718.     while( i_sci_size >= 20 && i > 0 )
  1719.     {
  1720.         if( p_sci0 == NULL )
  1721.         {
  1722.             i_sci_size -= 18 * sizeof(uint32_t);
  1723.             if( i_sci_size < 20 )
  1724.             {
  1725.                 break;
  1726.             }
  1728.             p_sci0 = p_sci1;
  1729.             REVERSE( p_sci1 + 17, 1 );
  1730.             y = U32_AT( p_sci1 + 17 );
  1731.             p_sci1 += 18;
  1732.         }
  1734.         if( !y )
  1735.         {
  1736.             i--;
  1737.             p_sci0 = NULL;
  1738.             continue;
  1739.         }
  1741.         i_user = U32_AT( p_sci0 );
  1742.         i_key = U32_AT( p_sci1 );
  1743.         REVERSE( &i_user, 1 );
  1744.         REVERSE( &i_key, 1 );
  1745.         if( i_user == p_drms->i_user && ( ( i_key == p_drms->i_key ) ||
  1746.             ( !p_drms->i_key && ( p_sci1 == (p_sci0 + 18) ) ) ) )
  1747.         {
  1748.             memcpy( p_user_key, p_sci1 + 1, 16 );
  1749.             REVERSE( p_sci1 + 1, 4 );
  1750.             WriteUserKey( p_drms, p_sci1 + 1 );
  1751.             i_ret = 0;
  1752.             break;
  1753.         }
  1755.         y--;
  1756.         p_sci1 += 5;
  1757.         i_sci_size -= 5 * sizeof(uint32_t);
  1758.     }
  1760.     free( p_sci_data );
  1762.     return i_ret;
  1763. }
  1765. /*****************************************************************************
  1766.  * GetSCIData: get SCI data from "SC Info.sidb"
  1767.  *****************************************************************************
  1768.  * Read SCI data from "Apple ComputeriTunesSC InfoSC Info.sidb"
  1769.  *****************************************************************************/
  1770. static int GetSCIData( char *psz_ipod, uint32_t **pp_sci,
  1771.                        uint32_t *pi_sci_size )
  1772. {
  1773.     FILE *file;
  1774.     char *psz_path = NULL;
  1775.     char p_tmp[ 4 * PATH_MAX ];
  1776.     int i_ret = -1;
  1778.     if( psz_ipod == NULL )
  1779.     {
  1780. #ifdef WIN32
  1781.         const wchar_t *wfile =
  1782.                 L"\Apple Computer\iTunes\SC Info\SC Info.sidb";
  1783.         typedef HRESULT (WINAPI *SHGETFOLDERPATH)( HWND, int, HANDLE, DWORD,
  1784.                                                    LPWSTR );
  1785.         HINSTANCE shfolder_dll = NULL;
  1786.         SHGETFOLDERPATH dSHGetFolderPath = NULL;
  1787.         wchar_t wpath[PATH_MAX];
  1789.         if( ( shfolder_dll = LoadLibrary( _T("SHFolder.dll") ) ) != NULL )
  1790.         {
  1791.             dSHGetFolderPath =
  1792.                 (SHGETFOLDERPATH)GetProcAddress( shfolder_dll,
  1793.                                                  _T("SHGetFolderPathW") );
  1794.         }
  1796.         if( dSHGetFolderPath != NULL &&
  1797.             SUCCEEDED( dSHGetFolderPath( NULL, CSIDL_COMMON_APPDATA,
  1798.                                          NULL, 0, wpath ) ) )
  1799.         {
  1800.             if (wcslen( wpath ) + wcslen( wfile ) >= PATH_MAX )
  1801.             {
  1802.                 return -1;
  1803.             }
  1804.             wcscat( wpath, wfile );
  1806.             psz_path = FromWide( wpath );
  1807.             strncpy( p_tmp, psz_path, sizeof( p_tmp ) - 1 );
  1808.             p_tmp[sizeof( p_tmp ) - 1] = '';
  1809.             free( psz_path );
  1810.             psz_path = p_tmp;
  1811.         }
  1813.         if( shfolder_dll != NULL )
  1814.         {
  1815.             FreeLibrary( shfolder_dll );
  1816.         }
  1817. #endif
  1818.     }
  1819.     else
  1820.     {
  1821. #define ISCINFO "iSCInfo"
  1822.         if( strstr( psz_ipod, ISCINFO ) == NULL )
  1823.         {
  1824.             snprintf( p_tmp, sizeof(p_tmp) - 1,
  1825.                       "%s/iPod_Control/iTunes/" ISCINFO "2", psz_ipod );
  1826.             psz_path = p_tmp;
  1827.         }
  1828.         else
  1829.         {
  1830.             psz_path = psz_ipod;
  1831.         }
  1832.     }
  1834.     if( psz_path == NULL )
  1835.     {
  1836.         return -1;
  1837.     }
  1839.     file = utf8_fopen( psz_path, "rb" );
  1840.     if( file != NULL )
  1841.     {
  1842.         struct stat st;
  1844.         if( !fstat( fileno( file ), &st ) && st.st_size >= 4 )
  1845.         {
  1846.             *pp_sci = malloc( st.st_size );
  1847.             if( *pp_sci != NULL )
  1848.             {
  1849.                 if( fread( *pp_sci, 1, st.st_size,
  1850.                            file ) == (size_t)st.st_size )
  1851.                 {
  1852.                     *pi_sci_size = st.st_size;
  1853.                     i_ret = 0;
  1854.                 }
  1855.                 else
  1856.                 {
  1857.                     free( (void *)*pp_sci );
  1858.                     *pp_sci = NULL;
  1859.                 }
  1860.             }
  1861.         }
  1863.         fclose( file );
  1864.     }
  1866.     return i_ret;
  1867. }
  1869. /*****************************************************************************
  1870.  * HashSystemInfo: hash system information
  1871.  *****************************************************************************
  1872.  * This function computes the MD5 hash of the C: hard drive serial number,
  1873.  * BIOS version, CPU type and Windows version.
  1874.  *****************************************************************************/
  1875. static int HashSystemInfo( uint32_t *p_system_hash )
  1876. {
  1877.     struct md5_s md5;
  1878.     int i_ret = 0;
  1880. #ifdef WIN32
  1881.     HKEY i_key;
  1882.     unsigned int i;
  1883.     DWORD i_size;
  1884.     DWORD i_serial;
  1885.     LPBYTE p_reg_buf;
  1887.     static const LPCTSTR p_reg_keys[ 3 ][ 2 ] =
  1888.     {
  1889.         {
  1890.             _T("HARDWARE\DESCRIPTION\System"),
  1891.             _T("SystemBiosVersion")
  1892.         },
  1894.         {
  1895.             _T("HARDWARE\DESCRIPTION\System\CentralProcessor\0"),
  1896.             _T("ProcessorNameString")
  1897.         },
  1899.         {
  1900.             _T("SOFTWARE\Microsoft\Windows\CurrentVersion"),
  1901.             _T("ProductId")
  1902.         }
  1903.     };
  1905.     InitMD5( &md5 );
  1907.     AddMD5( &md5, "cache-control", 13 );
  1908.     AddMD5( &md5, "Ethernet", 8 );
  1910.     GetVolumeInformation( _T("C:\"), NULL, 0, &i_serial,
  1911.                           NULL, NULL, NULL, 0 );
  1912.     AddMD5( &md5, (const uint8_t *)&i_serial, 4 );
  1914.     for( i = 0; i < sizeof(p_reg_keys) / sizeof(p_reg_keys[ 0 ]); i++ )
  1915.     {
  1916.         if( RegOpenKeyEx( HKEY_LOCAL_MACHINE, p_reg_keys[ i ][ 0 ],
  1917.                           0, KEY_READ, &i_key ) != ERROR_SUCCESS )
  1918.         {
  1919.             continue;
  1920.         }
  1922.         if( RegQueryValueEx( i_key, p_reg_keys[ i ][ 1 ],
  1923.                              NULL, NULL, NULL, &i_size ) != ERROR_SUCCESS )
  1924.         {
  1925.             RegCloseKey( i_key );
  1926.             continue;
  1927.         }
  1929.         p_reg_buf = malloc( i_size );
  1931.         if( p_reg_buf != NULL )
  1932.         {
  1933.             if( RegQueryValueEx( i_key, p_reg_keys[ i ][ 1 ],
  1934.                                  NULL, NULL, p_reg_buf,
  1935.                                  &i_size ) == ERROR_SUCCESS )
  1936.             {
  1937.                 AddMD5( &md5, (const uint8_t *)p_reg_buf, i_size );
  1938.             }
  1940.             free( p_reg_buf );
  1941.         }
  1943.         RegCloseKey( i_key );
  1944.     }
  1946. #else
  1947.     InitMD5( &md5 );
  1948.     i_ret = -1;
  1949. #endif
  1951.     EndMD5( &md5 );
  1952.     memcpy( p_system_hash, md5.p_digest, 16 );
  1954.     return i_ret;
  1955. }
  1957. /*****************************************************************************
  1958.  * GetiPodID: Get iPod ID
  1959.  *****************************************************************************
  1960.  * This function gets the iPod ID.
  1961.  *****************************************************************************/
  1962. static int GetiPodID( int64_t *p_ipod_id )
  1963. {
  1964.     int i_ret = -1;
  1966. #define PROD_NAME   "iPod"
  1967. #define VENDOR_NAME "Apple Computer, Inc."
  1969.     char *psz_ipod_id = getenv( "IPODID" );
  1970.     if( psz_ipod_id != NULL )
  1971.     {
  1972.         *p_ipod_id = strtoll( psz_ipod_id, NULL, 16 );
  1973.         return 0;
  1974.     }
  1976. #ifdef __APPLE__
  1977.     CFTypeRef value;
  1978.     mach_port_t port;
  1979.     io_object_t device;
  1980.     io_iterator_t iterator;
  1981.     CFMutableDictionaryRef match_dic;
  1982.     CFMutableDictionaryRef smatch_dic;
  1984.     if( IOMasterPort( MACH_PORT_NULL, &port ) == KERN_SUCCESS )
  1985.     {
  1986.         smatch_dic = IOServiceMatching( "IOFireWireUnit" );
  1987.         match_dic = CFDictionaryCreateMutable( kCFAllocatorDefault, 0,
  1988.                                            &kCFTypeDictionaryKeyCallBacks,
  1989.                                            &kCFTypeDictionaryValueCallBacks );
  1991.         if( smatch_dic != NULL && match_dic != NULL )
  1992.         {
  1993.             CFDictionarySetValue( smatch_dic,
  1994.                                   CFSTR("FireWire Vendor Name"),
  1995.                                   CFSTR(VENDOR_NAME) );
  1996.             CFDictionarySetValue( smatch_dic,
  1997.                                   CFSTR("FireWire Product Name"),
  1998.                                   CFSTR(PROD_NAME) );
  2000.             CFDictionarySetValue( match_dic,
  2001.                                   CFSTR(kIOPropertyMatchKey),
  2002.                                   smatch_dic );
  2004.             if( IOServiceGetMatchingServices( port, match_dic,
  2005.                                               &iterator ) == KERN_SUCCESS )
  2006.             {
  2007.                 while( ( device = IOIteratorNext( iterator ) ) != NULL )
  2008.                 {
  2009.                     value = IORegistryEntryCreateCFProperty( device,
  2010.                         CFSTR("GUID"), kCFAllocatorDefault, kNilOptions );
  2012.                     if( value != NULL )
  2013.                     {
  2014.                         if( CFGetTypeID( value ) == CFNumberGetTypeID() )
  2015.                         {
  2016.                             int64_t i_ipod_id;
  2017.                             CFNumberGetValue( (CFNumberRef)value,
  2018.                                               kCFNumberLongLongType,
  2019.                                               &i_ipod_id );
  2020.                             *p_ipod_id = i_ipod_id;
  2021.                             i_ret = 0;
  2022.                         }
  2024.                         CFRelease( value );
  2025.                     }
  2027.                     IOObjectRelease( device );
  2029.                     if( !i_ret ) break;
  2030.                 }
  2032.                 IOObjectRelease( iterator );
  2033.             }
  2034.             CFRelease( match_dic );
  2035.         }
  2037.         mach_port_deallocate( mach_task_self(), port );
  2038.     }
  2040. #elif defined (HAVE_SYSFS_LIBSYSFS_H)
  2041.     struct sysfs_bus *bus = NULL;
  2042.     struct dlist *devlist = NULL;
  2043.     struct dlist *attributes = NULL;
  2044.     struct sysfs_device *curdev = NULL;
  2045.     struct sysfs_attribute *curattr = NULL;
  2047.     bus = sysfs_open_bus( "ieee1394" );
  2048.     if( bus != NULL )
  2049.     {
  2050.         devlist = sysfs_get_bus_devices( bus );
  2051.         if( devlist != NULL )
  2052.         {
  2053.             dlist_for_each_data( devlist, curdev, struct sysfs_device )
  2054.             {
  2055.                 attributes = sysfs_get_device_attributes( curdev );
  2056.                 if( attributes != NULL )
  2057.                 {
  2058.                     dlist_for_each_data( attributes, curattr,
  2059.                                          struct sysfs_attribute )
  2060.                     {
  2061.                         if( ( strcmp( curattr->name, "model_name" ) == 0 ) &&
  2062.                             ( strncmp( curattr->value, PROD_NAME,
  2063.                                        sizeof(PROD_NAME) ) == 0 ) )
  2064.                         {
  2065.                             *p_ipod_id = strtoll( curdev->name, NULL, 16 );
  2066.                             i_ret = 0;
  2067.                             break;
  2068.                         }
  2069.                     }
  2070.                }
  2072.                 if( !i_ret ) break;
  2073.             }
  2074.         }
  2076.         sysfs_close_bus( bus );
  2077.     }
  2078. #endif
  2080.     return i_ret;
  2081. }
  2083. #else /* !defined( UNDER_CE ) */
  2085. void *drms_alloc( const char *psz_homedir ){ return NULL; }
  2086. void drms_free( void *a ){}
  2087. void drms_decrypt( void *a, uint32_t *b, uint32_t c, uint32_t *k  ){}
  2088. void drms_get_p_key( void *p_drms, uint32_t *p_key ){}
  2089. int drms_init( void *a, uint32_t b, uint8_t *c, uint32_t d ){ return -1; }
  2091. #endif /* defined( UNDER_CE ) */