shithub: aacdec

--- a/common/mp4ff/Makefile.am

+++ b/common/mp4ff/Makefile.am

@@ -8,5 +8,5 @@

 AM_CFLAGS = -O2 -g -DUSE_TAGGING=1

 LIBTOOL_DEPS =

-LIBS =

+LIBS = @MP4FF_LIBS@

--- a/common/mp4ff/drms.c

+++ b/common/mp4ff/drms.c

@@ -1,10 +1,11 @@

 /*****************************************************************************

- * drms.c : DRMS

+ * drms.c: DRMS

  *****************************************************************************

  * Copyright (C) 2004 VideoLAN

- * $Id: drms.c,v 1.4 2004/03/27 11:14:48 menno Exp $

+ * $Id: drms.c,v 1.5 2004/03/31 17:39:57 menno Exp $

- * Author: Jon Lech Johansen <jon-vl@nanocrew.net>

+ * Authors: Jon Lech Johansen <jon-vl@nanocrew.net>

+ *          Sam Hocevar <sam@zoy.org>

  * This program is free software; you can redistribute it and/or modify

  * it under the terms of the GNU General Public License as published by

@@ -23,1022 +24,1298 @@

 #include <stdlib.h>                                      /* malloc(), free() */

-/* #include <vlc/vlc.h> */

+#ifndef _WIN32

+#include "config.h"

+#endif

 #include "mp4ffint.h"

 #ifdef ITUNES_DRM

 #ifdef _WIN32

-#include <tchar.h>

-#include <shlobj.h>

-#include <windows.h>

+#   include <io.h>

+#   include <stdio.h>

+#   include <sys/stat.h>

+#   define PATH_MAX MAX_PATH

+#else

+#   include <stdio.h>

 #endif

+#ifdef HAVE_ERRNO_H

+#   include <errno.h>

+#endif

+#ifdef _WIN32

+#   include <tchar.h>

+#   include <shlobj.h>

+#   include <windows.h>

+#endif

+#ifdef HAVE_SYS_STAT_H

+#   include <sys/stat.h>

+#endif

+#ifdef HAVE_SYS_TYPES_H

+#   include <sys/types.h>

+#endif

+/* In Solaris (and perhaps others) PATH_MAX is in limits.h. */

+#ifdef HAVE_LIMITS_H

+#   include <limits.h>

+#endif

+#ifdef HAVE_IOKIT_IOKITLIB_H

+#   include <mach/mach.h>

+#   include <IOKit/IOKitLib.h>

+#   include <CoreFoundation/CFNumber.h>

+#endif

+#ifdef HAVE_SYSFS_LIBSYSFS_H

+#   include <sysfs/libsysfs.h>

+#endif

 #include "drms.h"

 #include "drmstables.h"

-static __inline uint32_t U32_AT( void * _p )

+/*****************************************************************************

+ * aes_s: AES keys structure

+ *****************************************************************************

+ * This structure stores a set of keys usable for encryption and decryption

+ * with the AES/Rijndael algorithm.

+ *****************************************************************************/

+struct aes_s

-    uint8_t * p = (uint8_t *)_p;

-    return ( ((uint32_t)p[0] << 24) | ((uint32_t)p[1] << 16)

-              | ((uint32_t)p[2] << 8) | p[3] );

-}

+    uint32_t pp_enc_keys[ AES_KEY_COUNT + 1 ][ 4 ];

+    uint32_t pp_dec_keys[ AES_KEY_COUNT + 1 ][ 4 ];

+};

-#define TAOS_INIT( tmp, i ) \

-    memset( tmp, 0, sizeof(tmp) ); \

-    tmp[ i + 0 ] = 0x67452301; \

-    tmp[ i + 1 ] = 0xEFCDAB89; \

-    tmp[ i + 2 ] = 0x98BADCFE; \

-    tmp[ i + 3 ] = 0x10325476;

+/*****************************************************************************

+ * md5_s: MD5 message structure

+ *****************************************************************************

+ * This structure stores the static information needed to compute an MD5

+ * hash. It has an extra data buffer to allow non-aligned writes.

+ *****************************************************************************/

+struct md5_s

+{

+    uint64_t i_bits;      /* Total written bits */

+    uint32_t p_digest[4]; /* The MD5 digest */

+    uint32_t p_data[16];  /* Buffer to cache non-aligned writes */

+};

-#define ROR( x, n ) (((x) << (32-(n))) | ((x) >> (n)))

+/*****************************************************************************

+ * shuffle_s: shuffle structure

+ *****************************************************************************

+ * This structure stores the static information needed to shuffle data using

+ * a custom algorithm.

+ *****************************************************************************/

+struct shuffle_s

+{

+    uint32_t p_commands[ 20 ];

+    uint32_t p_bordel[ 16 ];

+};

-static void init_ctx( uint32_t *p_ctx, uint32_t *p_input )

+/*****************************************************************************

+ * drms_s: DRMS structure

+ *****************************************************************************

+ * This structure stores the static information needed to decrypt DRMS data.

+ *****************************************************************************/

+struct drms_s

-    uint32_t i;

-    uint32_t p_tmp[ 6 ];

+    uint32_t i_user;

+    uint32_t i_key;

+    uint8_t  p_iviv[ 16 ];

+    uint8_t *p_name;

-    p_ctx[ 0 ] = sizeof(*p_input);

+    uint32_t p_key[ 4 ];

+    struct aes_s aes;

-    memset( &p_ctx[ 1 + 4 ], 0, sizeof(*p_input) * 4 );

-    memcpy( &p_ctx[ 1 + 0 ], p_input, sizeof(*p_input) * 4 );

+    char     psz_homedir[ PATH_MAX ];

+};

-    p_tmp[ 0 ] = p_ctx[ 1 + 3 ];

+/*****************************************************************************

+ * Local prototypes

+ *****************************************************************************/

+static void InitAES       ( struct aes_s *, uint32_t * );

+static void DecryptAES    ( struct aes_s *, uint32_t *, const uint32_t * );

-    for( i = 0; i < sizeof(p_drms_tab1)/sizeof(p_drms_tab1[ 0 ]); i++ )

-    {

-        p_tmp[ 0 ] = ROR( p_tmp[ 0 ], 8 );

+static void InitMD5       ( struct md5_s * );

+static void AddMD5        ( struct md5_s *, const uint8_t *, uint32_t );

+static void EndMD5        ( struct md5_s * );

+static void Digest        ( struct md5_s *, uint32_t * );

-        p_tmp[ 5 ] = p_drms_tab2[ (p_tmp[ 0 ] >> 24) & 0xFF ]

-                   ^ ROR( p_drms_tab2[ (p_tmp[ 0 ] >> 16) & 0xFF ], 8 )

-                   ^ ROR( p_drms_tab2[ (p_tmp[ 0 ] >> 8) & 0xFF ], 16 )

-                   ^ ROR( p_drms_tab2[ p_tmp[ 0 ] & 0xFF ], 24 )

-                   ^ p_drms_tab1[ i ]

-                   ^ p_ctx[ 1 + ((i + 1) * 4) - 4 ];

+static void InitShuffle   ( struct shuffle_s *, uint32_t * );

+static void DoShuffle     ( struct shuffle_s *, uint32_t *, uint32_t );

-        p_ctx[ 1 + ((i + 1) * 4) + 0 ] = p_tmp[ 5 ];

-        p_tmp[ 5 ] ^= p_ctx[ 1 + ((i + 1) * 4) - 3 ];

-        p_ctx[ 1 + ((i + 1) * 4) + 1 ] = p_tmp[ 5 ];

-        p_tmp[ 5 ] ^= p_ctx[ 1 + ((i + 1) * 4) - 2 ];

-        p_ctx[ 1 + ((i + 1) * 4) + 2 ] = p_tmp[ 5 ];

-        p_tmp[ 5 ] ^= p_ctx[ 1 + ((i + 1) * 4) - 1 ];

-        p_ctx[ 1 + ((i + 1) * 4) + 3 ] = p_tmp[ 5 ];

+static int GetSystemKey   ( uint32_t *, uint32_t );

+static int WriteUserKey   ( void *, uint32_t * );

+static int ReadUserKey    ( void *, uint32_t * );

+static int GetUserKey     ( void *, uint32_t * );

-        p_tmp[ 0 ] = p_tmp[ 5 ];

-    }

+static int GetSCIData     ( char *, uint32_t **, uint32_t * );

+static int HashSystemInfo ( uint32_t * );

+static int GetiPodID      ( int64_t * );

-    memcpy( &p_ctx[ 1 + 64 ], &p_ctx[ 1 ], sizeof(*p_ctx) * 4 );

+#ifdef WORDS_BIGENDIAN

+/*****************************************************************************

+ * Reverse: reverse byte order

+ *****************************************************************************/

+static __inline void Reverse( uint32_t *p_buffer, int n )

+{

+    int i;

-    for( i = 4; i < sizeof(p_drms_tab1); i++ )

+    for( i = 0; i < n; i++ )

-        p_tmp[ 2 ] = p_ctx[ 1 + 4 + (i - 4) ];

+        p_buffer[ i ] = GetDWLE(&p_buffer[ i ]);

+    }

+}

+#    define REVERSE( p, n ) Reverse( p, n )

+#else

+#    define REVERSE( p, n )

+#endif

-        p_tmp[ 0 ] = (((p_tmp[ 2 ] >> 7) & 0x01010101) * 27)

-                   ^ ((p_tmp[ 2 ] & 0xFF7F7F7F) << 1);

-        p_tmp[ 1 ] = (((p_tmp[ 0 ] >> 7) & 0x01010101) * 27)

-                   ^ ((p_tmp[ 0 ] & 0xFF7F7F7F) << 1);

-        p_tmp[ 4 ] = (((p_tmp[ 1 ] >> 7) & 0x01010101) * 27)

-                   ^ ((p_tmp[ 1 ] & 0xFF7F7F7F) << 1);

+/*****************************************************************************

+ * BlockXOR: XOR two 128 bit blocks

+ *****************************************************************************/

+static __inline void BlockXOR( uint32_t *p_dest, uint32_t *p_s1, uint32_t *p_s2 )

+{

+    int i;

-        p_tmp[ 2 ] ^= p_tmp[ 4 ];

-        p_tmp[ 3 ] = ROR( p_tmp[ 1 ] ^ p_tmp[ 2 ], 16 )

-                   ^ ROR( p_tmp[ 0 ] ^ p_tmp[ 2 ], 8 )

-                   ^ ROR( p_tmp[ 2 ], 24 );

-        p_ctx[ 1 + 4 + 64 + (i - 4) ] = p_tmp[ 3 ] ^ p_tmp[ 4 ]

-                                      ^ p_tmp[ 1 ] ^ p_tmp[ 0 ];

+    for( i = 0; i < 4; i++ )

+    {

+        p_dest[ i ] = p_s1[ i ] ^ p_s2[ i ];

-static void ctx_xor( uint32_t *p_ctx, uint32_t *p_in, uint32_t *p_out,

-                     uint32_t p_table1[ 256 ], uint32_t p_table2[ 256 ] )

+/*****************************************************************************

+ * drms_alloc: allocate a DRMS structure

+ *****************************************************************************/

+void *drms_alloc( char *psz_homedir )

-    uint32_t i, x, y;

-    uint32_t p_tmp1[ 4 ];

-    uint32_t p_tmp2[ 4 ];

+    struct drms_s *p_drms;

-    i = p_ctx[ 0 ] * 4;

+    p_drms = malloc( sizeof(struct drms_s) );

-    p_tmp1[ 0 ] = p_ctx[ 1 + i + 24 ] ^ p_in[ 0 ];

-    p_tmp1[ 1 ] = p_ctx[ 1 + i + 25 ] ^ p_in[ 1 ];

-    p_tmp1[ 2 ] = p_ctx[ 1 + i + 26 ] ^ p_in[ 2 ];

-    p_tmp1[ 3 ] = p_ctx[ 1 + i + 27 ] ^ p_in[ 3 ];

-    i += 84;

-#define XOR_ROR( p_table, p_tmp, i_ctx ) \

-    p_table[ (p_tmp[ y > 2 ? y - 3 : y + 1 ] >> 24) & 0xFF ] \

-    ^ ROR( p_table[ (p_tmp[ y > 1 ? y - 2 : y + 2 ] >> 16) & 0xFF ], 8 ) \

-    ^ ROR( p_table[ (p_tmp[ y > 0 ? y - 1 : y + 3 ] >> 8) & 0xFF ], 16 ) \

-    ^ ROR( p_table[ p_tmp[ y ] & 0xFF ], 24 ) \

-    ^ p_ctx[ i_ctx ]

-    for( x = 0; x < 1; x++ )

+    if( p_drms == NULL )

-        memcpy( p_tmp2, p_tmp1, sizeof(p_tmp1) );

-        for( y = 0; y < 4; y++ )

-        {

-            p_tmp1[ y ] = XOR_ROR( p_table1, p_tmp2, 1 + i - x + y );

-        }

+        return NULL;

-    for( ; x < 9; x++ )

-    {

-        memcpy( p_tmp2, p_tmp1, sizeof(p_tmp1) );

+    memset( p_drms, 0, sizeof(struct drms_s) );

-        for( y = 0; y < 4; y++ )

-        {

-            p_tmp1[ y ] = XOR_ROR( p_table1, p_tmp2,

-                                   1 + i - x - ((x * 3) - y) );

-        }

-    }

+    strncpy( p_drms->psz_homedir, psz_homedir, PATH_MAX );

+    p_drms->psz_homedir[ PATH_MAX - 1 ] = '\0';

-    for( y = 0; y < 4; y++ )

+    return (void *)p_drms;

+}

+/*****************************************************************************

+ * drms_free: free a previously allocated DRMS structure

+ *****************************************************************************/

+void drms_free( void *_p_drms )

+{

+    struct drms_s *p_drms = (struct drms_s *)_p_drms;

+    if( p_drms->p_name != NULL )

-        p_out[ y ] = XOR_ROR( p_table2, p_tmp1,

-                              1 + i - x - ((x * 3) - y) );

+        free( (void *)p_drms->p_name );

-#undef XOR_ROR

+    free( p_drms );

-static void taos( uint32_t *p_buffer, uint32_t *p_input )

+/*****************************************************************************

+ * drms_decrypt: unscramble a chunk of data

+ *****************************************************************************/

+void drms_decrypt( void *_p_drms, uint32_t *p_buffer, uint32_t i_bytes )

-    uint32_t i;

-    uint32_t x = 0;

-    uint32_t p_tmp1[ 4 ];

-    uint32_t p_tmp2[ 4 ];

+    struct drms_s *p_drms = (struct drms_s *)_p_drms;

+    uint32_t p_key[ 4 ];

+    unsigned int i_blocks;

-    memcpy( p_tmp1, p_buffer, sizeof(p_tmp1) );

+    /* AES is a block cypher, round down the byte count */

+    i_blocks = i_bytes / 16;

+    i_bytes = i_blocks * 16;

-    p_tmp2[ 0 ] = ((~p_tmp1[ 1 ] & p_tmp1[ 3 ])

-                |   (p_tmp1[ 2 ] & p_tmp1[ 1 ])) + p_input[ x ];

-    p_tmp1[ 0 ] = p_tmp2[ 0 ] + p_tmp1[ 0 ] + p_drms_tab_taos[ x++ ];

+    /* Initialise the key */

+    memcpy( p_key, p_drms->p_key, 16 );

-    for( i = 0; i < 4; i++ )

+    /* Unscramble */

+    while( i_blocks-- )

-        p_tmp2[ 0 ] = ((p_tmp1[ 0 ] >> 0x19)

-                    |  (p_tmp1[ 0 ] << 0x7)) + p_tmp1[ 1 ];

-        p_tmp2[ 1 ] = ((~p_tmp2[ 0 ] & p_tmp1[ 2 ])

-                    |   (p_tmp1[ 1 ] & p_tmp2[ 0 ])) + p_input[ x ];

-        p_tmp2[ 1 ] += p_tmp1[ 3 ] + p_drms_tab_taos[ x++ ];

+        uint32_t p_tmp[ 4 ];

-        p_tmp1[ 3 ] = ((p_tmp2[ 1 ] >> 0x14)

-                    |  (p_tmp2[ 1 ] << 0xC)) + p_tmp2[ 0 ];

-        p_tmp2[ 1 ] = ((~p_tmp1[ 3 ] & p_tmp1[ 1 ])

-                    |   (p_tmp1[ 3 ] & p_tmp2[ 0 ])) + p_input[ x ];

-        p_tmp2[ 1 ] += p_tmp1[ 2 ] + p_drms_tab_taos[ x++ ];

+        REVERSE( p_buffer, 4 );

+        DecryptAES( &p_drms->aes, p_tmp, p_buffer );

+        BlockXOR( p_tmp, p_key, p_tmp );

-        p_tmp1[ 2 ] = ((p_tmp2[ 1 ] >> 0xF)

-                    |  (p_tmp2[ 1 ] << 0x11)) + p_tmp1[ 3 ];

-        p_tmp2[ 1 ] = ((~p_tmp1[ 2 ] & p_tmp2[ 0 ])

-                    |   (p_tmp1[ 3 ] & p_tmp1[ 2 ])) + p_input[ x ];

-        p_tmp2[ 2 ] = p_tmp2[ 1 ] + p_tmp1[ 1 ] + p_drms_tab_taos[ x++ ];

+        /* Use the previous scrambled data as the key for next block */

+        memcpy( p_key, p_buffer, 16 );

-        p_tmp1[ 1 ] = ((p_tmp2[ 2 ] << 0x16)

-                    |  (p_tmp2[ 2 ] >> 0xA)) + p_tmp1[ 2 ];

-        if( i == 3 )

-        {

-            p_tmp2[ 1 ] = ((~p_tmp1[ 3 ] & p_tmp1[ 2 ])

-                        |   (p_tmp1[ 3 ] & p_tmp1[ 1 ])) + p_input[ 1 ];

-        }

-        else

-        {

-            p_tmp2[ 1 ] = ((~p_tmp1[ 1 ] & p_tmp1[ 3 ])

-                        |   (p_tmp1[ 2 ] & p_tmp1[ 1 ])) + p_input[ x ];

-        }

-        p_tmp1[ 0 ] = p_tmp2[ 0 ] + p_tmp2[ 1 ] + p_drms_tab_taos[ x++ ];

+        /* Copy unscrambled data back to the buffer */

+        memcpy( p_buffer, p_tmp, 16 );

+        REVERSE( p_buffer, 4 );

+        p_buffer += 4;

+}

-    for( i = 0; i < 4; i++ )

+/*****************************************************************************

+ * drms_init: initialise a DRMS structure

+ *****************************************************************************/

+int drms_init( void *_p_drms, uint32_t i_type,

+               uint8_t *p_info, uint32_t i_len )

+{

+    struct drms_s *p_drms = (struct drms_s *)_p_drms;

+    int i_ret = 0;

+    switch( i_type )

-        uint8_t p_table[ 4 ][ 4 ] =

-        {

-            {  6, 11,  0,  5 },

-            { 10, 15,  4,  9 },

-            { 14,  3,  8, 13 },

-            {  2,  7, 12,  5 }

-        };

+        case FOURCC_user:

+            if( i_len < sizeof(p_drms->i_user) )

+            {

+                i_ret = -1;

+                break;

+            }

-        p_tmp2[ 0 ] = ((p_tmp1[ 0 ] >> 0x1B)

-                    |  (p_tmp1[ 0 ] << 0x5)) + p_tmp1[ 1 ];

-        p_tmp2[ 1 ] = ((~p_tmp1[ 2 ] & p_tmp1[ 1 ])

-                    |   (p_tmp1[ 2 ] & p_tmp2[ 0 ]))

-                    +   p_input[ p_table[ i ][ 0 ] ];

-        p_tmp2[ 1 ] += p_tmp1[ 3 ] + p_drms_tab_taos[ x++ ];

+            p_drms->i_user = U32_AT( p_info );

+            break;

-        p_tmp1[ 3 ] = ((p_tmp2[ 1 ] >> 0x17)

-                    |  (p_tmp2[ 1 ] << 0x9)) + p_tmp2[ 0 ];

-        p_tmp2[ 1 ] = ((~p_tmp1[ 1 ] & p_tmp2[ 0 ])

-                    |   (p_tmp1[ 3 ] & p_tmp1[ 1 ]))

-                    +   p_input[ p_table[ i ][ 1 ] ];

-        p_tmp2[ 1 ] += p_tmp1[ 2 ] + p_drms_tab_taos[ x++ ];

+        case FOURCC_key:

+            if( i_len < sizeof(p_drms->i_key) )

+            {

+                i_ret = -1;

+                break;

+            }

-        p_tmp1[ 2 ] = ((p_tmp2[ 1 ] >> 0x12)

-                    |  (p_tmp2[ 1 ] << 0xE)) + p_tmp1[ 3 ];

-        p_tmp2[ 1 ] = ((~p_tmp2[ 0 ] & p_tmp1[ 3 ])

-                    |   (p_tmp1[ 2 ] & p_tmp2[ 0 ]))

-                    +   p_input[ p_table[ i ][ 2 ] ];

-        p_tmp2[ 1 ] += p_tmp1[ 1 ] + p_drms_tab_taos[ x++ ];

+            p_drms->i_key = U32_AT( p_info );

+            break;

-        p_tmp1[ 1 ] = ((p_tmp2[ 1 ] << 0x14)

-                    |  (p_tmp2[ 1 ] >> 0xC)) + p_tmp1[ 2 ];

-        if( i == 3 )

+        case FOURCC_iviv:

+            if( i_len < sizeof(p_drms->p_key) )

+            {

+                i_ret = -1;

+                break;

+            }

+            memcpy( p_drms->p_iviv, p_info, 16 );

+            break;

+        case FOURCC_name:

+            p_drms->p_name = strdup( p_info );

+            if( p_drms->p_name == NULL )

+            {

+                i_ret = -1;

+            }

+            break;

+        case FOURCC_priv:

-            p_tmp2[ 1 ] = (p_tmp1[ 3 ] ^ p_tmp1[ 2 ] ^ p_tmp1[ 1 ])

-                        + p_input[ p_table[ i ][ 3 ] ];

+            uint32_t p_priv[ 64 ];

+            struct md5_s md5;

+            if( i_len < 64 )

+            {

+                i_ret = -1;

+                break;

+            }

+            InitMD5( &md5 );

+            AddMD5( &md5, p_drms->p_name, strlen( p_drms->p_name ) );

+            AddMD5( &md5, p_drms->p_iviv, 16 );

+            EndMD5( &md5 );

+            if( GetUserKey( p_drms, p_drms->p_key ) )

+            {

+                i_ret = -1;

+                break;

+            }

+            InitAES( &p_drms->aes, p_drms->p_key );

+            memcpy( p_priv, p_info, 64 );

+            memcpy( p_drms->p_key, md5.p_digest, 16 );

+            drms_decrypt( p_drms, p_priv, 64 );

+            REVERSE( p_priv, 64 );

+            if( p_priv[ 0 ] != 0x6e757469 ) /* itun */

+            {

+                i_ret = -1;

+                break;

+            }

+            InitAES( &p_drms->aes, p_priv + 6 );

+            memcpy( p_drms->p_key, p_priv + 12, 16 );

+            free( (void *)p_drms->p_name );

+            p_drms->p_name = NULL;

-        else

-        {

-            p_tmp2[ 1 ] = ((~p_tmp1[ 3 ] & p_tmp1[ 2 ])

-                        |   (p_tmp1[ 3 ] & p_tmp1[ 1 ]))

-                        +   p_input[ p_table[ i ][ 3 ] ];

-        }

-        p_tmp1[ 0 ] = p_tmp2[ 0 ] + p_tmp2[ 1 ] + p_drms_tab_taos[ x++ ];

+        break;

-    for( i = 0; i < 4; i++ )

+    return i_ret;

+}

+/* The following functions are local */

+/*****************************************************************************

+ * InitAES: initialise AES/Rijndael encryption/decryption tables

+ *****************************************************************************

+ * The Advanced Encryption Standard (AES) is described in RFC 3268

+ *****************************************************************************/

+static void InitAES( struct aes_s *p_aes, uint32_t *p_key )

+{

+    unsigned int i, t;

+    uint32_t i_key, i_seed;

+    memset( p_aes->pp_enc_keys[1], 0, 16 );

+    memcpy( p_aes->pp_enc_keys[0], p_key, 16 );

+    /* Generate the key tables */

+    i_seed = p_aes->pp_enc_keys[ 0 ][ 3 ];

+    for( i_key = 0; i_key < AES_KEY_COUNT; i_key++ )

-        uint8_t p_table[ 4 ][ 4 ] =

-        {

-            {  8, 11, 14,  1 },

-            {  4,  7, 10, 13 },

-            {  0,  3,  6,  9 },

-            { 12, 15,  2,  0 }

-        };

+        uint32_t j;

-        p_tmp2[ 0 ] = ((p_tmp1[ 0 ] >> 0x1C)

-                    |  (p_tmp1[ 0 ] << 0x4)) + p_tmp1[ 1 ];

-        p_tmp2[ 1 ] = (p_tmp1[ 2 ] ^ p_tmp1[ 1 ] ^ p_tmp2[ 0 ])

-                    + p_input[ p_table[ i ][ 0 ] ];

-        p_tmp2[ 1 ] += p_tmp1[ 3 ] + p_drms_tab_taos[ x++ ];

+        i_seed = AES_ROR( i_seed, 8 );

-        p_tmp1[ 3 ] = ((p_tmp2[ 1 ] >> 0x15)

-                    |  (p_tmp2[ 1 ] << 0xB)) + p_tmp2[ 0 ];

-        p_tmp2[ 1 ] = (p_tmp1[ 3 ] ^ p_tmp1[ 1 ] ^ p_tmp2[ 0 ])

-                    + p_input[ p_table[ i ][ 1 ] ];

-        p_tmp2[ 1 ] += p_tmp1[ 2 ] + p_drms_tab_taos[ x++ ];

+        j = p_aes_table[ i_key ];

-        p_tmp1[ 2 ] = ((p_tmp2[ 1 ] >> 0x10)

-                    |  (p_tmp2[ 1 ] << 0x10)) + p_tmp1[ 3 ];

-        p_tmp2[ 1 ] = (p_tmp1[ 3 ] ^ p_tmp1[ 2 ] ^ p_tmp2[ 0 ])

-                    + p_input[ p_table[ i ][ 2 ] ];

-        p_tmp2[ 1 ] += p_tmp1[ 1 ] + p_drms_tab_taos[ x++ ];

+        j ^= p_aes_encrypt[ (i_seed >> 24) & 0xff ]

+              ^ AES_ROR( p_aes_encrypt[ (i_seed >> 16) & 0xff ], 8 )

+              ^ AES_ROR( p_aes_encrypt[ (i_seed >> 8) & 0xff ], 16 )

+              ^ AES_ROR( p_aes_encrypt[ i_seed & 0xff ], 24 );

-        p_tmp1[ 1 ] = ((p_tmp2[ 1 ] << 0x17)

-                    |  (p_tmp2[ 1 ] >> 0x9)) + p_tmp1[ 2 ];

-        if( i == 3 )

-        {

-            p_tmp2[ 1 ] = ((~p_tmp1[ 3 ] | p_tmp1[ 1 ]) ^ p_tmp1[ 2 ])

-                        +   p_input[ p_table[ i ][ 3 ] ];

-        }

-        else

-        {

-            p_tmp2[ 1 ] = (p_tmp1[ 3 ] ^ p_tmp1[ 2 ] ^ p_tmp1[ 1 ])

-                        + p_input[ p_table[ i ][ 3 ] ];

-        }

-        p_tmp1[ 0 ] = p_tmp2[ 0 ] + p_tmp2[ 1 ] + p_drms_tab_taos[ x++ ];

+        j ^= p_aes->pp_enc_keys[ i_key ][ 0 ];

+        p_aes->pp_enc_keys[ i_key + 1 ][ 0 ] = j;

+        j ^= p_aes->pp_enc_keys[ i_key ][ 1 ];

+        p_aes->pp_enc_keys[ i_key + 1 ][ 1 ] = j;

+        j ^= p_aes->pp_enc_keys[ i_key ][ 2 ];

+        p_aes->pp_enc_keys[ i_key + 1 ][ 2 ] = j;

+        j ^= p_aes->pp_enc_keys[ i_key ][ 3 ];

+        p_aes->pp_enc_keys[ i_key + 1 ][ 3 ] = j;

+        i_seed = j;

-    for( i = 0; i < 4; i++ )

+    memcpy( p_aes->pp_dec_keys[ 0 ],

+            p_aes->pp_enc_keys[ 0 ], 16 );

+    for( i = 1; i < AES_KEY_COUNT; i++ )

-        uint8_t p_table[ 4 ][ 4 ] =

+        for( t = 0; t < 4; t++ )

-            {  7, 14,  5, 12 },

-            {  3, 10,  1,  8 },

-            { 15,  6, 13,  4 },

-            { 11,  2,  9,  0 }

-        };

+            uint32_t j, k, l, m, n;

-        p_tmp2[ 0 ] = ((p_tmp1[ 0 ] >> 0x1A)

-                    |  (p_tmp1[ 0 ] << 0x6)) + p_tmp1[ 1 ];

-        p_tmp2[ 1 ] = ((~p_tmp1[ 2 ] | p_tmp2[ 0 ]) ^ p_tmp1[ 1 ])

-                    +   p_input[ p_table[ i ][ 0 ] ];

-        p_tmp2[ 1 ] += p_tmp1[ 3 ] + p_drms_tab_taos[ x++ ];

+            j = p_aes->pp_enc_keys[ i ][ t ];

-        p_tmp1[ 3 ] = ((p_tmp2[ 1 ] >> 0x16)

-                    |  (p_tmp2[ 1 ] << 0xA)) + p_tmp2[ 0 ];

-        p_tmp2[ 1 ] = ((~p_tmp1[ 1 ] | p_tmp1[ 3 ]) ^ p_tmp2[ 0 ])

-                    +   p_input[ p_table[ i ][ 1 ] ];

-        p_tmp2[ 1 ] += p_tmp1[ 2 ] + p_drms_tab_taos[ x++ ];

+            k = (((j >> 7) & 0x01010101) * 27) ^ ((j & 0xff7f7f7f) << 1);

+            l = (((k >> 7) & 0x01010101) * 27) ^ ((k & 0xff7f7f7f) << 1);

+            m = (((l >> 7) & 0x01010101) * 27) ^ ((l & 0xff7f7f7f) << 1);

-        p_tmp1[ 2 ] = ((p_tmp2[ 1 ] >> 0x11)

-                    |  (p_tmp2[ 1 ] << 0xF)) + p_tmp1[ 3 ];

-        p_tmp2[ 1 ] = ((~p_tmp2[ 0 ] | p_tmp1[ 2 ]) ^ p_tmp1[ 3 ])

-                    +   p_input[ p_table[ i ][ 2 ] ];

-        p_tmp2[ 1 ] += p_tmp1[ 1 ] + p_drms_tab_taos[ x++ ];

+            j ^= m;

-        p_tmp1[ 1 ] = ((p_tmp2[ 1 ] << 0x15)

-                    |  (p_tmp2[ 1 ] >> 0xB)) + p_tmp1[ 2 ];

+            n = AES_ROR( l ^ j, 16 ) ^ AES_ROR( k ^ j, 8 ) ^ AES_ROR( j, 24 );

-        if( i < 3 )

-        {

-            p_tmp2[ 1 ] = ((~p_tmp1[ 3 ] | p_tmp1[ 1 ]) ^ p_tmp1[ 2 ])

-                        +   p_input[ p_table[ i ][ 3 ] ];

-            p_tmp1[ 0 ] = p_tmp2[ 0 ] + p_tmp2[ 1 ] + p_drms_tab_taos[ x++ ];

+            p_aes->pp_dec_keys[ i ][ t ] = k ^ l ^ m ^ n;

-    p_buffer[ 0 ] += p_tmp2[ 0 ];

-    p_buffer[ 1 ] += p_tmp1[ 1 ];

-    p_buffer[ 2 ] += p_tmp1[ 2 ];

-    p_buffer[ 3 ] += p_tmp1[ 3 ];

-static void taos_add1( uint32_t *p_buffer,

-                       uint8_t *p_in, uint32_t i_len )

+/*****************************************************************************

+ * DecryptAES: decrypt an AES/Rijndael 128 bit block

+ *****************************************************************************/

+static void DecryptAES( struct aes_s *p_aes,

+                        uint32_t *p_dest, const uint32_t *p_src )

-    uint32_t i;

-    uint32_t x, y;

-    uint32_t p_tmp[ 16 ];

-    uint32_t i_offset = 0;

+    uint32_t p_wtxt[ 4 ]; /* Working cyphertext */

+    uint32_t p_tmp[ 4 ];

+    unsigned int i_round, t;

-    x = p_buffer[ 6 ] & 63;

-    y = 64 - x;

-    p_buffer[ 6 ] += i_len;

-    if( i_len < y )

+    for( t = 0; t < 4; t++ )

-        memcpy( &((uint8_t *)p_buffer)[ 48 + x ], p_in, i_len );

+        /* FIXME: are there any endianness issues here? */

+        p_wtxt[ t ] = p_src[ t ] ^ p_aes->pp_enc_keys[ AES_KEY_COUNT ][ t ];

-    else

+    /* Rounds 0 - 8 */

+    for( i_round = 0; i_round < (AES_KEY_COUNT - 1); i_round++ )

-        if( x )

+        for( t = 0; t < 4; t++ )

-            memcpy( &((uint8_t *)p_buffer)[ 48 + x ], p_in, y );

-            taos( &p_buffer[ 8 ], &p_buffer[ 12 ] );

-            i_offset = y;

-            i_len -= y;

+            p_tmp[ t ] = AES_XOR_ROR( p_aes_itable, p_wtxt );

-        if( i_len >= 64 )

+        for( t = 0; t < 4; t++ )

-            for( i = 0; i < i_len / 64; i++ )

-            {

-                memcpy( p_tmp, &p_in[ i_offset ], sizeof(p_tmp) );

-                taos( &p_buffer[ 8 ], p_tmp );

-                i_offset += 64;

-                i_len -= 64;

-            }

+            p_wtxt[ t ] = p_tmp[ t ]

+                    ^ p_aes->pp_dec_keys[ (AES_KEY_COUNT - 1) - i_round ][ t ];

+    }

-        if( i_len )

-        {

-            memcpy( &p_buffer[ 12 ], &p_in[ i_offset ], i_len );

-        }

+    /* Final round (9) */

+    for( t = 0; t < 4; t++ )

+    {

+        p_dest[ t ] = AES_XOR_ROR( p_aes_decrypt, p_wtxt );

+        p_dest[ t ] ^= p_aes->pp_dec_keys[ 0 ][ t ];

-static void taos_end1( uint32_t *p_buffer, uint32_t *p_out )

+/*****************************************************************************

+ * InitMD5: initialise an MD5 message

+ *****************************************************************************

+ * The MD5 message-digest algorithm is described in RFC 1321

+ *****************************************************************************/

+static void InitMD5( struct md5_s *p_md5 )

-    uint32_t x, y;

+    p_md5->p_digest[ 0 ] = 0x67452301;

+    p_md5->p_digest[ 1 ] = 0xefcdab89;

+    p_md5->p_digest[ 2 ] = 0x98badcfe;

+    p_md5->p_digest[ 3 ] = 0x10325476;

-    x = p_buffer[ 6 ] & 63;

-    y = 63 - x;

+    memset( p_md5->p_data, 0, 64 );

+    p_md5->i_bits = 0;

+}

-    ((uint8_t *)p_buffer)[ 48 + x++ ] = 128;

+/*****************************************************************************

+ * AddMD5: add i_len bytes to an MD5 message

+ *****************************************************************************/

+static void AddMD5( struct md5_s *p_md5, const uint8_t *p_src, uint32_t i_len )

+{

+    unsigned int i_current; /* Current bytes in the spare buffer */

+    unsigned int i_offset = 0;

-    if( y < 8 )

+    i_current = (p_md5->i_bits / 8) & 63;

+    p_md5->i_bits += 8 * i_len;

+    /* If we can complete our spare buffer to 64 bytes, do it and add the

+     * resulting buffer to the MD5 message */

+    if( i_len >= (64 - i_current) )

-        memset( &((uint8_t *)p_buffer)[ 48 + x ], 0, y );

-        taos( &p_buffer[ 8 ], &p_buffer[ 12 ] );

-        y = 64;

-        x = 0;

+        memcpy( ((uint8_t *)p_md5->p_data) + i_current, p_src,

+                (64 - i_current) );

+        Digest( p_md5, p_md5->p_data );

+        i_offset += (64 - i_current);

+        i_len -= (64 - i_current);

+        i_current = 0;

-    memset( &((uint8_t *)p_buffer)[ 48 + x ], 0, y );

+    /* Add as many entire 64 bytes blocks as we can to the MD5 message */

+    while( i_len >= 64 )

+    {

+        uint32_t p_tmp[ 16 ];

+        memcpy( p_tmp, p_src + i_offset, 64 );

+        Digest( p_md5, p_tmp );

+        i_offset += 64;

+        i_len -= 64;

+    }

-    p_buffer[ 26 ] = p_buffer[ 6 ] * 8;

-    p_buffer[ 27 ] = p_buffer[ 6 ] >> 29;

-    taos( &p_buffer[ 8 ], &p_buffer[ 12 ] );

-    memcpy( p_out, &p_buffer[ 8 ], sizeof(*p_out) * 4 );

+    /* Copy our remaining data to the message's spare buffer */

+    memcpy( ((uint8_t *)p_md5->p_data) + i_current, p_src + i_offset, i_len );

-static void taos_add2( uint32_t *p_buffer, uint8_t *p_in, uint32_t i_len )

+/*****************************************************************************

+ * EndMD5: finish an MD5 message

+ *****************************************************************************

+ * This function adds adequate padding to the end of the message, and appends

+ * the bit count so that we end at a block boundary.

+ *****************************************************************************/

+static void EndMD5( struct md5_s *p_md5 )

-    uint32_t i, x;

-    uint32_t p_tmp[ 16 ];

+    unsigned int i_current;

-    x = (p_buffer[ 0 ] / 8) & 63;

-    i = p_buffer[ 0 ] + i_len * 8;

+    i_current = (p_md5->i_bits / 8) & 63;

-    if( i < p_buffer[ 0 ] )

+    /* Append 0x80 to our buffer. No boundary check because the temporary

+     * buffer cannot be full, otherwise AddMD5 would have emptied it. */

+    ((uint8_t *)p_md5->p_data)[ i_current++ ] = 0x80;

+    /* If less than 8 bytes are available at the end of the block, complete

+     * this 64 bytes block with zeros and add it to the message. We'll add

+     * our length at the end of the next block. */

+    if( i_current > 56 )

-        p_buffer[ 1 ] += 1;

+        memset( ((uint8_t *)p_md5->p_data) + i_current, 0, (64 - i_current) );

+        Digest( p_md5, p_md5->p_data );

+        i_current = 0;

-    p_buffer[ 0 ] = i;

-    p_buffer[ 1 ] += i_len >> 29;

+    /* Fill the unused space in our last block with zeroes and put the

+     * message length at the end. */

+    memset( ((uint8_t *)p_md5->p_data) + i_current, 0, (56 - i_current) );

+    p_md5->p_data[ 14 ] = p_md5->i_bits & 0xffffffff;

+    p_md5->p_data[ 15 ] = (p_md5->i_bits >> 32);

+    REVERSE( &p_md5->p_data[ 14 ], 2 );

-    for( i = 0; i < i_len; i++ )

-    {

-        ((uint8_t *)p_buffer)[ 24 + x++ ] = p_in[ i ];

+    Digest( p_md5, p_md5->p_data );

+}

-        if( x != 64 )

-            continue;

+#define F1( x, y, z ) ((z) ^ ((x) & ((y) ^ (z))))

+#define F2( x, y, z ) F1((z), (x), (y))

+#define F3( x, y, z ) ((x) ^ (y) ^ (z))

+#define F4( x, y, z ) ((y) ^ ((x) | ~(z)))

-        memcpy( p_tmp, &p_buffer[ 6 ], sizeof(p_tmp) );

-        taos( &p_buffer[ 2 ], p_tmp );

-    }

-}

+#define MD5_DO( f, w, x, y, z, data, s ) \

+    ( w += f(x, y, z) + data,  w = w<<s | w>>(32-s),  w += x )

-static void taos_add2e( uint32_t *p_buffer, uint32_t *p_in, uint32_t i_len )

+/*****************************************************************************

+ * Digest: update the MD5 digest with 64 bytes of data

+ *****************************************************************************/

+static void Digest( struct md5_s *p_md5, uint32_t *p_input )

-    uint32_t i, x, y;

-    uint32_t p_tmp[ 32 ];

+    uint32_t a, b, c, d;

-    if( i_len )

-    {

-        for( x = i_len; x; x -= y )

-        {

-            y = x > 32 ? 32 : x;

+    REVERSE( p_input, 16 );

-            for( i = 0; i < y; i++ )

-            {

-                p_tmp[ i ] = U32_AT(&p_in[ i ]);

-            }

-        }

-    }

+    a = p_md5->p_digest[ 0 ];

+    b = p_md5->p_digest[ 1 ];

+    c = p_md5->p_digest[ 2 ];

+    d = p_md5->p_digest[ 3 ];

-    taos_add2( p_buffer, (uint8_t *)p_tmp, i_len * sizeof(p_tmp[ 0 ]) );

-}

+    MD5_DO( F1, a, b, c, d, p_input[  0 ] + 0xd76aa478,  7 );

+    MD5_DO( F1, d, a, b, c, p_input[  1 ] + 0xe8c7b756, 12 );

+    MD5_DO( F1, c, d, a, b, p_input[  2 ] + 0x242070db, 17 );

+    MD5_DO( F1, b, c, d, a, p_input[  3 ] + 0xc1bdceee, 22 );

+    MD5_DO( F1, a, b, c, d, p_input[  4 ] + 0xf57c0faf,  7 );

+    MD5_DO( F1, d, a, b, c, p_input[  5 ] + 0x4787c62a, 12 );

+    MD5_DO( F1, c, d, a, b, p_input[  6 ] + 0xa8304613, 17 );

+    MD5_DO( F1, b, c, d, a, p_input[  7 ] + 0xfd469501, 22 );

+    MD5_DO( F1, a, b, c, d, p_input[  8 ] + 0x698098d8,  7 );

+    MD5_DO( F1, d, a, b, c, p_input[  9 ] + 0x8b44f7af, 12 );

+    MD5_DO( F1, c, d, a, b, p_input[ 10 ] + 0xffff5bb1, 17 );

+    MD5_DO( F1, b, c, d, a, p_input[ 11 ] + 0x895cd7be, 22 );

+    MD5_DO( F1, a, b, c, d, p_input[ 12 ] + 0x6b901122,  7 );

+    MD5_DO( F1, d, a, b, c, p_input[ 13 ] + 0xfd987193, 12 );

+    MD5_DO( F1, c, d, a, b, p_input[ 14 ] + 0xa679438e, 17 );

+    MD5_DO( F1, b, c, d, a, p_input[ 15 ] + 0x49b40821, 22 );

-static void taos_end2( uint32_t *p_buffer )

-{

-    uint32_t x;

-    uint32_t p_tmp[ 16 ];

+    MD5_DO( F2, a, b, c, d, p_input[  1 ] + 0xf61e2562,  5 );

+    MD5_DO( F2, d, a, b, c, p_input[  6 ] + 0xc040b340,  9 );

+    MD5_DO( F2, c, d, a, b, p_input[ 11 ] + 0x265e5a51, 14 );

+    MD5_DO( F2, b, c, d, a, p_input[  0 ] + 0xe9b6c7aa, 20 );

+    MD5_DO( F2, a, b, c, d, p_input[  5 ] + 0xd62f105d,  5 );

+    MD5_DO( F2, d, a, b, c, p_input[ 10 ] + 0x02441453,  9 );

+    MD5_DO( F2, c, d, a, b, p_input[ 15 ] + 0xd8a1e681, 14 );

+    MD5_DO( F2, b, c, d, a, p_input[  4 ] + 0xe7d3fbc8, 20 );

+    MD5_DO( F2, a, b, c, d, p_input[  9 ] + 0x21e1cde6,  5 );

+    MD5_DO( F2, d, a, b, c, p_input[ 14 ] + 0xc33707d6,  9 );

+    MD5_DO( F2, c, d, a, b, p_input[  3 ] + 0xf4d50d87, 14 );

+    MD5_DO( F2, b, c, d, a, p_input[  8 ] + 0x455a14ed, 20 );

+    MD5_DO( F2, a, b, c, d, p_input[ 13 ] + 0xa9e3e905,  5 );

+    MD5_DO( F2, d, a, b, c, p_input[  2 ] + 0xfcefa3f8,  9 );

+    MD5_DO( F2, c, d, a, b, p_input[  7 ] + 0x676f02d9, 14 );

+    MD5_DO( F2, b, c, d, a, p_input[ 12 ] + 0x8d2a4c8a, 20 );

-    p_tmp[ 14 ] = p_buffer[ 0 ];

-    p_tmp[ 15 ] = p_buffer[ 1 ];

+    MD5_DO( F3, a, b, c, d, p_input[  5 ] + 0xfffa3942,  4 );

+    MD5_DO( F3, d, a, b, c, p_input[  8 ] + 0x8771f681, 11 );

+    MD5_DO( F3, c, d, a, b, p_input[ 11 ] + 0x6d9d6122, 16 );

+    MD5_DO( F3, b, c, d, a, p_input[ 14 ] + 0xfde5380c, 23 );

+    MD5_DO( F3, a, b, c, d, p_input[  1 ] + 0xa4beea44,  4 );

+    MD5_DO( F3, d, a, b, c, p_input[  4 ] + 0x4bdecfa9, 11 );

+    MD5_DO( F3, c, d, a, b, p_input[  7 ] + 0xf6bb4b60, 16 );

+    MD5_DO( F3, b, c, d, a, p_input[ 10 ] + 0xbebfbc70, 23 );

+    MD5_DO( F3, a, b, c, d, p_input[ 13 ] + 0x289b7ec6,  4 );

+    MD5_DO( F3, d, a, b, c, p_input[  0 ] + 0xeaa127fa, 11 );

+    MD5_DO( F3, c, d, a, b, p_input[  3 ] + 0xd4ef3085, 16 );

+    MD5_DO( F3, b, c, d, a, p_input[  6 ] + 0x04881d05, 23 );

+    MD5_DO( F3, a, b, c, d, p_input[  9 ] + 0xd9d4d039,  4 );

+    MD5_DO( F3, d, a, b, c, p_input[ 12 ] + 0xe6db99e5, 11 );

+    MD5_DO( F3, c, d, a, b, p_input[ 15 ] + 0x1fa27cf8, 16 );

+    MD5_DO( F3, b, c, d, a, p_input[  2 ] + 0xc4ac5665, 23 );

-    x = (p_buffer[ 0 ] / 8) & 63;

+    MD5_DO( F4, a, b, c, d, p_input[  0 ] + 0xf4292244,  6 );

+    MD5_DO( F4, d, a, b, c, p_input[  7 ] + 0x432aff97, 10 );

+    MD5_DO( F4, c, d, a, b, p_input[ 14 ] + 0xab9423a7, 15 );

+    MD5_DO( F4, b, c, d, a, p_input[  5 ] + 0xfc93a039, 21 );

+    MD5_DO( F4, a, b, c, d, p_input[ 12 ] + 0x655b59c3,  6 );

+    MD5_DO( F4, d, a, b, c, p_input[  3 ] + 0x8f0ccc92, 10 );

+    MD5_DO( F4, c, d, a, b, p_input[ 10 ] + 0xffeff47d, 15 );

+    MD5_DO( F4, b, c, d, a, p_input[  1 ] + 0x85845dd1, 21 );

+    MD5_DO( F4, a, b, c, d, p_input[  8 ] + 0x6fa87e4f,  6 );

+    MD5_DO( F4, d, a, b, c, p_input[ 15 ] + 0xfe2ce6e0, 10 );

+    MD5_DO( F4, c, d, a, b, p_input[  6 ] + 0xa3014314, 15 );

+    MD5_DO( F4, b, c, d, a, p_input[ 13 ] + 0x4e0811a1, 21 );

+    MD5_DO( F4, a, b, c, d, p_input[  4 ] + 0xf7537e82,  6 );

+    MD5_DO( F4, d, a, b, c, p_input[ 11 ] + 0xbd3af235, 10 );

+    MD5_DO( F4, c, d, a, b, p_input[  2 ] + 0x2ad7d2bb, 15 );

+    MD5_DO( F4, b, c, d, a, p_input[  9 ] + 0xeb86d391, 21 );

-    taos_add2( p_buffer, p_drms_tab_tend, 56 - x );

-    memcpy( p_tmp, &p_buffer[ 6 ], 56 );

-    taos( &p_buffer[ 2 ], p_tmp );

-    memcpy( &p_buffer[ 22 ], &p_buffer[ 2 ], sizeof(*p_buffer) * 4 );

+    p_md5->p_digest[ 0 ] += a;

+    p_md5->p_digest[ 1 ] += b;

+    p_md5->p_digest[ 2 ] += c;

+    p_md5->p_digest[ 3 ] += d;

-static void taos_add3( uint32_t *p_buffer, uint8_t *p_key, uint32_t i_len )

-{

-    uint32_t x, y;

-    uint32_t i = 0;

+/*****************************************************************************

+ * InitShuffle: initialise a shuffle structure

+ *****************************************************************************

+ * This function initialises tables in the p_shuffle structure that will be

+ * used later by DoShuffle. The only external parameter is p_sys_key.

+ *****************************************************************************/

+static void InitShuffle( struct shuffle_s *p_shuffle, uint32_t *p_sys_key )

+{

+    char p_secret1[] = "Tv!*";

+    static char const p_secret2[] = "v8rhvsaAvOKMFfUH%798=[;."

+                                    "f8677680a634ba87fnOIf)(*";

+    unsigned int i;

-    x = (p_buffer[ 4 ] / 8) & 63;

-    p_buffer[ 4 ] += i_len * 8;

+    /* Fill p_commands using the key and a secret seed */

+    for( i = 0; i < 20; i++ )

+    {

+        struct md5_s md5;

+        int32_t i_hash;

-    if( p_buffer[ 4 ] < i_len * 8 )

-        p_buffer[ 5 ] += 1;

+        InitMD5( &md5 );

+        AddMD5( &md5, (uint8_t *)p_sys_key, 16 );

+        AddMD5( &md5, (uint8_t *)p_secret1, 4 );

+        EndMD5( &md5 );

-    p_buffer[ 5 ] += i_len >> 29;

+        p_secret1[ 3 ]++;

-    y = 64 - x;

+        REVERSE( md5.p_digest, 1 );

+        i_hash = ((int32_t)U32_AT(md5.p_digest)) % 1024;

-    if( i_len >= y )

-    {

-        memcpy( &((uint8_t *)p_buffer)[ 24 + x ], p_key, y );

-        taos( p_buffer, &p_buffer[ 6 ] );

-        i = y;

-        y += 63;

-        if( y < i_len )

-        {

-            for( ; y < i_len; y += 64, i += 64 )

-            {

-                taos( p_buffer, (uint32_t *)&p_key[y - 63] );

-            }

-        }

-        else

-        {

-            x = 0;

-        }

+        p_shuffle->p_commands[ i ] = i_hash < 0 ? i_hash * -1 : i_hash;

-    memcpy( &((uint8_t *)p_buffer)[ 24 + x ], &p_key[ i ], i_len - i );

+    /* Fill p_bordel with completely meaningless initial values. */

+    for( i = 0; i < 4; i++ )

+    {

+        p_shuffle->p_bordel[ 4 * i ] = U32_AT(p_sys_key + i);

+        memcpy( p_shuffle->p_bordel + 4 * i + 1, p_secret2 + 12 * i, 12 );

+        REVERSE( p_shuffle->p_bordel + 4 * i + 1, 3 );

+    }

-static int taos_osi( uint32_t *p_buffer )

+/*****************************************************************************

+ * DoShuffle: shuffle buffer

+ *****************************************************************************

+ * This is so ugly and uses so many MD5 checksums that it is most certainly

+ * one-way, though why it needs to be so complicated is beyond me.

+ *****************************************************************************/

+static void DoShuffle( struct shuffle_s *p_shuffle,

+                       uint32_t *p_buffer, uint32_t i_size )

-    int i_ret = 0;

+    struct md5_s md5;

+    uint32_t p_big_bordel[ 16 ];

+    uint32_t *p_bordel = p_shuffle->p_bordel;

+    unsigned int i;

-#ifdef _WIN32

-    HKEY i_key;

-    uint32_t i;

-    DWORD i_size;

-    DWORD i_serial;

-    LPBYTE p_reg_buf;

-    static LPCTSTR p_reg_keys[ 3 ][ 2 ] =

+    /* Using the MD5 hash of a memory block is probably not one-way enough

+     * for the iTunes people. This function randomises p_bordel depending on

+     * the values in p_commands to make things even more messy in p_bordel. */

+    for( i = 0; i < 20; i++ )

-        {

-            _T("HARDWARE\\DESCRIPTION\\System"),

-            _T("SystemBiosVersion")

-        },

+        uint8_t i_command, i_index;

+        if( !p_shuffle->p_commands[ i ] )

-            _T("HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0"),

-            _T("ProcessorNameString")

-        },

+            continue;

+        }

+        i_command = (p_shuffle->p_commands[ i ] & 0x300) >> 8;

+        i_index = p_shuffle->p_commands[ i ] & 0xff;

+        switch( i_command )

-            _T("SOFTWARE\\Microsoft\\Windows\\CurrentVersion"),

-            _T("ProductId")

+        case 0x3:

+            p_bordel[ i_index & 0xf ] = p_bordel[ i_index >> 4 ]

+                                      + p_bordel[ ((i_index + 0x10) >> 4) & 0xf ];

+            break;

+        case 0x2:

+            p_bordel[ i_index >> 4 ] ^= p_shuffle_xor[ 0xff - i_index ];

+            break;

+        case 0x1:

+            p_bordel[ i_index >> 4 ] -= p_shuffle_sub[ 0xff - i_index ];

+            break;

+        default:

+            p_bordel[ i_index >> 4 ] += p_shuffle_add[ 0xff - i_index ];

+            break;

-    };

+    }

-    taos_add1( p_buffer, "cache-control", 13 );

-    taos_add1( p_buffer, "Ethernet", 8 );

+    /* Convert our newly randomised p_bordel to big endianness and take

+     * its MD5 hash. */

+    InitMD5( &md5 );

+    for( i = 0; i < 16; i++ )

+    {

+        p_big_bordel[ i ] = U32_AT(p_bordel + i);

+    }

+    AddMD5( &md5, (uint8_t *)p_big_bordel, 64 );

+    EndMD5( &md5 );

-    GetVolumeInformation( _T("C:\\"), NULL, 0, &i_serial,

-                          NULL, NULL, NULL, 0 );

-    taos_add1( p_buffer, (uint8_t *)&i_serial, 4 );

-    for( i = 0; i < sizeof(p_reg_keys)/sizeof(p_reg_keys[ 0 ]); i++ )

+    /* XOR our buffer with the computed checksum */

+    for( i = 0; i < i_size; i++ )

-        if( RegOpenKeyEx( HKEY_LOCAL_MACHINE, p_reg_keys[ i ][ 0 ],

-                          0, KEY_READ, &i_key ) == ERROR_SUCCESS )

-        {

-            if( RegQueryValueEx( i_key, p_reg_keys[ i ][ 1 ],

-                                 NULL, NULL, NULL,

-                                 &i_size ) == ERROR_SUCCESS )

-            {

-                p_reg_buf = malloc( i_size );

+        p_buffer[ i ] ^= md5.p_digest[ i ];

+    }

+}

-                if( p_reg_buf != NULL )

-                {

-                    if( RegQueryValueEx( i_key, p_reg_keys[ i ][ 1 ],

-                                         NULL, NULL, p_reg_buf,

-                                         &i_size ) == ERROR_SUCCESS )

-                    {

-                        taos_add1( p_buffer, (uint8_t *)p_reg_buf,

-                                   i_size );

-                    }

+/*****************************************************************************

+ * GetSystemKey: get the system key

+ *****************************************************************************

+ * Compute the system key from various system information, see HashSystemInfo.

+ *****************************************************************************/

+static int GetSystemKey( uint32_t *p_sys_key, uint32_t b_ipod )

+{

+    static char const p_secret1[ 8 ] = "YuaFlafu";

+    static char const p_secret2[ 8 ] = "zPif98ga";

+    struct md5_s md5;

+    int64_t i_ipod_id;

+    uint32_t p_system_hash[ 4 ];

+    /* Compute the MD5 hash of our system info */

+    if( ( !b_ipod && HashSystemInfo( p_system_hash ) ) ||

+        (  b_ipod && GetiPodID( &i_ipod_id ) ) )

+    {

+        return -1;

+    }

-                    free( p_reg_buf );

-                }

-            }

+    /* Combine our system info hash with additional secret data. The resulting

+     * MD5 hash will be our system key. */

+    InitMD5( &md5 );

+    AddMD5( &md5, p_secret1, 8 );

-            RegCloseKey( i_key );

-        }

+    if( !b_ipod )

+    {

+        AddMD5( &md5, (uint8_t *)p_system_hash, 6 );

+        AddMD5( &md5, (uint8_t *)p_system_hash, 6 );

+        AddMD5( &md5, (uint8_t *)p_system_hash, 6 );

+        AddMD5( &md5, p_secret2, 8 );

+    else

+    {

+        i_ipod_id = U64_AT(&i_ipod_id);

+        AddMD5( &md5, (uint8_t *)&i_ipod_id, sizeof(i_ipod_id) );

+        AddMD5( &md5, (uint8_t *)&i_ipod_id, sizeof(i_ipod_id) );

+        AddMD5( &md5, (uint8_t *)&i_ipod_id, sizeof(i_ipod_id) );

+    }

-#else

-    i_ret = -1;

-#endif

+    EndMD5( &md5 );

-    return( i_ret );

+    memcpy( p_sys_key, md5.p_digest, 16 );

+    return 0;

-static int get_sci_data( uint32_t p_sci[ 11 ][ 4 ] )

+#ifdef _WIN32

+#   define DRMS_DIRNAME "drms"

+#else

+#   define DRMS_DIRNAME ".drms"

+#endif

+/*****************************************************************************

+ * WriteUserKey: write the user key to hard disk

+ *****************************************************************************

+ * Write the user key to the hard disk so that it can be reused later or used

+ * on operating systems other than Win32.

+ *****************************************************************************/

+static int WriteUserKey( void *_p_drms, uint32_t *p_user_key )

+    struct drms_s *p_drms = (struct drms_s *)_p_drms;

+    FILE *file;

     int i_ret = -1;

+    char psz_path[ PATH_MAX ];

-#ifdef _WIN32

-    HANDLE i_file;

-    DWORD i_size, i_read;

-    TCHAR p_path[ MAX_PATH ];

-    TCHAR *p_filename = _T("\\Apple Computer\\iTunes\\SC Info\\SC Info.sidb");

+    sprintf( psz_path, /* PATH_MAX - 1, */

+              "%s/" DRMS_DIRNAME, p_drms->psz_homedir );

-    typedef HRESULT (WINAPI *SHGETFOLDERPATH)( HWND, int, HANDLE, DWORD,

-                                               LPTSTR );

-    HINSTANCE shfolder_dll = NULL;

-    SHGETFOLDERPATH dSHGetFolderPath = NULL;

-    if( ( shfolder_dll = LoadLibrary( _T("SHFolder.dll") ) ) != NULL )

-    {

-        dSHGetFolderPath =

-            (SHGETFOLDERPATH)GetProcAddress( shfolder_dll,

-#ifdef _UNICODE

-                                             _T("SHGetFolderPathW") );

+#if defined( HAVE_ERRNO_H )

+#   if defined( _WIN32 )

+    if( !mkdir( psz_path ) || errno == EEXIST )

+#   else

+    if( !mkdir( psz_path, 0755 ) || errno == EEXIST )

+#   endif

 #else

-                                             _T("SHGetFolderPathA") );

+    if( !mkdir( psz_path ) )

 #endif

-    }

-    if( dSHGetFolderPath != NULL &&

-        SUCCEEDED( dSHGetFolderPath( NULL, /*CSIDL_COMMON_APPDATA*/ 0x0023,

-                                     NULL, 0, p_path ) ) )

-        _tcsncat( p_path, p_filename, min( _tcslen( p_filename ),

-                  (MAX_PATH-1) - _tcslen( p_path ) ) );

+        sprintf( psz_path, /*PATH_MAX - 1,*/ "%s/" DRMS_DIRNAME "/%08X.%03d",

+                  p_drms->psz_homedir, p_drms->i_user, p_drms->i_key );

-        i_file = CreateFile( p_path, GENERIC_READ, 0, NULL,

-                             OPEN_EXISTING, 0, NULL );

-        if( i_file != INVALID_HANDLE_VALUE )

+        file = fopen( psz_path, "w" );

+        if( file != NULL )

-            i_read = sizeof(p_sci[ 0 ]) * 11;

-            i_size = GetFileSize( i_file, NULL );

-            if( i_size != INVALID_FILE_SIZE && i_size >= i_read )

-            {

-                i_size = SetFilePointer( i_file, 4, NULL, FILE_BEGIN );

-                if( i_size != /*INVALID_SET_FILE_POINTER*/ ((DWORD)-1))

-                {

-                    if( ReadFile( i_file, p_sci, i_read, &i_size, NULL ) &&

-                        i_size == i_read )

-                    {

-                        i_ret = 0;

-                    }

-                }

-            }

-            CloseHandle( i_file );

+            i_ret = fwrite( p_user_key, sizeof(uint32_t),

+                            4, file ) == 4 ? 0 : -1;

+            fclose( file );

-#endif

-    return( i_ret );

+    return i_ret;

-static void acei_taxs( uint32_t *p_acei, uint32_t i_val )

+/*****************************************************************************

+ * ReadUserKey: read the user key from hard disk

+ *****************************************************************************

+ * Retrieve the user key from the hard disk if available.

+ *****************************************************************************/

+static int ReadUserKey( void *_p_drms, uint32_t *p_user_key )

-    uint32_t i, x;

+    struct drms_s *p_drms = (struct drms_s *)_p_drms;

+    FILE *file;

+    int i_ret = -1;

+    char psz_path[ PATH_MAX ];

-    i = (i_val / 16) & 15;

-    x = (~(i_val & 15)) & 15;

+    sprintf( psz_path, /*PATH_MAX - 1,*/

+              "%s/" DRMS_DIRNAME "/%08X.%03d", p_drms->psz_homedir,

+              p_drms->i_user, p_drms->i_key );

-    if( (i_val & 768) == 768 )

+    file = fopen( psz_path, "r" );

+    if( file != NULL )

-        x = (~i) & 15;

-        i = i_val & 15;

-        p_acei[ 25 + i ] = p_acei[ 25 + ((16 - x) & 15) ]

-                         + p_acei[ 25 + (15 - x) ];

+        i_ret = fread( p_user_key, sizeof(uint32_t),

+                       4, file ) == 4 ? 0 : -1;

+        fclose( file );

-    else if( (i_val & 512) == 512 )

-    {

-        p_acei[ 25 + i ] ^= p_drms_tab_xor[ 15 - i ][ x ];

-    }

-    else if( (i_val & 256) == 256 )

-    {

-        p_acei[ 25 + i ] -= p_drms_tab_sub[ 15 - i ][ x ];

-    }

-    else

-    {

-        p_acei[ 25 + i ] += p_drms_tab_add[ 15 - i ][ x ];

-    }

+    return i_ret;

-static void acei( uint32_t *p_acei, uint8_t *p_buffer, uint32_t i_len )

+/*****************************************************************************

+ * GetUserKey: get the user key

+ *****************************************************************************

+ * Retrieve the user key from the hard disk if available, otherwise generate

+ * it from the system key. If the key could be successfully generated, write

+ * it to the hard disk for future use.

+ *****************************************************************************/

+static int GetUserKey( void *_p_drms, uint32_t *p_user_key )

-    uint32_t i, x;

-    uint32_t p_tmp[ 26 ];

+    static char const p_secret[] = "mUfnpognadfgf873";

+    struct drms_s *p_drms = (struct drms_s *)_p_drms;

+    struct aes_s aes;

+    struct shuffle_s shuffle;

+    uint32_t i, y;

+    uint32_t *p_sci_data;

+    uint32_t i_user, i_key;

+    uint32_t p_sys_key[ 4 ];

+    uint32_t i_sci_size, i_blocks, i_remaining;

+    uint32_t *p_sci0, *p_sci1, *p_buffer;

+    uint32_t p_sci_key[ 4 ];

+    char *psz_ipod;

+    int i_ret = -1;

-    for( i = 5; i < 25; i++ )

+    if( !ReadUserKey( p_drms, p_user_key ) )

-        if( p_acei[ i ] )

-        {

-            acei_taxs( p_acei, p_acei[ i ] );

-        }

+        REVERSE( p_user_key, 4 );

+        return 0;

-    TAOS_INIT( p_tmp, 2 );

-    taos_add2e( p_tmp, &p_acei[ 25 ], sizeof(*p_acei) * 4 );

-    taos_end2( p_tmp );

+    psz_ipod = getenv( "IPOD" );

-    x = i_len < 16 ? i_len : 16;

+    if( GetSystemKey( p_sys_key, psz_ipod ? 1 : 0 ) )

+    {

+        return -1;

+    }

-    if( x > 0 )

+    if( GetSCIData( psz_ipod, &p_sci_data, &i_sci_size ) )

-        for( i = 0; i < x; i++ )

-        {

-            p_buffer[ i ] ^= ((uint8_t *)&p_tmp)[ 88 + i ];

-        }

+        return -1;

-}

-static uint32_t ttov_calc( uint32_t *p_acei )

-{

-    int32_t i_val;

-    uint32_t p_tmp[ 26 ];

+    /* Phase 1: unscramble the SCI data using the system key and shuffle

+     *          it using DoShuffle(). */

-    TAOS_INIT( p_tmp, 2 );

-    taos_add2e( p_tmp, &p_acei[ 0 ], 4 );

-    taos_add2e( p_tmp, &p_acei[ 4 ], 1 );

-    taos_end2( p_tmp );

+    /* Skip the first 4 bytes (some sort of header). Decrypt the rest. */

+    i_blocks = (i_sci_size - 4) / 16;

+    i_remaining = (i_sci_size - 4) - (i_blocks * 16);

+    p_buffer = p_sci_data + 1;

-    p_acei[ 4 ]++;

+    /* Decrypt and shuffle our data at the same time */

+    InitAES( &aes, p_sys_key );

+    REVERSE( p_sys_key, 4 );

+    InitShuffle( &shuffle, p_sys_key );

-    i_val = ((int32_t)U32_AT(&p_tmp[ 22 ])) % 1024;

+    memcpy( p_sci_key, p_secret, 16 );

+    REVERSE( p_sci_key, 4 );

-    return( i_val < 0 ? i_val * -1 : i_val );

-}

+    while( i_blocks-- )

+    {

+        uint32_t p_tmp[ 4 ];

-static void acei_init( uint32_t *p_acei, uint32_t *p_sys_key )

-{

-    uint32_t i;

+        REVERSE( p_buffer, 4 );

+        DecryptAES( &aes, p_tmp, p_buffer );

+        BlockXOR( p_tmp, p_sci_key, p_tmp );

-    for( i = 0; i < 4; i++ )

-    {

-        p_acei[ i ] = U32_AT(&p_sys_key[ i ]);

-    }

+        /* Use the previous scrambled data as the key for next block */

+        memcpy( p_sci_key, p_buffer, 16 );

-    p_acei[ 4 ] = 0x5476212A;

+        /* Shuffle the decrypted data using a custom routine */

+        DoShuffle( &shuffle, p_tmp, 4 );

-    for( i = 5; i < 25; i++ )

+        /* Copy this block back to p_buffer */

+        memcpy( p_buffer, p_tmp, 16 );

+        p_buffer += 4;

+    }

+    if( i_remaining >= 4 )

-        p_acei[ i ] = ttov_calc( p_acei );

+        i_remaining /= 4;

+        REVERSE( p_buffer, i_remaining );

+        DoShuffle( &shuffle, p_buffer, i_remaining );

-    p_acei[ 25 + 0 ] = p_acei[ 0 ];

-    p_acei[ 25 + 1 ] = 0x68723876;

-    p_acei[ 25 + 2 ] = 0x41617376;

-    p_acei[ 25 + 3 ] = 0x4D4B4F76;

+    /* Phase 2: look for the user key in the generated data. I must admit I

+     *          do not understand what is going on here, because it almost

+     *          looks like we are browsing data that makes sense, even though

+     *          the DoShuffle() part made it completely meaningless. */

-    p_acei[ 25 + 4 ] = p_acei[ 1 ];

-    p_acei[ 25 + 5 ] = 0x48556646;

-    p_acei[ 25 + 6 ] = 0x38393725;

-    p_acei[ 25 + 7 ] = 0x2E3B5B3D;

+    y = 0;

+    REVERSE( p_sci_data + 5, 1 );

+    i = U32_AT( p_sci_data + 5 );

+    i_sci_size -= 22 * sizeof(uint32_t);

+    p_sci1 = p_sci_data + 22;

+    p_sci0 = NULL;

-    p_acei[ 25 + 8 ] = p_acei[ 2 ];

-    p_acei[ 25 + 9 ] = 0x37363866;

-    p_acei[ 25 + 10 ] = 0x30383637;

-    p_acei[ 25 + 11 ] = 0x34333661;

+    while( i_sci_size >= 20 && i > 0 )

+    {

+        if( p_sci0 == NULL )

+        {

+            i_sci_size -= 18 * sizeof(uint32_t);

+            if( i_sci_size < 20 )

+            {

+                break;

+            }

-    p_acei[ 25 + 12 ] = p_acei[ 3 ];

-    p_acei[ 25 + 13 ] = 0x37386162;

-    p_acei[ 25 + 14 ] = 0x494F6E66;

-    p_acei[ 25 + 15 ] = 0x2A282966;

-}

+            p_sci0 = p_sci1;

+            REVERSE( p_sci1 + 17, 1 );

+            y = U32_AT( p_sci1 + 17 );

+            p_sci1 += 18;

+        }

-static __inline void block_xor( uint32_t *p_in, uint32_t *p_key,

-                              uint32_t *p_out )

-{

-    uint32_t i;

+        if( !y )

+        {

+            i--;

+            p_sci0 = NULL;

+            continue;

+        }

-    for( i = 0; i < 4; i++ )

-    {

-        p_out[ i ] = p_key[ i ] ^ p_in[ i ];

-    }

-}

+        i_user = U32_AT( p_sci0 );

+        i_key = U32_AT( p_sci1 );

+        REVERSE( &i_user, 1 );

+        REVERSE( &i_key, 1 );

+        if( i_user == p_drms->i_user && ( ( i_key == p_drms->i_key ) ||

+            ( !p_drms->i_key && ( p_sci1 == (p_sci0 + 18) ) ) ) )

+        {

+            memcpy( p_user_key, p_sci1 + 1, 16 );

+            REVERSE( p_sci1 + 1, 4 );

+            WriteUserKey( p_drms, p_sci1 + 1 );

+            i_ret = 0;

+            break;

+        }

-int drms_get_sys_key( uint32_t *p_sys_key )

-{

-    uint32_t p_tmp[ 128 ];

-    uint32_t p_tmp_key[ 4 ];

-    TAOS_INIT( p_tmp, 8 );

-    if( taos_osi( p_tmp ) )

-    {

-        return( -1 );

+        y--;

+        p_sci1 += 5;

+        i_sci_size -= 5 * sizeof(uint32_t);

-    taos_end1( p_tmp, p_tmp_key );

-    TAOS_INIT( p_tmp, 2 );

-    taos_add2( p_tmp, "YuaFlafu", 8 );

-    taos_add2( p_tmp, (uint8_t *)p_tmp_key, 6 );

-    taos_add2( p_tmp, (uint8_t *)p_tmp_key, 6 );

-    taos_add2( p_tmp, (uint8_t *)p_tmp_key, 6 );

-    taos_add2( p_tmp, "zPif98ga", 8 );

-    taos_end2( p_tmp );

+    free( p_sci_data );

-    memcpy( p_sys_key, &p_tmp[ 2 ], sizeof(*p_sys_key) * 4 );

-    return( 0 );

+    return i_ret;

-int drms_get_user_key( uint32_t *p_sys_key, uint32_t *p_user_key )

+/*****************************************************************************

+ * GetSCIData: get SCI data from "SC Info.sidb"

+ *****************************************************************************

+ * Read SCI data from "\Apple Computer\iTunes\SC Info\SC Info.sidb"

+ *****************************************************************************/

+static int GetSCIData( char *psz_ipod, uint32_t **pp_sci,

+                       uint32_t *pi_sci_size )

-    uint32_t i;

-    uint32_t p_tmp[ 4 ];

-    uint32_t *p_cur_key;

-    uint32_t p_acei[ 41 ];

-    uint32_t p_ctx[ 128 ];

-    uint32_t p_sci[ 2 ][ 11 ][ 4 ];

+    FILE *file;

+    char *psz_path = NULL;

+    char p_tmp[ PATH_MAX ];

+    int i_ret = -1;

-    uint32_t p_sci_key[ 4 ] =

+    if( psz_ipod == NULL )

-        0x6E66556D, 0x6E676F70, 0x67666461, 0x33373866

-    };

+#ifdef _WIN32

+        char *p_filename = "\\Apple Computer\\iTunes\\SC Info\\SC Info.sidb";

+        typedef HRESULT (WINAPI *SHGETFOLDERPATH)( HWND, int, HANDLE, DWORD,

+                                                   LPSTR );

+        HINSTANCE shfolder_dll = NULL;

+        SHGETFOLDERPATH dSHGetFolderPath = NULL;

-    if( p_sys_key == NULL )

-    {

-        if( drms_get_sys_key( p_tmp ) )

+        if( ( shfolder_dll = LoadLibrary( _T("SHFolder.dll") ) ) != NULL )

-            return( -1 );

+            dSHGetFolderPath =

+                (SHGETFOLDERPATH)GetProcAddress( shfolder_dll,

+                                                 _T("SHGetFolderPathA") );

-        p_sys_key = p_tmp;

-    }

+        if( dSHGetFolderPath != NULL &&

+            SUCCEEDED( dSHGetFolderPath( NULL, /*CSIDL_COMMON_APPDATA*/ 0x0023,

+                                         NULL, 0, p_tmp ) ) )

+        {

+            strncat( p_tmp, p_filename, min( strlen( p_filename ),

+                     (sizeof(p_tmp)/sizeof(p_tmp[0]) - 1) -

+                     strlen( p_tmp ) ) );

+            psz_path = p_tmp;

+        }

-    if( get_sci_data( p_sci[ 0 ] ) )

+        if( shfolder_dll != NULL )

+        {

+            FreeLibrary( shfolder_dll );

+        }

+#endif

+    }

+    else

-        return( -1 );

+#define ISCINFO "iSCInfo"

+        if( strstr( psz_ipod, ISCINFO ) == NULL )

+        {

+            sprintf( p_tmp, /*sizeof(p_tmp)/sizeof(p_tmp[0]) - 1,*/

+                      "%s/iPod_Control/iTunes/" ISCINFO, psz_ipod );

+            psz_path = p_tmp;

+        }

+        else

+        {

+            psz_path = psz_ipod;

+        }

-    init_ctx( p_ctx, p_sys_key );

-    for( i = 0, p_cur_key = p_sci_key;

-         i < sizeof(p_sci[ 0 ])/sizeof(p_sci[ 0 ][ 0 ]); i++ )

+    if( psz_path == NULL )

-        ctx_xor( p_ctx, &p_sci[ 0 ][ i ][ 0 ], &p_sci[ 1 ][ i ][ 0 ],

-                 p_drms_tab3, p_drms_tab4 );

-        block_xor( &p_sci[ 1 ][ i ][ 0 ], p_cur_key, &p_sci[ 1 ][ i ][ 0 ] );

-        p_cur_key = &p_sci[ 0 ][ i ][ 0 ];

+        return -1;

-    acei_init( p_acei, p_sys_key );

-    for( i = 0; i < sizeof(p_sci[ 1 ])/sizeof(p_sci[ 1 ][ 0 ]); i++ )

+    file = fopen( psz_path, "r" );

+    if( file != NULL )

-        acei( p_acei, (uint8_t *)&p_sci[ 1 ][ i ][ 0 ],

-              sizeof(p_sci[ 1 ][ i ]) );

-    }

+        struct stat st;

-    memcpy( p_user_key, &p_sci[ 1 ][ 10 ][ 0 ], sizeof(p_sci[ 1 ][ i ]) );

-    return( 0 );

-}

-struct drms_s

-{

-    uint8_t *p_iviv;

-    uint32_t i_iviv_len;

-    uint8_t *p_name;

-    uint32_t i_name_len;

+        if( !fstat( fileno( file ), &st ) )

+        {

+            *pp_sci = malloc( st.st_size );

+            if( *pp_sci != NULL )

+            {

+                if( fread( *pp_sci, 1, st.st_size,

+                           file ) == (size_t)st.st_size )

+                {

+                    *pi_sci_size = st.st_size;

+                    i_ret = 0;

+                }

+                else

+                {

+                    free( (void *)*pp_sci );

+                    *pp_sci = NULL;

+                }

+            }

+        }

-    uint32_t *p_tmp;

-    uint32_t i_tmp_len;

+        fclose( file );

+    }

-    uint32_t p_key[ 4 ];

-    uint32_t p_ctx[ 128 ];

-};

+    return i_ret;

+}

-#define P_DRMS ((struct drms_s *)p_drms)

-void *drms_alloc()

+/*****************************************************************************

+ * HashSystemInfo: hash system information

+ *****************************************************************************

+ * This function computes the MD5 hash of the C: hard drive serial number,

+ * BIOS version, CPU type and Windows version.

+ *****************************************************************************/

+static int HashSystemInfo( uint32_t *p_system_hash )

-    struct drms_s *p_drms;

+    struct md5_s md5;

+    int i_ret = 0;

-    p_drms = malloc( sizeof(struct drms_s) );

+#ifdef _WIN32

+    HKEY i_key;

+    unsigned int i;

+    DWORD i_size;

+    DWORD i_serial;

+    LPBYTE p_reg_buf;

-    if( p_drms != NULL )

+    static LPCTSTR p_reg_keys[ 3 ][ 2 ] =

-        memset( p_drms, 0, sizeof(struct drms_s) );

+        {

+            _T("HARDWARE\\DESCRIPTION\\System"),

+            _T("SystemBiosVersion")

+        },

-        p_drms->i_tmp_len = 1024;

-        p_drms->p_tmp = malloc( p_drms->i_tmp_len );

-        if( p_drms->p_tmp == NULL )

-            free( (void *)p_drms );

-            p_drms = NULL;

+            _T("HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0"),

+            _T("ProcessorNameString")

+        },

+        {

+            _T("SOFTWARE\\Microsoft\\Windows\\CurrentVersion"),

+            _T("ProductId")

-    }

+    };

-    return( (void *)p_drms );

-}

+    InitMD5( &md5 );

-void drms_free( void *p_drms )

-{

-    if( P_DRMS->p_name != NULL )

-    {

-        free( (void *)P_DRMS->p_name );

-    }

+    AddMD5( &md5, "cache-control", 13 );

+    AddMD5( &md5, "Ethernet", 8 );

-    if( P_DRMS->p_iviv != NULL )

-    {

-        free( (void *)P_DRMS->p_iviv );

-    }

+    GetVolumeInformation( _T("C:\\"), NULL, 0, &i_serial,

+                          NULL, NULL, NULL, 0 );

+    AddMD5( &md5, (uint8_t *)&i_serial, 4 );

-    if( P_DRMS->p_tmp != NULL )

+    for( i = 0; i < sizeof(p_reg_keys) / sizeof(p_reg_keys[ 0 ]); i++ )

-        free( (void *)P_DRMS->p_tmp );

-    }

+        if( RegOpenKeyEx( HKEY_LOCAL_MACHINE, p_reg_keys[ i ][ 0 ],

+                          0, KEY_READ, &i_key ) != ERROR_SUCCESS )

+        {

+            continue;

+        }

-    free( p_drms );

-}

+        if( RegQueryValueEx( i_key, p_reg_keys[ i ][ 1 ],

+                             NULL, NULL, NULL, &i_size ) != ERROR_SUCCESS )

+        {

+            RegCloseKey( i_key );

+            continue;

+        }

-void drms_decrypt( void *p_drms, uint32_t *p_buffer, uint32_t i_len )

-{

-    uint32_t i, x, y;

-    uint32_t *p_cur_key = P_DRMS->p_key;

+        p_reg_buf = malloc( i_size );

-    x = (i_len / sizeof(P_DRMS->p_key)) * sizeof(P_DRMS->p_key);

+        if( p_reg_buf != NULL )

+        {

+            if( RegQueryValueEx( i_key, p_reg_keys[ i ][ 1 ],

+                                 NULL, NULL, p_reg_buf,

+                                 &i_size ) == ERROR_SUCCESS )

+            {

+                AddMD5( &md5, (uint8_t *)p_reg_buf, i_size );

+            }

-    if( P_DRMS->i_tmp_len < x )

-    {

-        free( (void *)P_DRMS->p_tmp );

+            free( p_reg_buf );

+        }

-        P_DRMS->i_tmp_len = x;

-        P_DRMS->p_tmp = malloc( P_DRMS->i_tmp_len );

+        RegCloseKey( i_key );

-    if( P_DRMS->p_tmp != NULL )

-    {

-        memcpy( P_DRMS->p_tmp, p_buffer, x );

+#else

+    InitMD5( &md5 );

+    i_ret = -1;

+#endif

-        for( i = 0, x /= sizeof(P_DRMS->p_key); i < x; i++ )

-        {

-            y = i * sizeof(*p_buffer);

+    EndMD5( &md5 );

+    memcpy( p_system_hash, md5.p_digest, 16 );

-            ctx_xor( P_DRMS->p_ctx, P_DRMS->p_tmp + y, p_buffer + y,

-                     p_drms_tab3, p_drms_tab4 );

-            block_xor( p_buffer + y, p_cur_key, p_buffer + y );

-            p_cur_key = P_DRMS->p_tmp + y;

-        }

-    }

+    return i_ret;

-int drms_init( void *p_drms, uint32_t i_type,

-               uint8_t *p_info, uint32_t i_len )

+/*****************************************************************************

+ * GetiPodID: Get iPod ID

+ *****************************************************************************

+ * This function gets the iPod ID.

+ *****************************************************************************/

+static int GetiPodID( int64_t *p_ipod_id )

-    int i_ret = 0;

+    int i_ret = -1;

-    switch( i_type )

+#define PROD_NAME   "iPod"

+#define VENDOR_NAME "Apple Computer, Inc."

+    char *psz_ipod_id = getenv( "IPODID" );

+    if( psz_ipod_id != NULL )

-        case DRMS_INIT_UKEY:

-        {

-            if( i_len != sizeof(P_DRMS->p_key) )

-            {

-                i_ret = -1;

-                break;

-            }

+#ifndef _WIN32

+        *p_ipod_id = strtoll( psz_ipod_id, NULL, 16 );

+#else

+        *p_ipod_id = strtol( psz_ipod_id, NULL, 16 );

+#endif

+        return 0;

+    }

-            init_ctx( P_DRMS->p_ctx, (uint32_t *)p_info );

-        }

-        break;

+#ifdef HAVE_IOKIT_IOKITLIB_H

+    CFTypeRef value;

+    mach_port_t port;

+    io_object_t device;

+    io_iterator_t iterator;

+    CFMutableDictionaryRef matching_dic;

-        case DRMS_INIT_IVIV:

+    if( IOMasterPort( MACH_PORT_NULL, &port ) == KERN_SUCCESS )

+    {

+        if( ( matching_dic = IOServiceMatching( "IOFireWireUnit" ) ) != NULL )

-            if( i_len != sizeof(P_DRMS->p_key) )

-            {

-                i_ret = -1;

-                break;

-            }

+            CFDictionarySetValue( matching_dic,

+                                  CFSTR("FireWire Vendor Name"),

+                                  CFSTR(VENDOR_NAME) );

+            CFDictionarySetValue( matching_dic,

+                                  CFSTR("FireWire Product Name"),

+                                  CFSTR(PROD_NAME) );

-            P_DRMS->p_iviv = malloc( i_len );

-            if( P_DRMS->p_iviv == NULL )

+            if( IOServiceGetMatchingServices( port, matching_dic,

+                                              &iterator ) == KERN_SUCCESS )

-                i_ret = -1;

-                break;

-            }

+                while( ( device = IOIteratorNext( iterator ) ) != NULL )

+                {

+                    value = IORegistryEntryCreateCFProperty( device,

+                        CFSTR("GUID"), kCFAllocatorDefault, kNilOptions );

-            memcpy( P_DRMS->p_iviv, p_info, i_len );

-            P_DRMS->i_iviv_len = i_len;

-        }

-        break;

+                    if( value != NULL )

+                    {

+                        if( CFGetTypeID( value ) == CFNumberGetTypeID() )

+                        {

+                            int64_t i_ipod_id;

+                            CFNumberGetValue( (CFNumberRef)value,

+                                              kCFNumberLongLongType,

+                                              &i_ipod_id );

+                            *p_ipod_id = i_ipod_id;

+                            i_ret = 0;

+                        }

-        case DRMS_INIT_NAME:

-        {

-            P_DRMS->p_name = malloc( i_len );

-            if( P_DRMS->p_name == NULL )

-            {

-                i_ret = -1;

-                break;

-            }

+                        CFRelease( value );

+                    }

-            memcpy( P_DRMS->p_name, p_info, i_len );

-            P_DRMS->i_name_len = i_len;

-        }

-        break;

+                    IOObjectRelease( device );

-        case DRMS_INIT_PRIV:

-        {

-            uint32_t i;

-            uint32_t p_priv[ 64 ];

-            uint32_t p_tmp[ 128 ];

+                    if( !i_ret ) break;

+                }

-            if( i_len < 64 )

-            {

-                i_ret = -1;

-                break;

+                IOObjectRelease( iterator );

+        }

-            TAOS_INIT( p_tmp, 0 );

-            taos_add3( p_tmp, P_DRMS->p_name, P_DRMS->i_name_len );

-            taos_add3( p_tmp, P_DRMS->p_iviv, P_DRMS->i_iviv_len );

-            memcpy( p_priv, &p_tmp[ 4 ], sizeof(p_priv[ 0 ]) * 2 );

-            i = (p_tmp[ 4 ] / 8) & 63;

-            i = i >= 56 ? 120 - i : 56 - i;

-            taos_add3( p_tmp, p_drms_tab_tend, i );

-            taos_add3( p_tmp, (uint8_t *)p_priv, sizeof(p_priv[ 0 ]) * 2 );

+        mach_port_deallocate( mach_task_self(), port );

+    }

-            memcpy( p_priv, p_info, 64 );

-            memcpy( P_DRMS->p_key, p_tmp, sizeof(P_DRMS->p_key) );

-            drms_decrypt( p_drms, p_priv, sizeof(p_priv) );

+#elif HAVE_SYSFS_LIBSYSFS_H

+    struct sysfs_bus *bus = NULL;

+    struct dlist *devlist = NULL;

+    struct dlist *attributes = NULL;

+    struct sysfs_device *curdev = NULL;

+    struct sysfs_attribute *curattr = NULL;

-            init_ctx( P_DRMS->p_ctx, &p_priv[ 6 ] );

-            memcpy( P_DRMS->p_key, &p_priv[ 12 ], sizeof(P_DRMS->p_key) );

-            free( (void *)P_DRMS->p_name );

-            P_DRMS->p_name = NULL;

-            free( (void *)P_DRMS->p_iviv );

-            P_DRMS->p_iviv = NULL;

-        }

-        break;

-    }

-    return( i_ret );

-}

+    bus = sysfs_open_bus( "ieee1394" );

+    if( bus != NULL )

+    {

+        devlist = sysfs_get_bus_devices( bus );

+        if( devlist != NULL )

+        {

+            dlist_for_each_data( devlist, curdev, struct sysfs_device )

+            {

+                attributes = sysfs_get_device_attributes( curdev );

+                if( attributes != NULL )

+                {

+                    dlist_for_each_data( attributes, curattr,

+                                         struct sysfs_attribute )

+                    {

+                        if( ( strcmp( curattr->name, "model_name" ) == 0 ) &&

+                            ( strncmp( curattr->value, PROD_NAME,

+                                       sizeof(PROD_NAME) ) == 0 ) )

+                        {

+                            *p_ipod_id = strtoll( curdev->name, NULL, 16 );

+                            i_ret = 0;

+                            break;

+                        }

+                    }

+                }

-#undef P_DRMS

+                if( !i_ret ) break;

+            }

+        }

+        sysfs_close_bus( bus );

+    }

 #endif

+    return i_ret;

+}

+#endif

--- a/common/mp4ff/drms.h

+++ b/common/mp4ff/drms.h

@@ -2,7 +2,7 @@

  * drms.h : DRMS

  *****************************************************************************

  * Copyright (C) 2004 VideoLAN

- * $Id: drms.h,v 1.4 2004/03/27 11:14:48 menno Exp $

+ * $Id: drms.h,v 1.5 2004/03/31 17:39:57 menno Exp $

  * Author: Jon Lech Johansen <jon-vl@nanocrew.net>

@@ -21,16 +21,7 @@

  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.

  *****************************************************************************/

-#define DRMS_INIT_UKEY  0

-#define DRMS_INIT_IVIV  1

-#define DRMS_INIT_NAME  2

-#define DRMS_INIT_PRIV  3

-extern int drms_get_sys_key( uint32_t *p_sys_key );

-extern int drms_get_user_key( uint32_t *p_sys_key,

-                              uint32_t *p_user_key );

-extern void *drms_alloc();

+extern void *drms_alloc( char *psz_homedir );

 extern void drms_free( void *p_drms );

 extern int drms_init( void *p_drms, uint32_t i_type,

                       uint8_t *p_info, uint32_t i_len );

--- a/common/mp4ff/drmstables.h

+++ b/common/mp4ff/drmstables.h

@@ -1,8 +1,8 @@

 /*****************************************************************************

- * drmstables.h : DRMS tables

+ * drmstables.h : AES/Rijndael block cipher and miscellaneous tables

  *****************************************************************************

  * Copyright (C) 2004 VideoLAN

- * $Id: drmstables.h,v 1.3 2004/03/27 11:14:48 menno Exp $

+ * $Id: drmstables.h,v 1.4 2004/03/31 17:39:57 menno Exp $

  * Author: Jon Lech Johansen <jon-vl@nanocrew.net>

@@ -21,428 +21,268 @@

  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.

  *****************************************************************************/

-static uint32_t p_drms_tab1[ 10 ] =

-{

-    0x00000001, 0x00000002, 0x00000004, 0x00000008, 0x00000010, 0x00000020,

-    0x00000040, 0x00000080, 0x0000001B, 0x00000036

-};

+#define AES_ROR( x, n ) (((x) << (32-(n))) | ((x) >> (n)))

-static uint32_t p_drms_tab2[ 256 ] =

-{

-    0x63000000, 0x7C000000, 0x77000000, 0x7B000000, 0xF2000000, 0x6B000000,

-    0x6F000000, 0xC5000000, 0x30000000, 0x01000000, 0x67000000, 0x2B000000,

-    0xFE000000, 0xD7000000, 0xAB000000, 0x76000000, 0xCA000000, 0x82000000,

-    0xC9000000, 0x7D000000, 0xFA000000, 0x59000000, 0x47000000, 0xF0000000,

-    0xAD000000, 0xD4000000, 0xA2000000, 0xAF000000, 0x9C000000, 0xA4000000,

-    0x72000000, 0xC0000000, 0xB7000000, 0xFD000000, 0x93000000, 0x26000000,

-    0x36000000, 0x3F000000, 0xF7000000, 0xCC000000, 0x34000000, 0xA5000000,

-    0xE5000000, 0xF1000000, 0x71000000, 0xD8000000, 0x31000000, 0x15000000,

-    0x04000000, 0xC7000000, 0x23000000, 0xC3000000, 0x18000000, 0x96000000,

-    0x05000000, 0x9A000000, 0x07000000, 0x12000000, 0x80000000, 0xE2000000,

-    0xEB000000, 0x27000000, 0xB2000000, 0x75000000, 0x09000000, 0x83000000,

-    0x2C000000, 0x1A000000, 0x1B000000, 0x6E000000, 0x5A000000, 0xA0000000,

-    0x52000000, 0x3B000000, 0xD6000000, 0xB3000000, 0x29000000, 0xE3000000,

-    0x2F000000, 0x84000000, 0x53000000, 0xD1000000, 0x00000000, 0xED000000,

-    0x20000000, 0xFC000000, 0xB1000000, 0x5B000000, 0x6A000000, 0xCB000000,

-    0xBE000000, 0x39000000, 0x4A000000, 0x4C000000, 0x58000000, 0xCF000000,

-    0xD0000000, 0xEF000000, 0xAA000000, 0xFB000000, 0x43000000, 0x4D000000,

-    0x33000000, 0x85000000, 0x45000000, 0xF9000000, 0x02000000, 0x7F000000,

-    0x50000000, 0x3C000000, 0x9F000000, 0xA8000000, 0x51000000, 0xA3000000,

-    0x40000000, 0x8F000000, 0x92000000, 0x9D000000, 0x38000000, 0xF5000000,

-    0xBC000000, 0xB6000000, 0xDA000000, 0x21000000, 0x10000000, 0xFF000000,

-    0xF3000000, 0xD2000000, 0xCD000000, 0x0C000000, 0x13000000, 0xEC000000,

-    0x5F000000, 0x97000000, 0x44000000, 0x17000000, 0xC4000000, 0xA7000000,

-    0x7E000000, 0x3D000000, 0x64000000, 0x5D000000, 0x19000000, 0x73000000,

-    0x60000000, 0x81000000, 0x4F000000, 0xDC000000, 0x22000000, 0x2A000000,

-    0x90000000, 0x88000000, 0x46000000, 0xEE000000, 0xB8000000, 0x14000000,

-    0xDE000000, 0x5E000000, 0x0B000000, 0xDB000000, 0xE0000000, 0x32000000,

-    0x3A000000, 0x0A000000, 0x49000000, 0x06000000, 0x24000000, 0x5C000000,

-    0xC2000000, 0xD3000000, 0xAC000000, 0x62000000, 0x91000000, 0x95000000,

-    0xE4000000, 0x79000000, 0xE7000000, 0xC8000000, 0x37000000, 0x6D000000,

-    0x8D000000, 0xD5000000, 0x4E000000, 0xA9000000, 0x6C000000, 0x56000000,

-    0xF4000000, 0xEA000000, 0x65000000, 0x7A000000, 0xAE000000, 0x08000000,

-    0xBA000000, 0x78000000, 0x25000000, 0x2E000000, 0x1C000000, 0xA6000000,

-    0xB4000000, 0xC6000000, 0xE8000000, 0xDD000000, 0x74000000, 0x1F000000,

-    0x4B000000, 0xBD000000, 0x8B000000, 0x8A000000, 0x70000000, 0x3E000000,

-    0xB5000000, 0x66000000, 0x48000000, 0x03000000, 0xF6000000, 0x0E000000,

-    0x61000000, 0x35000000, 0x57000000, 0xB9000000, 0x86000000, 0xC1000000,

-    0x1D000000, 0x9E000000, 0xE1000000, 0xF8000000, 0x98000000, 0x11000000,

-    0x69000000, 0xD9000000, 0x8E000000, 0x94000000, 0x9B000000, 0x1E000000,

-    0x87000000, 0xE9000000, 0xCE000000, 0x55000000, 0x28000000, 0xDF000000,

-    0x8C000000, 0xA1000000, 0x89000000, 0x0D000000, 0xBF000000, 0xE6000000,

-    0x42000000, 0x68000000, 0x41000000, 0x99000000, 0x2D000000, 0x0F000000,

-    0xB0000000, 0x54000000, 0xBB000000, 0x16000000

-};

+#define AES_XOR_ROR( p_table, p_tmp ) \

+    ( p_table[ (p_tmp[ t > 2 ? t - 3 : t + 1 ] >> 24) & 0xFF ] \

+     ^ AES_ROR( p_table[ (p_tmp[ t > 1 ? t - 2 : t + 2 ] >> 16) & 0xFF ], 8 ) \

+     ^ AES_ROR( p_table[ (p_tmp[ t > 0 ? t - 1 : t + 3 ] >> 8) & 0xFF ], 16 ) \

+     ^ AES_ROR( p_table[ p_tmp[ t ] & 0xFF ], 24 ) )

-static uint32_t p_drms_tab3[ 256 ] =

+#define AES_KEY_COUNT 10

+static uint32_t const p_aes_table[ AES_KEY_COUNT ] =

-    0x5150A7F4, 0x7E536541, 0x1AC3A417, 0x3A965E27, 0x3BCB6BAB, 0x1FF1459D,

-    0xACAB58FA, 0x4B9303E3, 0x2055FA30, 0xADF66D76, 0x889176CC, 0xF5254C02,

-    0x4FFCD7E5, 0xC5D7CB2A, 0x26804435, 0xB58FA362, 0xDE495AB1, 0x25671BBA,

-    0x45980EEA, 0x5DE1C0FE, 0xC302752F, 0x8112F04C, 0x8DA39746, 0x6BC6F9D3,

-    0x03E75F8F, 0x15959C92, 0xBFEB7A6D, 0x95DA5952, 0xD42D83BE, 0x58D32174,

-    0x492969E0, 0x8E44C8C9, 0x756A89C2, 0xF478798E, 0x996B3E58, 0x27DD71B9,

-    0xBEB64FE1, 0xF017AD88, 0xC966AC20, 0x7DB43ACE, 0x63184ADF, 0xE582311A,

-    0x97603351, 0x62457F53, 0xB1E07764, 0xBB84AE6B, 0xFE1CA081, 0xF9942B08,

-    0x70586848, 0x8F19FD45, 0x94876CDE, 0x52B7F87B, 0xAB23D373, 0x72E2024B,

-    0xE3578F1F, 0x662AAB55, 0xB20728EB, 0x2F03C2B5, 0x869A7BC5, 0xD3A50837,

-    0x30F28728, 0x23B2A5BF, 0x02BA6A03, 0xED5C8216, 0x8A2B1CCF, 0xA792B479,

-    0xF3F0F207, 0x4EA1E269, 0x65CDF4DA, 0x06D5BE05, 0xD11F6234, 0xC48AFEA6,

-    0x349D532E, 0xA2A055F3, 0x0532E18A, 0xA475EBF6, 0x0B39EC83, 0x40AAEF60,

-    0x5E069F71, 0xBD51106E, 0x3EF98A21, 0x963D06DD, 0xDDAE053E, 0x4D46BDE6,

-    0x91B58D54, 0x71055DC4, 0x046FD406, 0x60FF1550, 0x1924FB98, 0xD697E9BD,

-    0x89CC4340, 0x67779ED9, 0xB0BD42E8, 0x07888B89, 0xE7385B19, 0x79DBEEC8,

-    0xA1470A7C, 0x7CE90F42, 0xF8C91E84, 0x00000000, 0x09838680, 0x3248ED2B,

-    0x1EAC7011, 0x6C4E725A, 0xFDFBFF0E, 0x0F563885, 0x3D1ED5AE, 0x3627392D,

-    0x0A64D90F, 0x6821A65C, 0x9BD1545B, 0x243A2E36, 0x0CB1670A, 0x930FE757,

-    0xB4D296EE, 0x1B9E919B, 0x804FC5C0, 0x61A220DC, 0x5A694B77, 0x1C161A12,

-    0xE20ABA93, 0xC0E52AA0, 0x3C43E022, 0x121D171B, 0x0E0B0D09, 0xF2ADC78B,

-    0x2DB9A8B6, 0x14C8A91E, 0x578519F1, 0xAF4C0775, 0xEEBBDD99, 0xA3FD607F,

-    0xF79F2601, 0x5CBCF572, 0x44C53B66, 0x5B347EFB, 0x8B762943, 0xCBDCC623,

-    0xB668FCED, 0xB863F1E4, 0xD7CADC31, 0x42108563, 0x13402297, 0x842011C6,

-    0x857D244A, 0xD2F83DBB, 0xAE1132F9, 0xC76DA129, 0x1D4B2F9E, 0xDCF330B2,

-    0x0DEC5286, 0x77D0E3C1, 0x2B6C16B3, 0xA999B970, 0x11FA4894, 0x472264E9,

-    0xA8C48CFC, 0xA01A3FF0, 0x56D82C7D, 0x22EF9033, 0x87C74E49, 0xD9C1D138,

-    0x8CFEA2CA, 0x98360BD4, 0xA6CF81F5, 0xA528DE7A, 0xDA268EB7, 0x3FA4BFAD,

-    0x2CE49D3A, 0x500D9278, 0x6A9BCC5F, 0x5462467E, 0xF6C2138D, 0x90E8B8D8,

-    0x2E5EF739, 0x82F5AFC3, 0x9FBE805D, 0x697C93D0, 0x6FA92DD5, 0xCFB31225,

-    0xC83B99AC, 0x10A77D18, 0xE86E639C, 0xDB7BBB3B, 0xCD097826, 0x6EF41859,

-    0xEC01B79A, 0x83A89A4F, 0xE6656E95, 0xAA7EE6FF, 0x2108CFBC, 0xEFE6E815,

-    0xBAD99BE7, 0x4ACE366F, 0xEAD4099F, 0x29D67CB0, 0x31AFB2A4, 0x2A31233F,

-    0xC63094A5, 0x35C066A2, 0x7437BC4E, 0xFCA6CA82, 0xE0B0D090, 0x3315D8A7,

-    0xF14A9804, 0x41F7DAEC, 0x7F0E50CD, 0x172FF691, 0x768DD64D, 0x434DB0EF,

-    0xCC544DAA, 0xE4DF0496, 0x9EE3B5D1, 0x4C1B886A, 0xC1B81F2C, 0x467F5165,

-    0x9D04EA5E, 0x015D358C, 0xFA737487, 0xFB2E410B, 0xB35A1D67, 0x9252D2DB,

-    0xE9335610, 0x6D1347D6, 0x9A8C61D7, 0x377A0CA1, 0x598E14F8, 0xEB893C13,

-    0xCEEE27A9, 0xB735C961, 0xE1EDE51C, 0x7A3CB147, 0x9C59DFD2, 0x553F73F2,

-    0x1879CE14, 0x73BF37C7, 0x53EACDF7, 0x5F5BAAFD, 0xDF146F3D, 0x7886DB44,

-    0xCA81F3AF, 0xB93EC468, 0x382C3424, 0xC25F40A3, 0x1672C31D, 0xBC0C25E2,

-    0x288B493C, 0xFF41950D, 0x397101A8, 0x08DEB30C, 0xD89CE4B4, 0x6490C156,

-    0x7B6184CB, 0xD570B632, 0x48745C6C, 0xD04257B8

+    0x00000001, 0x00000002, 0x00000004, 0x00000008, 0x00000010, 0x00000020,

+    0x00000040, 0x00000080, 0x0000001b, 0x00000036

};

-static uint32_t p_drms_tab4[ 256 ] =

+static uint32_t const p_aes_encrypt[ 256 ] =

-    0x52000000, 0x09000000, 0x6A000000, 0xD5000000, 0x30000000, 0x36000000,

-    0xA5000000, 0x38000000, 0xBF000000, 0x40000000, 0xA3000000, 0x9E000000,

-    0x81000000, 0xF3000000, 0xD7000000, 0xFB000000, 0x7C000000, 0xE3000000,

-    0x39000000, 0x82000000, 0x9B000000, 0x2F000000, 0xFF000000, 0x87000000,

-    0x34000000, 0x8E000000, 0x43000000, 0x44000000, 0xC4000000, 0xDE000000,

-    0xE9000000, 0xCB000000, 0x54000000, 0x7B000000, 0x94000000, 0x32000000,

-    0xA6000000, 0xC2000000, 0x23000000, 0x3D000000, 0xEE000000, 0x4C000000,

-    0x95000000, 0x0B000000, 0x42000000, 0xFA000000, 0xC3000000, 0x4E000000,

-    0x08000000, 0x2E000000, 0xA1000000, 0x66000000, 0x28000000, 0xD9000000,

-    0x24000000, 0xB2000000, 0x76000000, 0x5B000000, 0xA2000000, 0x49000000,

-    0x6D000000, 0x8B000000, 0xD1000000, 0x25000000, 0x72000000, 0xF8000000,

-    0xF6000000, 0x64000000, 0x86000000, 0x68000000, 0x98000000, 0x16000000,

-    0xD4000000, 0xA4000000, 0x5C000000, 0xCC000000, 0x5D000000, 0x65000000,

-    0xB6000000, 0x92000000, 0x6C000000, 0x70000000, 0x48000000, 0x50000000,

-    0xFD000000, 0xED000000, 0xB9000000, 0xDA000000, 0x5E000000, 0x15000000,

-    0x46000000, 0x57000000, 0xA7000000, 0x8D000000, 0x9D000000, 0x84000000,

-    0x90000000, 0xD8000000, 0xAB000000, 0x00000000, 0x8C000000, 0xBC000000,

-    0xD3000000, 0x0A000000, 0xF7000000, 0xE4000000, 0x58000000, 0x05000000,

-    0xB8000000, 0xB3000000, 0x45000000, 0x06000000, 0xD0000000, 0x2C000000,

-    0x1E000000, 0x8F000000, 0xCA000000, 0x3F000000, 0x0F000000, 0x02000000,

-    0xC1000000, 0xAF000000, 0xBD000000, 0x03000000, 0x01000000, 0x13000000,

-    0x8A000000, 0x6B000000, 0x3A000000, 0x91000000, 0x11000000, 0x41000000,

-    0x4F000000, 0x67000000, 0xDC000000, 0xEA000000, 0x97000000, 0xF2000000,

-    0xCF000000, 0xCE000000, 0xF0000000, 0xB4000000, 0xE6000000, 0x73000000,

-    0x96000000, 0xAC000000, 0x74000000, 0x22000000, 0xE7000000, 0xAD000000,

-    0x35000000, 0x85000000, 0xE2000000, 0xF9000000, 0x37000000, 0xE8000000,

-    0x1C000000, 0x75000000, 0xDF000000, 0x6E000000, 0x47000000, 0xF1000000,

-    0x1A000000, 0x71000000, 0x1D000000, 0x29000000, 0xC5000000, 0x89000000,

-    0x6F000000, 0xB7000000, 0x62000000, 0x0E000000, 0xAA000000, 0x18000000,

-    0xBE000000, 0x1B000000, 0xFC000000, 0x56000000, 0x3E000000, 0x4B000000,

-    0xC6000000, 0xD2000000, 0x79000000, 0x20000000, 0x9A000000, 0xDB000000,

-    0xC0000000, 0xFE000000, 0x78000000, 0xCD000000, 0x5A000000, 0xF4000000,

-    0x1F000000, 0xDD000000, 0xA8000000, 0x33000000, 0x88000000, 0x07000000,

-    0xC7000000, 0x31000000, 0xB1000000, 0x12000000, 0x10000000, 0x59000000,

-    0x27000000, 0x80000000, 0xEC000000, 0x5F000000, 0x60000000, 0x51000000,

-    0x7F000000, 0xA9000000, 0x19000000, 0xB5000000, 0x4A000000, 0x0D000000,

-    0x2D000000, 0xE5000000, 0x7A000000, 0x9F000000, 0x93000000, 0xC9000000,

-    0x9C000000, 0xEF000000, 0xA0000000, 0xE0000000, 0x3B000000, 0x4D000000,

-    0xAE000000, 0x2A000000, 0xF5000000, 0xB0000000, 0xC8000000, 0xEB000000,

-    0xBB000000, 0x3C000000, 0x83000000, 0x53000000, 0x99000000, 0x61000000,

-    0x17000000, 0x2B000000, 0x04000000, 0x7E000000, 0xBA000000, 0x77000000,

-    0xD6000000, 0x26000000, 0xE1000000, 0x69000000, 0x14000000, 0x63000000,

-    0x55000000, 0x21000000, 0x0C000000, 0x7D000000

+    0x63000000, 0x7c000000, 0x77000000, 0x7b000000, 0xf2000000, 0x6b000000,

+    0x6f000000, 0xc5000000, 0x30000000, 0x01000000, 0x67000000, 0x2b000000,

+    0xfe000000, 0xd7000000, 0xab000000, 0x76000000, 0xca000000, 0x82000000,

+    0xc9000000, 0x7d000000, 0xfa000000, 0x59000000, 0x47000000, 0xf0000000,

+    0xad000000, 0xd4000000, 0xa2000000, 0xaf000000, 0x9c000000, 0xa4000000,

+    0x72000000, 0xc0000000, 0xb7000000, 0xfd000000, 0x93000000, 0x26000000,

+    0x36000000, 0x3f000000, 0xf7000000, 0xcc000000, 0x34000000, 0xa5000000,

+    0xe5000000, 0xf1000000, 0x71000000, 0xd8000000, 0x31000000, 0x15000000,

+    0x04000000, 0xc7000000, 0x23000000, 0xc3000000, 0x18000000, 0x96000000,

+    0x05000000, 0x9a000000, 0x07000000, 0x12000000, 0x80000000, 0xe2000000,

+    0xeb000000, 0x27000000, 0xb2000000, 0x75000000, 0x09000000, 0x83000000,

+    0x2c000000, 0x1a000000, 0x1b000000, 0x6e000000, 0x5a000000, 0xa0000000,

+    0x52000000, 0x3b000000, 0xd6000000, 0xb3000000, 0x29000000, 0xe3000000,

+    0x2f000000, 0x84000000, 0x53000000, 0xd1000000, 0x00000000, 0xed000000,

+    0x20000000, 0xfc000000, 0xb1000000, 0x5b000000, 0x6a000000, 0xcb000000,

+    0xbe000000, 0x39000000, 0x4a000000, 0x4c000000, 0x58000000, 0xcf000000,

+    0xd0000000, 0xef000000, 0xaa000000, 0xfb000000, 0x43000000, 0x4d000000,

+    0x33000000, 0x85000000, 0x45000000, 0xf9000000, 0x02000000, 0x7f000000,

+    0x50000000, 0x3c000000, 0x9f000000, 0xa8000000, 0x51000000, 0xa3000000,

+    0x40000000, 0x8f000000, 0x92000000, 0x9d000000, 0x38000000, 0xf5000000,

+    0xbc000000, 0xb6000000, 0xda000000, 0x21000000, 0x10000000, 0xff000000,

+    0xf3000000, 0xd2000000, 0xcd000000, 0x0c000000, 0x13000000, 0xec000000,

+    0x5f000000, 0x97000000, 0x44000000, 0x17000000, 0xc4000000, 0xa7000000,

+    0x7e000000, 0x3d000000, 0x64000000, 0x5d000000, 0x19000000, 0x73000000,

+    0x60000000, 0x81000000, 0x4f000000, 0xdc000000, 0x22000000, 0x2a000000,

+    0x90000000, 0x88000000, 0x46000000, 0xee000000, 0xb8000000, 0x14000000,

+    0xde000000, 0x5e000000, 0x0b000000, 0xdb000000, 0xe0000000, 0x32000000,

+    0x3a000000, 0x0a000000, 0x49000000, 0x06000000, 0x24000000, 0x5c000000,

+    0xc2000000, 0xd3000000, 0xac000000, 0x62000000, 0x91000000, 0x95000000,

+    0xe4000000, 0x79000000, 0xe7000000, 0xc8000000, 0x37000000, 0x6d000000,

+    0x8d000000, 0xd5000000, 0x4e000000, 0xa9000000, 0x6c000000, 0x56000000,

+    0xf4000000, 0xea000000, 0x65000000, 0x7a000000, 0xae000000, 0x08000000,

+    0xba000000, 0x78000000, 0x25000000, 0x2e000000, 0x1c000000, 0xa6000000,

+    0xb4000000, 0xc6000000, 0xe8000000, 0xdd000000, 0x74000000, 0x1f000000,

+    0x4b000000, 0xbd000000, 0x8b000000, 0x8a000000, 0x70000000, 0x3e000000,

+    0xb5000000, 0x66000000, 0x48000000, 0x03000000, 0xf6000000, 0x0e000000,

+    0x61000000, 0x35000000, 0x57000000, 0xb9000000, 0x86000000, 0xc1000000,

+    0x1d000000, 0x9e000000, 0xe1000000, 0xf8000000, 0x98000000, 0x11000000,

+    0x69000000, 0xd9000000, 0x8e000000, 0x94000000, 0x9b000000, 0x1e000000,

+    0x87000000, 0xe9000000, 0xce000000, 0x55000000, 0x28000000, 0xdf000000,

+    0x8c000000, 0xa1000000, 0x89000000, 0x0d000000, 0xbf000000, 0xe6000000,

+    0x42000000, 0x68000000, 0x41000000, 0x99000000, 0x2d000000, 0x0f000000,

+    0xb0000000, 0x54000000, 0xbb000000, 0x16000000

};

-static int32_t p_drms_tab_taos[ 64 ] =

+static uint32_t const p_aes_itable[ 256 ] =

-    -0x28955B88, -0x173848AA, +0x242070DB, -0x3E423112, -0x0A83F051,

-    +0x4787C62A, -0x57CFB9ED, -0x02B96AFF, +0x698098D8, -0x74BB0851,

-    -0x0000A44F, -0x76A32842, +0x6B901122, -0x02678E6D, -0x5986BC72,

-    +0x49B40821, -0x09E1DA9E, -0x3FBF4CC0, +0x265E5A51, -0x16493856,

-    -0x29D0EFA3, +0x02441453, -0x275E197F, -0x182C0438, +0x21E1CDE6,

-    -0x3CC8F82A, -0x0B2AF279, +0x455A14ED, -0x561C16FB, -0x03105C08,

-    +0x676F02D9, -0x72D5B376, -0x0005C6BE, -0x788E097F, +0x6D9D6122,

-    -0x021AC7F4, -0x5B4115BC, +0x4BDECFA9, -0x0944B4A0, -0x41404390,

-    +0x289B7EC6, -0x155ED806, -0x2B10CF7B, +0x04881D05, -0x262B2FC7,

-    -0x1924661B, +0x1FA27CF8, -0x3B53A99B, -0x0BD6DDBC, +0x432AFF97,

-    -0x546BDC59, -0x036C5FC7, +0x655B59C3, -0x70F3336E, -0x00100B83,

-    -0x7A7BA22F, +0x6FA87E4F, -0x01D31920, -0x5CFEBCEC, +0x4E0811A1,

-    -0x08AC817E, -0x42C50DCB, +0x2AD7D2BB, -0x14792C6F

+    0x5150a7f4, 0x7e536541, 0x1ac3a417, 0x3a965e27, 0x3bcb6bab, 0x1ff1459d,

+    0xacab58fa, 0x4b9303e3, 0x2055fa30, 0xadf66d76, 0x889176cc, 0xf5254c02,

+    0x4ffcd7e5, 0xc5d7cb2a, 0x26804435, 0xb58fa362, 0xde495ab1, 0x25671bba,

+    0x45980eea, 0x5de1c0fe, 0xc302752f, 0x8112f04c, 0x8da39746, 0x6bc6f9d3,

+    0x03e75f8f, 0x15959c92, 0xbfeb7a6d, 0x95da5952, 0xd42d83be, 0x58d32174,

+    0x492969e0, 0x8e44c8c9, 0x756a89c2, 0xf478798e, 0x996b3e58, 0x27dd71b9,

+    0xbeb64fe1, 0xf017ad88, 0xc966ac20, 0x7db43ace, 0x63184adf, 0xe582311a,

+    0x97603351, 0x62457f53, 0xb1e07764, 0xbb84ae6b, 0xfe1ca081, 0xf9942b08,

+    0x70586848, 0x8f19fd45, 0x94876cde, 0x52b7f87b, 0xab23d373, 0x72e2024b,

+    0xe3578f1f, 0x662aab55, 0xb20728eb, 0x2f03c2b5, 0x869a7bc5, 0xd3a50837,

+    0x30f28728, 0x23b2a5bf, 0x02ba6a03, 0xed5c8216, 0x8a2b1ccf, 0xa792b479,

+    0xf3f0f207, 0x4ea1e269, 0x65cdf4da, 0x06d5be05, 0xd11f6234, 0xc48afea6,

+    0x349d532e, 0xa2a055f3, 0x0532e18a, 0xa475ebf6, 0x0b39ec83, 0x40aaef60,

+    0x5e069f71, 0xbd51106e, 0x3ef98a21, 0x963d06dd, 0xddae053e, 0x4d46bde6,

+    0x91b58d54, 0x71055dc4, 0x046fd406, 0x60ff1550, 0x1924fb98, 0xd697e9bd,

+    0x89cc4340, 0x67779ed9, 0xb0bd42e8, 0x07888b89, 0xe7385b19, 0x79dbeec8,

+    0xa1470a7c, 0x7ce90f42, 0xf8c91e84, 0x00000000, 0x09838680, 0x3248ed2b,

+    0x1eac7011, 0x6c4e725a, 0xfdfbff0e, 0x0f563885, 0x3d1ed5ae, 0x3627392d,

+    0x0a64d90f, 0x6821a65c, 0x9bd1545b, 0x243a2e36, 0x0cb1670a, 0x930fe757,

+    0xb4d296ee, 0x1b9e919b, 0x804fc5c0, 0x61a220dc, 0x5a694b77, 0x1c161a12,

+    0xe20aba93, 0xc0e52aa0, 0x3c43e022, 0x121d171b, 0x0e0b0d09, 0xf2adc78b,

+    0x2db9a8b6, 0x14c8a91e, 0x578519f1, 0xaf4c0775, 0xeebbdd99, 0xa3fd607f,

+    0xf79f2601, 0x5cbcf572, 0x44c53b66, 0x5b347efb, 0x8b762943, 0xcbdcc623,

+    0xb668fced, 0xb863f1e4, 0xd7cadc31, 0x42108563, 0x13402297, 0x842011c6,

+    0x857d244a, 0xd2f83dbb, 0xae1132f9, 0xc76da129, 0x1d4b2f9e, 0xdcf330b2,

+    0x0dec5286, 0x77d0e3c1, 0x2b6c16b3, 0xa999b970, 0x11fa4894, 0x472264e9,

+    0xa8c48cfc, 0xa01a3ff0, 0x56d82c7d, 0x22ef9033, 0x87c74e49, 0xd9c1d138,

+    0x8cfea2ca, 0x98360bd4, 0xa6cf81f5, 0xa528de7a, 0xda268eb7, 0x3fa4bfad,

+    0x2ce49d3a, 0x500d9278, 0x6a9bcc5f, 0x5462467e, 0xf6c2138d, 0x90e8b8d8,

+    0x2e5ef739, 0x82f5afc3, 0x9fbe805d, 0x697c93d0, 0x6fa92dd5, 0xcfb31225,

+    0xc83b99ac, 0x10a77d18, 0xe86e639c, 0xdb7bbb3b, 0xcd097826, 0x6ef41859,

+    0xec01b79a, 0x83a89a4f, 0xe6656e95, 0xaa7ee6ff, 0x2108cfbc, 0xefe6e815,

+    0xbad99be7, 0x4ace366f, 0xead4099f, 0x29d67cb0, 0x31afb2a4, 0x2a31233f,

+    0xc63094a5, 0x35c066a2, 0x7437bc4e, 0xfca6ca82, 0xe0b0d090, 0x3315d8a7,

+    0xf14a9804, 0x41f7daec, 0x7f0e50cd, 0x172ff691, 0x768dd64d, 0x434db0ef,

+    0xcc544daa, 0xe4df0496, 0x9ee3b5d1, 0x4c1b886a, 0xc1b81f2c, 0x467f5165,

+    0x9d04ea5e, 0x015d358c, 0xfa737487, 0xfb2e410b, 0xb35a1d67, 0x9252d2db,

+    0xe9335610, 0x6d1347d6, 0x9a8c61d7, 0x377a0ca1, 0x598e14f8, 0xeb893c13,

+    0xceee27a9, 0xb735c961, 0xe1ede51c, 0x7a3cb147, 0x9c59dfd2, 0x553f73f2,

+    0x1879ce14, 0x73bf37c7, 0x53eacdf7, 0x5f5baafd, 0xdf146f3d, 0x7886db44,

+    0xca81f3af, 0xb93ec468, 0x382c3424, 0xc25f40a3, 0x1672c31d, 0xbc0c25e2,

+    0x288b493c, 0xff41950d, 0x397101a8, 0x08deb30c, 0xd89ce4b4, 0x6490c156,

+    0x7b6184cb, 0xd570b632, 0x48745c6c, 0xd04257b8

};

-static uint8_t p_drms_tab_tend[ 64 ] =

+static uint32_t const p_aes_decrypt[ 256 ] =

-    0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00

+    0x52000000, 0x09000000, 0x6a000000, 0xd5000000, 0x30000000, 0x36000000,

+    0xa5000000, 0x38000000, 0xbf000000, 0x40000000, 0xa3000000, 0x9e000000,

+    0x81000000, 0xf3000000, 0xd7000000, 0xfb000000, 0x7c000000, 0xe3000000,

+    0x39000000, 0x82000000, 0x9b000000, 0x2f000000, 0xff000000, 0x87000000,

+    0x34000000, 0x8e000000, 0x43000000, 0x44000000, 0xc4000000, 0xde000000,

+    0xe9000000, 0xcb000000, 0x54000000, 0x7b000000, 0x94000000, 0x32000000,

+    0xa6000000, 0xc2000000, 0x23000000, 0x3d000000, 0xee000000, 0x4c000000,

+    0x95000000, 0x0b000000, 0x42000000, 0xfa000000, 0xc3000000, 0x4e000000,

+    0x08000000, 0x2e000000, 0xa1000000, 0x66000000, 0x28000000, 0xd9000000,

+    0x24000000, 0xb2000000, 0x76000000, 0x5b000000, 0xa2000000, 0x49000000,

+    0x6d000000, 0x8b000000, 0xd1000000, 0x25000000, 0x72000000, 0xf8000000,

+    0xf6000000, 0x64000000, 0x86000000, 0x68000000, 0x98000000, 0x16000000,

+    0xd4000000, 0xa4000000, 0x5c000000, 0xcc000000, 0x5d000000, 0x65000000,

+    0xb6000000, 0x92000000, 0x6c000000, 0x70000000, 0x48000000, 0x50000000,

+    0xfd000000, 0xed000000, 0xb9000000, 0xda000000, 0x5e000000, 0x15000000,

+    0x46000000, 0x57000000, 0xa7000000, 0x8d000000, 0x9d000000, 0x84000000,

+    0x90000000, 0xd8000000, 0xab000000, 0x00000000, 0x8c000000, 0xbc000000,

+    0xd3000000, 0x0a000000, 0xf7000000, 0xe4000000, 0x58000000, 0x05000000,

+    0xb8000000, 0xb3000000, 0x45000000, 0x06000000, 0xd0000000, 0x2c000000,

+    0x1e000000, 0x8f000000, 0xca000000, 0x3f000000, 0x0f000000, 0x02000000,

+    0xc1000000, 0xaf000000, 0xbd000000, 0x03000000, 0x01000000, 0x13000000,

+    0x8a000000, 0x6b000000, 0x3a000000, 0x91000000, 0x11000000, 0x41000000,

+    0x4f000000, 0x67000000, 0xdc000000, 0xea000000, 0x97000000, 0xf2000000,

+    0xcf000000, 0xce000000, 0xf0000000, 0xb4000000, 0xe6000000, 0x73000000,

+    0x96000000, 0xac000000, 0x74000000, 0x22000000, 0xe7000000, 0xad000000,

+    0x35000000, 0x85000000, 0xe2000000, 0xf9000000, 0x37000000, 0xe8000000,

+    0x1c000000, 0x75000000, 0xdf000000, 0x6e000000, 0x47000000, 0xf1000000,

+    0x1a000000, 0x71000000, 0x1d000000, 0x29000000, 0xc5000000, 0x89000000,

+    0x6f000000, 0xb7000000, 0x62000000, 0x0e000000, 0xaa000000, 0x18000000,

+    0xbe000000, 0x1b000000, 0xfc000000, 0x56000000, 0x3e000000, 0x4b000000,

+    0xc6000000, 0xd2000000, 0x79000000, 0x20000000, 0x9a000000, 0xdb000000,

+    0xc0000000, 0xfe000000, 0x78000000, 0xcd000000, 0x5a000000, 0xf4000000,

+    0x1f000000, 0xdd000000, 0xa8000000, 0x33000000, 0x88000000, 0x07000000,

+    0xc7000000, 0x31000000, 0xb1000000, 0x12000000, 0x10000000, 0x59000000,

+    0x27000000, 0x80000000, 0xec000000, 0x5f000000, 0x60000000, 0x51000000,

+    0x7f000000, 0xa9000000, 0x19000000, 0xb5000000, 0x4a000000, 0x0d000000,

+    0x2d000000, 0xe5000000, 0x7a000000, 0x9f000000, 0x93000000, 0xc9000000,

+    0x9c000000, 0xef000000, 0xa0000000, 0xe0000000, 0x3b000000, 0x4d000000,

+    0xae000000, 0x2a000000, 0xf5000000, 0xb0000000, 0xc8000000, 0xeb000000,

+    0xbb000000, 0x3c000000, 0x83000000, 0x53000000, 0x99000000, 0x61000000,

+    0x17000000, 0x2b000000, 0x04000000, 0x7e000000, 0xba000000, 0x77000000,

+    0xd6000000, 0x26000000, 0xe1000000, 0x69000000, 0x14000000, 0x63000000,

+    0x55000000, 0x21000000, 0x0c000000, 0x7d000000

};

-static uint16_t p_drms_tab_xor[ 16 ][ 16 ] =

+static uint16_t const p_shuffle_xor[ 256 ] =

-    {

-        0x00D1, 0x0315, 0x1A32, 0x19EC, 0x1BBB, 0x1D6F, 0x14FE, 0x0E9E,

-        0x029E, 0x1B8F, 0x0B70, 0x033A, 0x188E, 0x1D18, 0x0BD8, 0x0EDB

-    },

-    {

-        0x0C64, 0x1C2B, 0x149C, 0x047B, 0x1064, 0x1C7C, 0x118D, 0x1355,

-        0x0AE5, 0x0F18, 0x016F, 0x17D6, 0x1595, 0x0084, 0x0616, 0x1CCD

-    },

-    {

-        0x1D94, 0x0618, 0x182C, 0x195B, 0x196D, 0x0394, 0x07DB, 0x0287,

-        0x1636, 0x0B81, 0x1519, 0x0DF9, 0x1BA3, 0x1CC3, 0x0EE2, 0x1434

-    },

-    {

-        0x1457, 0x0CED, 0x0F7D, 0x0D7B, 0x0B9E, 0x0D13, 0x13D7, 0x18D0,

-        0x1259, 0x1977, 0x0606, 0x1E80, 0x05F2, 0x06B8, 0x1F07, 0x1365

-    },

-    {

-        0x0334, 0x0E30, 0x195F, 0x15F1, 0x058E, 0x0AA8, 0x045A, 0x0465,

-        0x0B3E, 0x071E, 0x0A36, 0x105C, 0x01AC, 0x1A1E, 0x04E4, 0x056B

-    },

-    {

-        0x12BF, 0x0DA2, 0x0B41, 0x0EAF, 0x034F, 0x0181, 0x04E2, 0x002B,

-        0x12E6, 0x01BE, 0x10E8, 0x128F, 0x0EB2, 0x1369, 0x05BE, 0x1A59

-    },

-    {

-        0x117E, 0x047C, 0x1E86, 0x056A, 0x0DA7, 0x0D61, 0x03FC, 0x1E6E,

-        0x1D0C, 0x1E6D, 0x14BF, 0x0C50, 0x063A, 0x1B47, 0x17AE, 0x1321

-    },

-    {

-        0x041B, 0x0A24, 0x0D4D, 0x1F2B, 0x1CB6, 0x1BED, 0x1549, 0x03A7,

-        0x0254, 0x006C, 0x0C9E, 0x0F73, 0x006C, 0x0008, 0x11F9, 0x0DD5

-    },

-    {

-        0x0BCF, 0x0AF9, 0x1DFE, 0x0341, 0x0E49, 0x0D38, 0x17CB, 0x1513,

-        0x0E96, 0x00ED, 0x0556, 0x1B28, 0x100C, 0x19D8, 0x14FA, 0x028C

-    },

-    {

-        0x1C60, 0x1232, 0x13D3, 0x0D00, 0x1534, 0x192C, 0x14B5, 0x1CF2,

-        0x0504, 0x0B5B, 0x1ECF, 0x0423, 0x183B, 0x06B0, 0x169E, 0x1066

-    },

-    {

-        0x04CB, 0x08A2, 0x1B4A, 0x1254, 0x198D, 0x1044, 0x0236, 0x1BD8,

-        0x18A1, 0x03FF, 0x1A0D, 0x0277, 0x0C2D, 0x17C9, 0x007C, 0x116E

-    },

-    {

-        0x048A, 0x1EAF, 0x0922, 0x0C45, 0x0766, 0x1E5F, 0x1A28, 0x0120,

-        0x1C15, 0x034C, 0x0508, 0x0E73, 0x0879, 0x0441, 0x09AE, 0x132F

-    },

-    {

-        0x14FE, 0x0413, 0x0A9D, 0x1727, 0x01D7, 0x1A2B, 0x0474, 0x18F0,

-        0x1F3B, 0x14F5, 0x1071, 0x0895, 0x1071, 0x18FF, 0x18E3, 0x0EB9

-    },

-    {

-        0x0BA9, 0x0961, 0x1599, 0x019E, 0x1D12, 0x1BAA, 0x1E94, 0x1921,

-        0x14DC, 0x124E, 0x0A25, 0x03AB, 0x1CC0, 0x1EBB, 0x0B4B, 0x16E5

-    },

-    {

-        0x11EA, 0x0D78, 0x1BB3, 0x1BA7, 0x1510, 0x1B7B, 0x0C64, 0x1995,

-        0x1A58, 0x1651, 0x1964, 0x147A, 0x15F2, 0x11BB, 0x1654, 0x166E

-    },

-    {

-        0x0EA9, 0x1DE1, 0x1443, 0x13C5, 0x00E1, 0x0B2F, 0x0B6F, 0x0A37,

-        0x18AC, 0x08E6, 0x06F0, 0x136E, 0x0853, 0x0B2E, 0x0813, 0x10D6

-    }

+    0x00d1, 0x0315, 0x1a32, 0x19ec, 0x1bbb, 0x1d6f, 0x14fe, 0x0e9e,

+    0x029e, 0x1b8f, 0x0b70, 0x033a, 0x188e, 0x1d18, 0x0bd8, 0x0edb,

+    0x0c64, 0x1c2b, 0x149c, 0x047b, 0x1064, 0x1c7c, 0x118d, 0x1355,

+    0x0ae5, 0x0f18, 0x016f, 0x17d6, 0x1595, 0x0084, 0x0616, 0x1ccd,

+    0x1d94, 0x0618, 0x182c, 0x195b, 0x196d, 0x0394, 0x07db, 0x0287,

+    0x1636, 0x0b81, 0x1519, 0x0df9, 0x1ba3, 0x1cc3, 0x0ee2, 0x1434,

+    0x1457, 0x0ced, 0x0f7d, 0x0d7b, 0x0b9e, 0x0d13, 0x13d7, 0x18d0,

+    0x1259, 0x1977, 0x0606, 0x1e80, 0x05f2, 0x06b8, 0x1f07, 0x1365,

+    0x0334, 0x0e30, 0x195f, 0x15f1, 0x058e, 0x0aa8, 0x045a, 0x0465,

+    0x0b3e, 0x071e, 0x0a36, 0x105c, 0x01ac, 0x1a1e, 0x04e4, 0x056b,

+    0x12bf, 0x0da2, 0x0b41, 0x0eaf, 0x034f, 0x0181, 0x04e2, 0x002b,

+    0x12e6, 0x01be, 0x10e8, 0x128f, 0x0eb2, 0x1369, 0x05be, 0x1a59,

+    0x117e, 0x047c, 0x1e86, 0x056a, 0x0da7, 0x0d61, 0x03fc, 0x1e6e,

+    0x1d0c, 0x1e6d, 0x14bf, 0x0c50, 0x063a, 0x1b47, 0x17ae, 0x1321,

+    0x041b, 0x0a24, 0x0d4d, 0x1f2b, 0x1cb6, 0x1bed, 0x1549, 0x03a7,

+    0x0254, 0x006c, 0x0c9e, 0x0f73, 0x006c, 0x0008, 0x11f9, 0x0dd5,

+    0x0bcf, 0x0af9, 0x1dfe, 0x0341, 0x0e49, 0x0d38, 0x17cb, 0x1513,

+    0x0e96, 0x00ed, 0x0556, 0x1b28, 0x100c, 0x19d8, 0x14fa, 0x028c,

+    0x1c60, 0x1232, 0x13d3, 0x0d00, 0x1534, 0x192c, 0x14b5, 0x1cf2,

+    0x0504, 0x0b5b, 0x1ecf, 0x0423, 0x183b, 0x06b0, 0x169e, 0x1066,

+    0x04cb, 0x08a2, 0x1b4a, 0x1254, 0x198d, 0x1044, 0x0236, 0x1bd8,

+    0x18a1, 0x03ff, 0x1a0d, 0x0277, 0x0c2d, 0x17c9, 0x007c, 0x116e,

+    0x048a, 0x1eaf, 0x0922, 0x0c45, 0x0766, 0x1e5f, 0x1a28, 0x0120,

+    0x1c15, 0x034c, 0x0508, 0x0e73, 0x0879, 0x0441, 0x09ae, 0x132f,

+    0x14fe, 0x0413, 0x0a9d, 0x1727, 0x01d7, 0x1a2b, 0x0474, 0x18f0,

+    0x1f3b, 0x14f5, 0x1071, 0x0895, 0x1071, 0x18ff, 0x18e3, 0x0eb9,

+    0x0ba9, 0x0961, 0x1599, 0x019e, 0x1d12, 0x1baa, 0x1e94, 0x1921,

+    0x14dc, 0x124e, 0x0a25, 0x03ab, 0x1cc0, 0x1ebb, 0x0b4b, 0x16e5,

+    0x11ea, 0x0d78, 0x1bb3, 0x1ba7, 0x1510, 0x1b7b, 0x0c64, 0x1995,

+    0x1a58, 0x1651, 0x1964, 0x147a, 0x15f2, 0x11bb, 0x1654, 0x166e,

+    0x0ea9, 0x1de1, 0x1443, 0x13c5, 0x00e1, 0x0b2f, 0x0b6f, 0x0a37,

+    0x18ac, 0x08e6, 0x06f0, 0x136e, 0x0853, 0x0b2e, 0x0813, 0x10d6

};

-static uint16_t p_drms_tab_sub[ 16 ][ 16 ] =

+static uint16_t const p_shuffle_sub[ 256 ] =

-    {

-        0x067A, 0x0C7D, 0x0B4F, 0x127D, 0x0BD6, 0x04AC, 0x16E0, 0x1730,

-        0x0587, 0x0AFB, 0x1AC3, 0x0120, 0x14B5, 0x0F67, 0x11DE, 0x0961

-    },

-    {

-        0x1127, 0x1A68, 0x07F0, 0x17D0, 0x1A6F, 0x1F3B, 0x01EF, 0x0919,

-        0x131E, 0x0F90, 0x19E9, 0x18A8, 0x0CB2, 0x1AD0, 0x0C66, 0x0378

-    },

-    {

-        0x03B0, 0x01BE, 0x1866, 0x1159, 0x197C, 0x1105, 0x010B, 0x0353,

-        0x1ABB, 0x09A6, 0x028A, 0x1BAD, 0x1B20, 0x0455, 0x0F57, 0x0588

-    },

-    {

-        0x1491, 0x0A1D, 0x0F04, 0x0650, 0x191E, 0x1E0E, 0x174B, 0x016B,

-        0x051F, 0x0532, 0x00DF, 0x1AEA, 0x0005, 0x0E1B, 0x0FF6, 0x08D8

-    },

-    {

-        0x14B4, 0x086A, 0x0C20, 0x0149, 0x1971, 0x0F26, 0x1852, 0x017D,

-        0x1228, 0x0352, 0x0A44, 0x1330, 0x18DF, 0x1E38, 0x01BC, 0x0BAC

-    },

-    {

-        0x1A48, 0x021F, 0x02F7, 0x0C31, 0x0BC4, 0x1E75, 0x105C, 0x13E3,

-        0x0B20, 0x03A1, 0x1AF3, 0x1A36, 0x0E34, 0x181F, 0x09BD, 0x122B

-    },

-    {

-        0x0EE0, 0x163B, 0x0BE7, 0x103D, 0x1075, 0x1E9D, 0x02AF, 0x0BA2,

-        0x1DAA, 0x0CF1, 0x04B6, 0x0598, 0x06A1, 0x0D33, 0x1CFE, 0x04EE

-    },

-    {

-        0x1BAD, 0x07C8, 0x1A48, 0x05E6, 0x031F, 0x0E0A, 0x0326, 0x1650,

-        0x0526, 0x0B4E, 0x08FC, 0x0E4D, 0x0832, 0x06EA, 0x09BF, 0x0993

-    },

-    {

-        0x09EB, 0x0F31, 0x071B, 0x14D5, 0x11CA, 0x0722, 0x120D, 0x014C,

-        0x1993, 0x0AE4, 0x1CCB, 0x04E9, 0x0AEE, 0x1708, 0x0C3D, 0x12F2

-    },

-    {

-        0x1A19, 0x07C1, 0x05A7, 0x0744, 0x1606, 0x1A9B, 0x042D, 0x1BFC,

-        0x1841, 0x0C3C, 0x0FFE, 0x1AB1, 0x1416, 0x18A9, 0x0320, 0x1EC2

-    },

-    {

-        0x0AE7, 0x11C6, 0x124A, 0x11DF, 0x0F81, 0x06CF, 0x0ED9, 0x0253,

-        0x1D2B, 0x0349, 0x0805, 0x08B3, 0x1052, 0x12CF, 0x0A44, 0x0EA6

-    },

-    {

-        0x03BF, 0x1D90, 0x0EF8, 0x0657, 0x156D, 0x0405, 0x10BE, 0x091F,

-        0x1C82, 0x1725, 0x19EF, 0x0B8C, 0x04D9, 0x02C7, 0x025A, 0x1B89

-    },

-    {

-        0x0F5C, 0x013D, 0x02F7, 0x12E3, 0x0BC5, 0x1B56, 0x0848, 0x0239,

-        0x0FCF, 0x03A4, 0x092D, 0x1354, 0x1D83, 0x01BD, 0x071A, 0x0AF1

-    },

-    {

-        0x0875, 0x0793, 0x1B41, 0x1782, 0x0DEF, 0x1D20, 0x13BE, 0x0095,

-        0x1650, 0x19D4, 0x0DE3, 0x0980, 0x18F2, 0x0CA3, 0x0098, 0x149A

-    },

-    {

-        0x0B81, 0x0AD2, 0x1BBA, 0x1A02, 0x027B, 0x1906, 0x07F5, 0x1CAE,

-        0x0C3F, 0x02F6, 0x1298, 0x175E, 0x15B2, 0x13D8, 0x14CC, 0x161A

-    },

-    {

-        0x0A42, 0x15F3, 0x0870, 0x1C1D, 0x1203, 0x18B1, 0x1738, 0x1954,

-        0x1143, 0x1AE8, 0x1D9D, 0x155B, 0x11E8, 0x0ED9, 0x06F7, 0x04CA

-    }

+    0x067a, 0x0c7d, 0x0b4f, 0x127d, 0x0bd6, 0x04ac, 0x16e0, 0x1730,

+    0x0587, 0x0afb, 0x1ac3, 0x0120, 0x14b5, 0x0f67, 0x11de, 0x0961,

+    0x1127, 0x1a68, 0x07f0, 0x17d0, 0x1a6f, 0x1f3b, 0x01ef, 0x0919,

+    0x131e, 0x0f90, 0x19e9, 0x18a8, 0x0cb2, 0x1ad0, 0x0c66, 0x0378,

+    0x03b0, 0x01be, 0x1866, 0x1159, 0x197c, 0x1105, 0x010b, 0x0353,

+    0x1abb, 0x09a6, 0x028a, 0x1bad, 0x1b20, 0x0455, 0x0f57, 0x0588,

+    0x1491, 0x0a1d, 0x0f04, 0x0650, 0x191e, 0x1e0e, 0x174b, 0x016b,

+    0x051f, 0x0532, 0x00df, 0x1aea, 0x0005, 0x0e1b, 0x0ff6, 0x08d8,

+    0x14b4, 0x086a, 0x0c20, 0x0149, 0x1971, 0x0f26, 0x1852, 0x017d,

+    0x1228, 0x0352, 0x0a44, 0x1330, 0x18df, 0x1e38, 0x01bc, 0x0bac,

+    0x1a48, 0x021f, 0x02f7, 0x0c31, 0x0bc4, 0x1e75, 0x105c, 0x13e3,

+    0x0b20, 0x03a1, 0x1af3, 0x1a36, 0x0e34, 0x181f, 0x09bd, 0x122b,

+    0x0ee0, 0x163b, 0x0be7, 0x103d, 0x1075, 0x1e9d, 0x02af, 0x0ba2,

+    0x1daa, 0x0cf1, 0x04b6, 0x0598, 0x06a1, 0x0d33, 0x1cfe, 0x04ee,

+    0x1bad, 0x07c8, 0x1a48, 0x05e6, 0x031f, 0x0e0a, 0x0326, 0x1650,

+    0x0526, 0x0b4e, 0x08fc, 0x0e4d, 0x0832, 0x06ea, 0x09bf, 0x0993,

+    0x09eb, 0x0f31, 0x071b, 0x14d5, 0x11ca, 0x0722, 0x120d, 0x014c,

+    0x1993, 0x0ae4, 0x1ccb, 0x04e9, 0x0aee, 0x1708, 0x0c3d, 0x12f2,

+    0x1a19, 0x07c1, 0x05a7, 0x0744, 0x1606, 0x1a9b, 0x042d, 0x1bfc,

+    0x1841, 0x0c3c, 0x0ffe, 0x1ab1, 0x1416, 0x18a9, 0x0320, 0x1ec2,

+    0x0ae7, 0x11c6, 0x124a, 0x11df, 0x0f81, 0x06cf, 0x0ed9, 0x0253,

+    0x1d2b, 0x0349, 0x0805, 0x08b3, 0x1052, 0x12cf, 0x0a44, 0x0ea6,

+    0x03bf, 0x1d90, 0x0ef8, 0x0657, 0x156d, 0x0405, 0x10be, 0x091f,

+    0x1c82, 0x1725, 0x19ef, 0x0b8c, 0x04d9, 0x02c7, 0x025a, 0x1b89,

+    0x0f5c, 0x013d, 0x02f7, 0x12e3, 0x0bc5, 0x1b56, 0x0848, 0x0239,

+    0x0fcf, 0x03a4, 0x092d, 0x1354, 0x1d83, 0x01bd, 0x071a, 0x0af1,

+    0x0875, 0x0793, 0x1b41, 0x1782, 0x0def, 0x1d20, 0x13be, 0x0095,

+    0x1650, 0x19d4, 0x0de3, 0x0980, 0x18f2, 0x0ca3, 0x0098, 0x149a,

+    0x0b81, 0x0ad2, 0x1bba, 0x1a02, 0x027b, 0x1906, 0x07f5, 0x1cae,

+    0x0c3f, 0x02f6, 0x1298, 0x175e, 0x15b2, 0x13d8, 0x14cc, 0x161a,

+    0x0a42, 0x15f3, 0x0870, 0x1c1d, 0x1203, 0x18b1, 0x1738, 0x1954,

+    0x1143, 0x1ae8, 0x1d9d, 0x155b, 0x11e8, 0x0ed9, 0x06f7, 0x04ca

};

-static uint16_t p_drms_tab_add[ 16 ][ 16 ] =

+static uint16_t const p_shuffle_add[ 256 ] =

-    {

-        0x0706, 0x175A, 0x0DEF, 0x1E72, 0x0297, 0x1B0E, 0x1D5A, 0x15B8,

-        0x13E2, 0x1347, 0x10C6, 0x0B4F, 0x0629, 0x0A75, 0x0A9B, 0x0F55

-    },

-    {

-        0x1A69, 0x09BF, 0x0BA6, 0x1582, 0x1086, 0x1921, 0x01CB, 0x1C6A,

-        0x0FF5, 0x00F7, 0x0A67, 0x0A1E, 0x1838, 0x0196, 0x10D6, 0x0C7A

-    },

-    {

-        0x180E, 0x038D, 0x1ADD, 0x0684, 0x154A, 0x0AB0, 0x18A4, 0x0D73,

-        0x1641, 0x0EC6, 0x09F1, 0x1A62, 0x0414, 0x162A, 0x194E, 0x1EC9

-    },

-    {

-        0x022F, 0x0296, 0x1104, 0x14FC, 0x096C, 0x1D02, 0x09BD, 0x027C,

-        0x080E, 0x1324, 0x128C, 0x0DC1, 0x00B9, 0x17F2, 0x0CBC, 0x0F97

-    },

-    {

-        0x1B93, 0x1C3C, 0x0415, 0x0395, 0x0C7A, 0x06CC, 0x0D4B, 0x16E2,

-        0x04A2, 0x0DAB, 0x1228, 0x012B, 0x0896, 0x0012, 0x1CD6, 0x1DAC

-    },

-    {

-        0x080D, 0x0446, 0x047A, 0x00AD, 0x029E, 0x0686, 0x17C3, 0x1466,

-        0x0D16, 0x1896, 0x076E, 0x00CD, 0x17DC, 0x1E9F, 0x1A7C, 0x02BB

-    },

-    {

-        0x0D06, 0x112B, 0x14CB, 0x0A03, 0x1541, 0x1290, 0x0F6D, 0x1503,

-        0x084B, 0x0382, 0x1A3F, 0x0371, 0x1977, 0x0B67, 0x0CAD, 0x1DF8

-    },

-    {

-        0x1CE3, 0x1306, 0x13F8, 0x1163, 0x1B0B, 0x00BD, 0x0BF0, 0x1A4F,

-        0x16F7, 0x0B4F, 0x0CF8, 0x1254, 0x0541, 0x100D, 0x0296, 0x0410

-    },

-    {

-        0x1A2B, 0x1169, 0x17D9, 0x0819, 0x03D6, 0x0D03, 0x194D, 0x184A,

-        0x07CA, 0x1989, 0x0FAD, 0x011C, 0x1C71, 0x0EF6, 0x0DC8, 0x0F2F

-    },

-    {

-        0x0FA5, 0x11BE, 0x0F3B, 0x1D52, 0x0DE2, 0x016E, 0x1AD1, 0x0C4A,

-        0x1BC2, 0x0AC9, 0x1485, 0x1BEE, 0x0949, 0x1A79, 0x1894, 0x12BB

-    },

-    {

-        0x17B6, 0x14F5, 0x16B1, 0x142C, 0x1301, 0x03EF, 0x16FF, 0x0D37,

-        0x0D78, 0x01FF, 0x00D6, 0x1053, 0x1A2A, 0x0F61, 0x1352, 0x0C7F

-    },

-    {

-        0x137F, 0x09C4, 0x1D96, 0x021D, 0x1037, 0x1B19, 0x10EF, 0x14E4,

-        0x02A0, 0x0236, 0x0A5D, 0x1519, 0x141C, 0x1399, 0x007E, 0x1E74

-    },

-    {

-        0x0941, 0x1B3C, 0x0062, 0x0371, 0x09AD, 0x08E8, 0x0A24, 0x0B97,

-        0x1ED2, 0x0889, 0x136B, 0x0006, 0x1C4C, 0x0444, 0x06F8, 0x0DFB

-    },

-    {

-        0x1D0F, 0x198D, 0x0700, 0x0AFC, 0x1781, 0x12F3, 0x10DA, 0x1F19,

-        0x1055, 0x0DC9, 0x1860, 0x012B, 0x05BF, 0x082D, 0x0C17, 0x1941

-    },

-    {

-        0x0359, 0x1232, 0x104C, 0x0762, 0x0897, 0x1D6C, 0x030F, 0x1A36,

-        0x16B0, 0x094D, 0x1782, 0x036F, 0x0EEA, 0x06E6, 0x0D00, 0x0187

-    },

-    {

-        0x17E2, 0x05E5, 0x19FA, 0x1950, 0x146A, 0x0B2A, 0x0512, 0x0EE0,

-        0x1E27, 0x112D, 0x1DF0, 0x0B13, 0x0378, 0x1DD0, 0x00C1, 0x01E6

-    }

+    0x0706, 0x175a, 0x0def, 0x1e72, 0x0297, 0x1b0e, 0x1d5a, 0x15b8,

+    0x13e2, 0x1347, 0x10c6, 0x0b4f, 0x0629, 0x0a75, 0x0a9b, 0x0f55,

+    0x1a69, 0x09bf, 0x0ba6, 0x1582, 0x1086, 0x1921, 0x01cb, 0x1c6a,

+    0x0ff5, 0x00f7, 0x0a67, 0x0a1e, 0x1838, 0x0196, 0x10d6, 0x0c7a,

+    0x180e, 0x038d, 0x1add, 0x0684, 0x154a, 0x0ab0, 0x18a4, 0x0d73,

+    0x1641, 0x0ec6, 0x09f1, 0x1a62, 0x0414, 0x162a, 0x194e, 0x1ec9,

+    0x022f, 0x0296, 0x1104, 0x14fc, 0x096c, 0x1d02, 0x09bd, 0x027c,

+    0x080e, 0x1324, 0x128c, 0x0dc1, 0x00b9, 0x17f2, 0x0cbc, 0x0f97,

+    0x1b93, 0x1c3c, 0x0415, 0x0395, 0x0c7a, 0x06cc, 0x0d4b, 0x16e2,

+    0x04a2, 0x0dab, 0x1228, 0x012b, 0x0896, 0x0012, 0x1cd6, 0x1dac,

+    0x080d, 0x0446, 0x047a, 0x00ad, 0x029e, 0x0686, 0x17c3, 0x1466,

+    0x0d16, 0x1896, 0x076e, 0x00cd, 0x17dc, 0x1e9f, 0x1a7c, 0x02bb,

+    0x0d06, 0x112b, 0x14cb, 0x0a03, 0x1541, 0x1290, 0x0f6d, 0x1503,

+    0x084b, 0x0382, 0x1a3f, 0x0371, 0x1977, 0x0b67, 0x0cad, 0x1df8,

+    0x1ce3, 0x1306, 0x13f8, 0x1163, 0x1b0b, 0x00bd, 0x0bf0, 0x1a4f,

+    0x16f7, 0x0b4f, 0x0cf8, 0x1254, 0x0541, 0x100d, 0x0296, 0x0410,

+    0x1a2b, 0x1169, 0x17d9, 0x0819, 0x03d6, 0x0d03, 0x194d, 0x184a,

+    0x07ca, 0x1989, 0x0fad, 0x011c, 0x1c71, 0x0ef6, 0x0dc8, 0x0f2f,

+    0x0fa5, 0x11be, 0x0f3b, 0x1d52, 0x0de2, 0x016e, 0x1ad1, 0x0c4a,

+    0x1bc2, 0x0ac9, 0x1485, 0x1bee, 0x0949, 0x1a79, 0x1894, 0x12bb,

+    0x17b6, 0x14f5, 0x16b1, 0x142c, 0x1301, 0x03ef, 0x16ff, 0x0d37,

+    0x0d78, 0x01ff, 0x00d6, 0x1053, 0x1a2a, 0x0f61, 0x1352, 0x0c7f,

+    0x137f, 0x09c4, 0x1d96, 0x021d, 0x1037, 0x1b19, 0x10ef, 0x14e4,

+    0x02a0, 0x0236, 0x0a5d, 0x1519, 0x141c, 0x1399, 0x007e, 0x1e74,

+    0x0941, 0x1b3c, 0x0062, 0x0371, 0x09ad, 0x08e8, 0x0a24, 0x0b97,

+    0x1ed2, 0x0889, 0x136b, 0x0006, 0x1c4c, 0x0444, 0x06f8, 0x0dfb,

+    0x1d0f, 0x198d, 0x0700, 0x0afc, 0x1781, 0x12f3, 0x10da, 0x1f19,

+    0x1055, 0x0dc9, 0x1860, 0x012b, 0x05bf, 0x082d, 0x0c17, 0x1941,

+    0x0359, 0x1232, 0x104c, 0x0762, 0x0897, 0x1d6c, 0x030f, 0x1a36,

+    0x16b0, 0x094d, 0x1782, 0x036f, 0x0eea, 0x06e6, 0x0d00, 0x0187,

+    0x17e2, 0x05e5, 0x19fa, 0x1950, 0x146a, 0x0b2a, 0x0512, 0x0ee0,

+    0x1e27, 0x112d, 0x1df0, 0x0b13, 0x0378, 0x1dd0, 0x00c1, 0x01e6

};

--- a/common/mp4ff/mp4atom.c

+++ b/common/mp4ff/mp4atom.c

@@ -22,10 +22,23 @@

 ** Commercial non-GPL licensing of this software is possible.

 ** For more info contact Ahead Software through Mpeg4AAClicense@nero.com.

**

-** $Id: mp4atom.c,v 1.18 2004/03/27 11:14:48 menno Exp $

+** $Id: mp4atom.c,v 1.19 2004/03/31 17:39:57 menno Exp $

**/

 #include <stdlib.h>

+#ifndef _WIN32

+#include "config.h"

+#else

+#include <tchar.h>

+#include <shlobj.h>

+#include <windows.h>

+#endif

+#ifdef HAVE_GETPWUID

+#    include <pwd.h>

+#endif

+#ifdef HAVE_STRING_H

+#    include <string.h>

+#endif

 #include "mp4ffint.h"

 #include "drms.h"

@@ -160,20 +173,24 @@

     else if (mp4ff_atom_compare(a,b,c,d, 'g','n','r','e'))

         return ATOM_GENRE2;

     else if (mp4ff_atom_compare(a,b,c,d, 'c','o','v','r'))

-		return ATOM_COVER;

+        return ATOM_COVER;

     else if (mp4ff_atom_compare(a,b,c,d, 'c','p','i','l'))

         return ATOM_COMPILATION;

     else if (mp4ff_atom_compare(a,b,c,d, 'c','t','t','s'))

-		return ATOM_CTTS;

+        return ATOM_CTTS;

     else if (mp4ff_atom_compare(a,b,c,d, 'd','r','m','s'))

-		return ATOM_DRMS;

+        return ATOM_DRMS;

     else if (mp4ff_atom_compare(a,b,c,d, 'f','r','m','a'))

-		return ATOM_FRMA;

+        return ATOM_FRMA;

     else if (mp4ff_atom_compare(a,b,c,d, 'p','r','i','v'))

-		return ATOM_PRIV;

+        return ATOM_PRIV;

     else if (mp4ff_atom_compare(a,b,c,d, 'i','v','i','v'))

-		return ATOM_IVIV;

-	else

+        return ATOM_IVIV;

+    else if (mp4ff_atom_compare(a,b,c,d, 'u','s','e','r'))

+        return ATOM_USER;

+    else if (mp4ff_atom_compare(a,b,c,d, 'k','e','y',' '))

+        return ATOM_KEY;

+    else

         return ATOM_UNKNOWN;

@@ -230,8 +247,8 @@

 static int32_t mp4ff_read_esds(mp4ff_t *f)

     uint8_t tag;

-	uint32_t temp;

+    uint32_t temp;

     mp4ff_read_char(f); /* version */

     mp4ff_read_int24(f); /* flags */

@@ -258,14 +275,14 @@

     /* read length */

-	temp = mp4ff_read_mp4_descr_length(f);

+    temp = mp4ff_read_mp4_descr_length(f);

     if (temp < 13) return 1;

-	f->track[f->total_tracks - 1]->audioType = mp4ff_read_char(f);

+    f->track[f->total_tracks - 1]->audioType = mp4ff_read_char(f);

     mp4ff_read_int32(f);//0x15000414 ????

     f->track[f->total_tracks - 1]->maxBitrate = mp4ff_read_int32(f);

     f->track[f->total_tracks - 1]->avgBitrate = mp4ff_read_int32(f);

     /* get and verify DecSpecificInfoTag */

     if (mp4ff_read_char(f) != 0x05)

@@ -273,7 +290,7 @@

     /* read length */

-    f->track[f->total_tracks - 1]->decoderConfigLen = mp4ff_read_mp4_descr_length(f);

+    f->track[f->total_tracks - 1]->decoderConfigLen = mp4ff_read_mp4_descr_length(f);

     if (f->track[f->total_tracks - 1]->decoderConfig)

         free(f->track[f->total_tracks - 1]->decoderConfig);

@@ -325,6 +342,75 @@

 #ifdef ITUNES_DRM

+char *GetHomeDir( void )

+{

+    char *p_tmp, *p_homedir = NULL;

+#if defined(HAVE_GETPWUID)

+    struct passwd *p_pw = NULL;

+#endif

+#if defined(_WIN32) || defined(UNDER_CE)

+    typedef HRESULT (WINAPI *SHGETFOLDERPATH)( HWND, int, HANDLE, DWORD,

+                                               LPSTR );

+#   define CSIDL_FLAG_CREATE 0x8000

+#   define CSIDL_APPDATA 0x1A

+#   define SHGFP_TYPE_CURRENT 0

+    HINSTANCE shfolder_dll;

+    SHGETFOLDERPATH SHGetFolderPath ;

+    /* load the shfolder dll to retrieve SHGetFolderPath */

+    if( ( shfolder_dll = LoadLibrary( _T("SHFolder.dll") ) ) != NULL )

+    {

+        SHGetFolderPath = (void *)GetProcAddress( shfolder_dll,

+                                                  _T("SHGetFolderPathA") );

+        if ( SHGetFolderPath != NULL )

+        {

+            p_homedir = (char *)malloc( MAX_PATH );

+            if( !p_homedir )

+            {

+                return NULL;

+            }

+            /* get the "Application Data" folder for the current user */

+            if( S_OK == SHGetFolderPath( NULL,

+                                         CSIDL_APPDATA | CSIDL_FLAG_CREATE,

+                                         NULL, SHGFP_TYPE_CURRENT,

+                                         p_homedir ) )

+            {

+                FreeLibrary( shfolder_dll );

+                return p_homedir;

+            }

+            free( p_homedir );

+        }

+        FreeLibrary( shfolder_dll );

+    }

+#endif

+#if defined(HAVE_GETPWUID)

+    if( ( p_pw = getpwuid( getuid() ) ) == NULL )

+#endif

+    {

+        if( ( p_tmp = getenv( "HOME" ) ) == NULL )

+        {

+            if( ( p_tmp = getenv( "TMP" ) ) == NULL )

+            {

+                p_tmp = "/tmp";

+            }

+        }

+        p_homedir = strdup( p_tmp );

+    }

+#if defined(HAVE_GETPWUID)

+    else

+    {

+        p_homedir = strdup( p_pw->pw_dir );

+    }

+#endif

+    return p_homedir;

+}

 static int32_t mp4ff_read_drms(mp4ff_t *f, uint64_t skip)

     uint64_t size;

@@ -331,17 +417,9 @@

     int32_t i;

     uint8_t atom_type = 0;

     uint8_t header_size = 0;

-    uint32_t drms_user_key[4];

-    if (drms_get_user_key(NULL, drms_user_key) == 0)

-    {

-        f->track[f->total_tracks - 1]->p_drms = drms_alloc();

+    f->track[f->total_tracks - 1]->p_drms = drms_alloc( GetHomeDir() );

-        drms_init( f->track[f->total_tracks - 1]->p_drms,

-            DRMS_INIT_UKEY, (uint8_t *)drms_user_key,

-            sizeof(drms_user_key) );

-    }

     for (i = 0; i < 6; i++)

         mp4ff_read_char(f); /* reserved */

@@ -408,7 +486,7 @@

     if (f->track[f->total_tracks - 1]->p_drms != NULL)

         drms_init(f->track[f->total_tracks - 1]->p_drms,

-            DRMS_INIT_NAME, data, strlen(data) );

+            FOURCC_name, data, strlen(data) );

     if (data)

@@ -425,7 +503,7 @@

     if (f->track[f->total_tracks - 1]->p_drms != 0)

         drms_init(f->track[f->total_tracks - 1]->p_drms,

-            DRMS_INIT_PRIV, data, size );

+            FOURCC_priv, data, size );

     if (data)

@@ -442,7 +520,7 @@

     if (f->track[f->total_tracks - 1]->p_drms != 0)

         drms_init(f->track[f->total_tracks - 1]->p_drms,

-            DRMS_INIT_IVIV, data, sizeof(uint32_t) * 4 );

+            FOURCC_iviv, data, sizeof(uint32_t) * 4 );

     if (data)

@@ -450,6 +528,40 @@

     return 0;

+static int32_t mp4ff_read_user(mp4ff_t *f, uint64_t size)

+{

+    uint8_t *data = malloc(size);

+    mp4ff_read_data(f, data, size);

+    if (f->track[f->total_tracks - 1]->p_drms != 0)

+    {

+        drms_init(f->track[f->total_tracks - 1]->p_drms,

+            FOURCC_user, data, size );

+    }

+    if (data)

+        free(data);

+    return 0;

+}

+static int32_t mp4ff_read_key(mp4ff_t *f, uint64_t size)

+{

+    uint8_t *data = malloc(size);

+    mp4ff_read_data(f, data, size);

+    if (f->track[f->total_tracks - 1]->p_drms != 0)

+    {

+        drms_init(f->track[f->total_tracks - 1]->p_drms,

+            FOURCC_key, data, size );

+    }

+    if (data)

+        free(data);

+    return 0;

+}

 #endif

 static int32_t mp4ff_read_stsd(mp4ff_t *f)

@@ -498,8 +610,8 @@

     int32_t i;

-    mp4ff_read_char(f); /* version */

-    mp4ff_read_int24(f); /* flags */

+    mp4ff_read_char(f); /* version */

+    mp4ff_read_int24(f); /* flags */

     f->track[f->total_tracks - 1]->stsc_entry_count = mp4ff_read_int32(f);

     f->track[f->total_tracks - 1]->stsc_first_chunk =

@@ -541,9 +653,9 @@

 static int32_t mp4ff_read_ctts(mp4ff_t *f)

     int32_t i;

-	mp4ff_track_t * p_track = f->track[f->total_tracks - 1];

+    mp4ff_track_t * p_track = f->track[f->total_tracks - 1];

-	if (p_track->ctts_entry_count) return 0;

+    if (p_track->ctts_entry_count) return 0;

     mp4ff_read_char(f); /* version */

     mp4ff_read_int24(f); /* flags */

@@ -552,30 +664,30 @@

     p_track->ctts_sample_count = (int32_t*)malloc(p_track->ctts_entry_count * sizeof(int32_t));

     p_track->ctts_sample_offset = (int32_t*)malloc(p_track->ctts_entry_count * sizeof(int32_t));

-	if (p_track->ctts_sample_count == 0 || p_track->ctts_sample_offset == 0)

-	{

-		if (p_track->ctts_sample_count) {free(p_track->ctts_sample_count);p_track->ctts_sample_count=0;}

-		if (p_track->ctts_sample_offset) {free(p_track->ctts_sample_offset);p_track->ctts_sample_offset=0;}

-		p_track->ctts_entry_count = 0;

-		return 0;

-	}

-	else

-	{

-		for (i = 0; i < f->track[f->total_tracks - 1]->ctts_entry_count; i++)

-		{

-			p_track->ctts_sample_count[i] = mp4ff_read_int32(f);

-			p_track->ctts_sample_offset[i] = mp4ff_read_int32(f);

-		}

-		return 1;

-	}

+    if (p_track->ctts_sample_count == 0 || p_track->ctts_sample_offset == 0)

+    {

+        if (p_track->ctts_sample_count) {free(p_track->ctts_sample_count);p_track->ctts_sample_count=0;}

+        if (p_track->ctts_sample_offset) {free(p_track->ctts_sample_offset);p_track->ctts_sample_offset=0;}

+        p_track->ctts_entry_count = 0;

+        return 0;

+    }

+    else

+    {

+        for (i = 0; i < f->track[f->total_tracks - 1]->ctts_entry_count; i++)

+        {

+            p_track->ctts_sample_count[i] = mp4ff_read_int32(f);

+            p_track->ctts_sample_offset[i] = mp4ff_read_int32(f);

+        }

+        return 1;

+    }

 static int32_t mp4ff_read_stts(mp4ff_t *f)

     int32_t i;

-	mp4ff_track_t * p_track = f->track[f->total_tracks - 1];

+    mp4ff_track_t * p_track = f->track[f->total_tracks - 1];

-	if (p_track->stts_entry_count) return 0;

+    if (p_track->stts_entry_count) return 0;

     mp4ff_read_char(f); /* version */

     mp4ff_read_int24(f); /* flags */

@@ -583,23 +695,23 @@

     p_track->stts_sample_count = (int32_t*)malloc(p_track->stts_entry_count * sizeof(int32_t));

     p_track->stts_sample_delta = (int32_t*)malloc(p_track->stts_entry_count * sizeof(int32_t));

-	if (p_track->stts_sample_count == 0 || p_track->stts_sample_delta == 0)

-	{

-		if (p_track->stts_sample_count) {free(p_track->stts_sample_count);p_track->stts_sample_count=0;}

-		if (p_track->stts_sample_delta) {free(p_track->stts_sample_delta);p_track->stts_sample_delta=0;}

-		p_track->stts_entry_count = 0;

-		return 0;

-	}

-	else

-	{

-		for (i = 0; i < f->track[f->total_tracks - 1]->stts_entry_count; i++)

-		{

-			p_track->stts_sample_count[i] = mp4ff_read_int32(f);

-			p_track->stts_sample_delta[i] = mp4ff_read_int32(f);

-		}

-		return 1;

-	}

+    if (p_track->stts_sample_count == 0 || p_track->stts_sample_delta == 0)

+    {

+        if (p_track->stts_sample_count) {free(p_track->stts_sample_count);p_track->stts_sample_count=0;}

+        if (p_track->stts_sample_delta) {free(p_track->stts_sample_delta);p_track->stts_sample_delta=0;}

+        p_track->stts_entry_count = 0;

+        return 0;

+    }

+    else

+    {

+        for (i = 0; i < f->track[f->total_tracks - 1]->stts_entry_count; i++)

+        {

+            p_track->stts_sample_count[i] = mp4ff_read_int32(f);

+            p_track->stts_sample_delta[i] = mp4ff_read_int32(f);

+        }

+        return 1;

+    }

 static int32_t mp4ff_read_mvhd(mp4ff_t *f)

@@ -636,71 +748,71 @@

 #if 0

 static int32_t mp4ff_read_tkhd(mp4ff_t *f)

-	uint8_t version;

-	uint32_t flags;

+    uint8_t version;

+    uint32_t flags;

     version = mp4ff_read_char(f); /* version */

     flags = mp4ff_read_int24(f); /* flags */

-	if (version==1)

-	{

-		mp4ff_read_int64(f);//creation-time

-		mp4ff_read_int64(f);//modification-time

-		mp4ff_read_int32(f);//track-id

-		mp4ff_read_int32(f);//reserved

-		f->track[f->total_tracks - 1]->duration = mp4ff_read_int64(f);//duration

-	}

-	else //version == 0

-	{

-		mp4ff_read_int32(f);//creation-time

-		mp4ff_read_int32(f);//modification-time

-		mp4ff_read_int32(f);//track-id

-		mp4ff_read_int32(f);//reserved

-		f->track[f->total_tracks - 1]->duration = mp4ff_read_int32(f);//duration

-		if (f->track[f->total_tracks - 1]->duration == 0xFFFFFFFF)

-			f->track[f->total_tracks - 1]->duration = 0xFFFFFFFFFFFFFFFF;

+    if (version==1)

+    {

+        mp4ff_read_int64(f);//creation-time

+        mp4ff_read_int64(f);//modification-time

+        mp4ff_read_int32(f);//track-id

+        mp4ff_read_int32(f);//reserved

+        f->track[f->total_tracks - 1]->duration = mp4ff_read_int64(f);//duration

+    }

+    else //version == 0

+    {

+        mp4ff_read_int32(f);//creation-time

+        mp4ff_read_int32(f);//modification-time

+        mp4ff_read_int32(f);//track-id

+        mp4ff_read_int32(f);//reserved

+        f->track[f->total_tracks - 1]->duration = mp4ff_read_int32(f);//duration

+        if (f->track[f->total_tracks - 1]->duration == 0xFFFFFFFF)

+            f->track[f->total_tracks - 1]->duration = 0xFFFFFFFFFFFFFFFF;

-	}

-	mp4ff_read_int32(f);//reserved

-	mp4ff_read_int32(f);//reserved

-	mp4ff_read_int16(f);//layer

-	mp4ff_read_int16(f);//pre-defined

-	mp4ff_read_int16(f);//volume

-	mp4ff_read_int16(f);//reserved

-	//matrix

-	mp4ff_read_int32(f); mp4ff_read_int32(f); mp4ff_read_int32(f);

-	mp4ff_read_int32(f); mp4ff_read_int32(f); mp4ff_read_int32(f);

-	mp4ff_read_int32(f); mp4ff_read_int32(f); mp4ff_read_int32(f);

-	mp4ff_read_int32(f);//width

-	mp4ff_read_int32(f);//height

-	return 1;

+    }

+    mp4ff_read_int32(f);//reserved

+    mp4ff_read_int32(f);//reserved

+    mp4ff_read_int16(f);//layer

+    mp4ff_read_int16(f);//pre-defined

+    mp4ff_read_int16(f);//volume

+    mp4ff_read_int16(f);//reserved

+    //matrix

+    mp4ff_read_int32(f); mp4ff_read_int32(f); mp4ff_read_int32(f);

+    mp4ff_read_int32(f); mp4ff_read_int32(f); mp4ff_read_int32(f);

+    mp4ff_read_int32(f); mp4ff_read_int32(f); mp4ff_read_int32(f);

+    mp4ff_read_int32(f);//width

+    mp4ff_read_int32(f);//height

+    return 1;

 #endif

 static int32_t mp4ff_read_mdhd(mp4ff_t *f)

-	uint32_t version;

+    uint32_t version;

-	version = mp4ff_read_int32(f);

-	if (version==1)

-	{

-		mp4ff_read_int64(f);//creation-time

-		mp4ff_read_int64(f);//modification-time

-		f->track[f->total_tracks - 1]->timeScale = mp4ff_read_int32(f);//timescale

-		f->track[f->total_tracks - 1]->duration = mp4ff_read_int64(f);//duration

-	}

-	else //version == 0

-	{

-		uint32_t temp;

+    version = mp4ff_read_int32(f);

+    if (version==1)

+    {

+        mp4ff_read_int64(f);//creation-time

+        mp4ff_read_int64(f);//modification-time

+        f->track[f->total_tracks - 1]->timeScale = mp4ff_read_int32(f);//timescale

+        f->track[f->total_tracks - 1]->duration = mp4ff_read_int64(f);//duration

+    }

+    else //version == 0

+    {

+        uint32_t temp;

-		mp4ff_read_int32(f);//creation-time

-		mp4ff_read_int32(f);//modification-time

-		f->track[f->total_tracks - 1]->timeScale = mp4ff_read_int32(f);//timescale

-		temp = mp4ff_read_int32(f);

-		f->track[f->total_tracks - 1]->duration = (temp == (uint32_t)(-1)) ? (uint64_t)(-1) : (uint64_t)(temp);

-	}

-	mp4ff_read_int16(f);

-	mp4ff_read_int16(f);

-	return 1;

+        mp4ff_read_int32(f);//creation-time

+        mp4ff_read_int32(f);//modification-time

+        f->track[f->total_tracks - 1]->timeScale = mp4ff_read_int32(f);//timescale

+        temp = mp4ff_read_int32(f);

+        f->track[f->total_tracks - 1]->duration = (temp == (uint32_t)(-1)) ? (uint64_t)(-1) : (uint64_t)(temp);

+    }

+    mp4ff_read_int16(f);

+    mp4ff_read_int16(f);

+    return 1;

 #ifdef USE_TAGGING

 static int32_t mp4ff_read_meta(mp4ff_t *f, const uint64_t size)

@@ -730,7 +842,7 @@

 int32_t mp4ff_atom_read(mp4ff_t *f, const int32_t size, const uint8_t atom_type)

-	uint64_t dest_position = mp4ff_position(f)+size-8;

+    uint64_t dest_position = mp4ff_position(f)+size-8;

     if (atom_type == ATOM_STSZ)

         /* sample size box */

@@ -738,9 +850,9 @@

     } else if (atom_type == ATOM_STTS) {

         /* time to sample box */

         mp4ff_read_stts(f);

-	} else if (atom_type == ATOM_CTTS) {

-		/* composition offset box */

-		mp4ff_read_ctts(f);

+    } else if (atom_type == ATOM_CTTS) {

+        /* composition offset box */

+        mp4ff_read_ctts(f);

     } else if (atom_type == ATOM_STSC) {

         /* sample to chunk box */

         mp4ff_read_stsc(f);

@@ -766,6 +878,10 @@

         mp4ff_read_name(f, size-8);

     } else if (atom_type == ATOM_PRIV) {

         mp4ff_read_priv(f, size-8);

+    } else if (atom_type == ATOM_USER) {

+        mp4ff_read_user(f, size-8);

+    } else if (atom_type == ATOM_KEY) {

+        mp4ff_read_key(f, size-8);

 #endif

 #ifdef USE_TAGGING

     } else if (atom_type == ATOM_META) {

@@ -773,7 +889,7 @@

         mp4ff_read_meta(f, size);

 #endif

     mp4ff_set_position(f, dest_position);

--- a/common/mp4ff/mp4ffint.h

+++ b/common/mp4ff/mp4ffint.h

@@ -22,7 +22,7 @@

 ** Commercial non-GPL licensing of this software is possible.

 ** For more info contact Ahead Software through Mpeg4AAClicense@nero.com.

**

-** $Id: mp4ffint.h,v 1.16 2004/03/27 11:14:49 menno Exp $

+** $Id: mp4ffint.h,v 1.17 2004/03/31 17:39:57 menno Exp $

**/

 #ifndef MP4FF_INTERNAL_H

@@ -39,7 +39,48 @@

 #define ITUNES_DRM

 #endif

+static __inline uint32_t GetDWLE( void const * _p )

+{

+    uint8_t * p = (uint8_t *)_p;

+    return ( ((uint32_t)p[3] << 24) | ((uint32_t)p[2] << 16)

+              | ((uint32_t)p[1] << 8) | p[0] );

+}

+static __inline uint32_t U32_AT( void const * _p )

+{

+    uint8_t * p = (uint8_t *)_p;

+    return ( ((uint32_t)p[0] << 24) | ((uint32_t)p[1] << 16)

+              | ((uint32_t)p[2] << 8) | p[3] );

+}

+static __inline uint64_t U64_AT( void const * _p )

+{

+    uint8_t * p = (uint8_t *)_p;

+    return ( ((uint64_t)p[0] << 56) | ((uint64_t)p[1] << 48)

+              | ((uint64_t)p[2] << 40) | ((uint64_t)p[3] << 32)

+              | ((uint64_t)p[4] << 24) | ((uint64_t)p[5] << 16)

+              | ((uint64_t)p[6] << 8) | p[7] );

+}

+#ifdef WORDS_BIGENDIAN

+#   define VLC_FOURCC( a, b, c, d ) \

+        ( ((uint32_t)d) | ( ((uint32_t)c) << 8 ) \

+           | ( ((uint32_t)b) << 16 ) | ( ((uint32_t)a) << 24 ) )

+#   define VLC_TWOCC( a, b ) \

+        ( (uint16_t)(b) | ( (uint16_t)(a) << 8 ) )

+#else

+#   define VLC_FOURCC( a, b, c, d ) \

+        ( ((uint32_t)a) | ( ((uint32_t)b) << 8 ) \

+           | ( ((uint32_t)c) << 16 ) | ( ((uint32_t)d) << 24 ) )

+#   define VLC_TWOCC( a, b ) \

+        ( (uint16_t)(a) | ( (uint16_t)(b) << 8 ) )

+#endif

+#define FOURCC_user VLC_FOURCC( 'u', 's', 'e', 'r' )

+#define FOURCC_key  VLC_FOURCC( 'k', 'e', 'y', ' ' )

+#define FOURCC_iviv VLC_FOURCC( 'i', 'v', 'i', 'v' )

+#define FOURCC_name VLC_FOURCC( 'n', 'a', 'm', 'e' )

+#define FOURCC_priv VLC_FOURCC( 'p', 'r', 'i', 'v' )

 #define MAX_TRACKS 1024

 #define TRACK_UNKNOWN 0

 #define TRACK_AUDIO   1

@@ -76,6 +117,8 @@

 #define ATOM_FRMA 152

 #define ATOM_IVIV 153

 #define ATOM_PRIV 154

+#define ATOM_USER 155

+#define ATOM_KEY  156

 #define ATOM_UNKNOWN 255

 #define ATOM_FREE ATOM_UNKNOWN

@@ -122,7 +165,7 @@

     uint32_t (*read)(void *user_data, void *buffer, uint32_t length);

     uint32_t (*write)(void *udata, void *buffer, uint32_t length);

     uint32_t (*seek)(void *user_data, uint64_t position);

-	uint32_t (*truncate)(void *user_data);

+    uint32_t (*truncate)(void *user_data);

     void *user_data;

 } mp4ff_callback_t;

@@ -148,46 +191,46 @@

     int32_t channelCount;

     int32_t sampleSize;

     uint16_t sampleRate;

-	int32_t audioType;

+    int32_t audioType;

     /* stsd */

     int32_t stsd_entry_count;

     /* stsz */

-	int32_t stsz_sample_size;

-	int32_t stsz_sample_count;

+    int32_t stsz_sample_size;

+    int32_t stsz_sample_count;

     int32_t *stsz_table;

     /* stts */

-	int32_t stts_entry_count;

+    int32_t stts_entry_count;

     int32_t *stts_sample_count;

     int32_t *stts_sample_delta;

     /* stsc */

-	int32_t stsc_entry_count;

+    int32_t stsc_entry_count;

     int32_t *stsc_first_chunk;

     int32_t *stsc_samples_per_chunk;

     int32_t *stsc_sample_desc_index;

     /* stsc */

-	int32_t stco_entry_count;

+    int32_t stco_entry_count;

     int32_t *stco_chunk_offset;

-	/* ctts */

-	int32_t ctts_entry_count;

-	int32_t *ctts_sample_count;

-	int32_t *ctts_sample_offset;

+    /* ctts */

+    int32_t ctts_entry_count;

+    int32_t *ctts_sample_count;

+    int32_t *ctts_sample_offset;

     /* esde */

     uint8_t *decoderConfig;

     int32_t decoderConfigLen;

-	uint32_t maxBitrate;

-	uint32_t avgBitrate;

-	uint32_t timeScale;

-	uint64_t duration;

+    uint32_t maxBitrate;

+    uint32_t avgBitrate;

+    uint32_t timeScale;

+    uint64_t duration;

 #ifdef ITUNES_DRM

     /* drms */

     void *p_drms;

@@ -199,7 +242,7 @@

 typedef struct

     /* stream to read from */

-	mp4ff_callback_t *stream;

+    mp4ff_callback_t *stream;

     int64_t current_position;

     int32_t moov_read;

--- a/configure.in

+++ b/configure.in

@@ -30,6 +30,16 @@

 AC_CHECK_HEADERS(sys/time.h)

 AC_HEADER_TIME

+dnl DRMS

+AC_CHECK_HEADERS(errno.h sys/stat.h sys/types.h limits.h)

+AC_CHECK_HEADERS(sysfs/libsysfs.h)

+AC_CHECK_HEADERS(IOKit/IOKitLib.h,

+  [AC_CHECK_LIB(IOKit, main,

+    [AC_DEFINE(HAVE_IOKIT_IOKITLIB_H, 1, [Define if you have the IOKit API])

+     MP4FF_LIBS="-lIOKit"

+     AC_SUBST(MP4FF_LIBS)])])

+AC_CHECK_FUNCS(getpwuid)

 AC_C_INLINE

 AC_C_BIGENDIAN