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

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

midi

开发平台：

Unix_Linux

update.c：源码内容
  1. /*****************************************************************************
  2.  * update.c: VLC update checking and downloading
  3.  *****************************************************************************
  4.  * Copyright © 2005-2008 the VideoLAN team
  5.  * $Id: e4e5d0161530771d5a09b3636eb87dab07794a27 $
  6.  *
  7.  * Authors: Antoine Cellerier <dionoea -at- videolan -dot- org>
  8.  *          Rémi Duraffort <ivoire at via.ecp.fr>
  9.             Rafaël Carré <funman@videolanorg>
  10.  *
  11.  * This program is free software; you can redistribute it and/or modify
  12.  * it under the terms of the GNU General Public License as published by
  13.  * the Free Software Foundation; either release 2 of the License, or
  14.  * (at your option) any later release.
  15.  *
  16.  * This program is distributed in the hope that it will be useful,
  17.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19.  * GNU General Public License for more details.
  20.  *
  21.  * You should have received a copy of the GNU General Public License
  22.  * along with this program; if not, write to the Free Software
  23.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  24.  *****************************************************************************/
  26. /**
  27.  *   file
  28.  *   This file contains functions related to VLC update management
  29.  */
  31. /*****************************************************************************
  32.  * Preamble
  33.  *****************************************************************************/
  35. #ifdef HAVE_CONFIG_H
  36. # include "config.h"
  37. #endif
  39. #include <vlc_common.h>
  40. #include <vlc_update.h>
  42. #ifdef UPDATE_CHECK
  44. #include <assert.h>
  46. #include <vlc_pgpkey.h>
  47. #include <vlc_stream.h>
  48. #include <vlc_strings.h>
  49. #include <vlc_charset.h>
  50. #include <vlc_dialog.h>
  52. #include <gcrypt.h>
  53. #include <vlc_gcrypt.h>
  55. #include "update.h"
  56. #include "../libvlc.h"
  58. /*****************************************************************************
  59.  * Misc defines
  60.  *****************************************************************************/
  62. /*
  63.  * Here is the format of these "status files" :
  64.  * First line is the last version: "X.Y.Ze" where:
  65.  *      * X is the major number
  66.  *      * Y is the minor number
  67.  *      * Z is the revision number
  68.  *      * e is an OPTIONAL extra letter
  69.  *      * AKA "0.8.6d" or "0.9.0"
  70.  * Second line is an url of the binary for this last version
  71.  * Remaining text is a required description of the update
  72.  */
  74. #if defined( UNDER_CE )
  75. #   define UPDATE_VLC_STATUS_URL "http://update.videolan.org/vlc/status-ce"
  76. #elif defined( WIN32 )
  77. #   define UPDATE_VLC_STATUS_URL "http://update.videolan.org/vlc/status-win-x86"
  78. #elif defined( __APPLE__ )
  79. #   if defined( __powerpc__ ) || defined( __ppc__ ) || defined( __ppc64__ )
  80. #       define UPDATE_VLC_STATUS_URL "http://update.videolan.org/vlc/status-mac-ppc"
  81. #   else
  82. #       define UPDATE_VLC_STATUS_URL "http://update.videolan.org/vlc/status-mac-x86"
  83. #   endif
  84. #elif defined( SYS_BEOS )
  85. #       define UPDATE_VLC_STATUS_URL "http://update.videolan.org/vlc/status-beos-x86"
  86. #else
  87. #   define UPDATE_VLC_STATUS_URL "http://update.videolan.org/vlc/status"
  88. #endif
  91. /*****************************************************************************
  92.  * OpenPGP functions
  93.  *****************************************************************************/
  95. #define packet_type( c ) ( ( c & 0x3c ) >> 2 )      /* 0x3C = 00111100 */
  96. #define packet_header_len( c ) ( ( c & 0x03 ) + 1 ) /* number of bytes in a packet header */
  98. static inline int scalar_number( uint8_t *p, int header_len )
  99. {
  100.     assert( header_len == 1 || header_len == 2 || header_len == 4 );
  102.     if( header_len == 1 )
  103.         return( p[0] );
  104.     else if( header_len == 2 )
  105.         return( (p[0] << 8) + p[1] );
  106.     else if( header_len == 4 )
  107.         return( (p[0] << 24) + (p[1] << 16) + (p[2] << 8) + p[3] );
  109.     abort(); /* to shut up GCC warning */
  110. }
  112. /* number of data bytes in a MPI */
  113. #define mpi_len( mpi ) ( ( scalar_number( mpi, 2 ) + 7 ) / 8 )
  115. /*
  116.  * fill a public_key_packet_t structure from public key packet data
  117.  * verify that it is a version 4 public key packet, using DSA
  118.  */
  119. static int parse_public_key_packet( public_key_packet_t *p_key, uint8_t *p_buf,
  120.                                     size_t i_packet_len )
  121. {
  123.     if( i_packet_len > 418 || i_packet_len < 6 )
  124.         return VLC_EGENERIC;
  126.     size_t i_read = 0;
  128.     p_key->version   = *p_buf++; i_read++;
  129.     if( p_key->version != 4 )
  130.         return VLC_EGENERIC;
  132.     /* XXX: warn when timestamp is > date ? */
  133.     memcpy( p_key->timestamp, p_buf, 4 ); p_buf += 4; i_read += 4;
  135.     p_key->algo      = *p_buf++; i_read++;
  136.     if( p_key->algo != PUBLIC_KEY_ALGO_DSA )
  137.         return VLC_EGENERIC;
  139.     /* read p */
  140.     if( i_read + 2 > i_packet_len )
  141.         return VLC_EGENERIC;
  143.     int i_p_len = mpi_len( p_buf );
  145.     if( i_p_len > 128 || i_read + 2 + i_p_len > i_packet_len )
  146.         return VLC_EGENERIC;
  148.     memcpy( p_key->p, p_buf, 2+i_p_len );
  149.     p_buf += 2+i_p_len; i_read += 2+i_p_len;
  151.     /* read q */
  152.     if( i_read + 2 > i_packet_len )
  153.         return VLC_EGENERIC;
  155.     int i_q_len = mpi_len( p_buf );
  157.     if( i_q_len > 20 || i_read+2+i_q_len > i_packet_len )
  158.         return VLC_EGENERIC;
  160.     memcpy( p_key->q, p_buf, 2+i_q_len );
  161.     p_buf += 2+i_q_len; i_read += 2+i_q_len;
  163.     /* read g */
  164.     if( i_read + 2 > i_packet_len )
  165.         return VLC_EGENERIC;
  167.     int i_g_len = mpi_len( p_buf );
  169.     if( i_g_len > 128 || i_read+2+i_g_len > i_packet_len )
  170.         return VLC_EGENERIC;
  172.     memcpy( p_key->g, p_buf, 2+i_g_len );
  173.     p_buf += 2+i_g_len; i_read += 2+i_g_len;
  175.     /* read y */
  176.     if( i_read + 2 > i_packet_len )
  177.         return VLC_EGENERIC;
  179.     int i_y_len = mpi_len( p_buf );
  182.     if( i_y_len > 128 || i_read+2+i_y_len > i_packet_len )
  183.         return VLC_EGENERIC;
  185.     memcpy( p_key->y, p_buf, 2+i_y_len );
  186.     i_read += 2+i_y_len;
  188.     if( i_read != i_packet_len ) /* some extra data eh ? */
  189.         return VLC_EGENERIC;
  191.     return VLC_SUCCESS;
  192. }
  194. static size_t parse_signature_v3_packet( signature_packet_t *p_sig,
  195.                                       uint8_t *p_buf, size_t i_sig_len )
  196. {
  197.     size_t i_read = 1; /* we already read the version byte */
  199.     if( i_sig_len < 19 ) /* signature is at least 19 bytes + the 2 MPIs */
  200.         return 0;
  202.     p_sig->specific.v3.hashed_data_len = *p_buf++; i_read++;
  203.     if( p_sig->specific.v3.hashed_data_len != 5 )
  204.         return 0;
  206.     p_sig->type = *p_buf++; i_read++;
  208.     memcpy( p_sig->specific.v3.timestamp, p_buf, 4 );
  209.     p_buf += 4; i_read += 4;
  211.     memcpy( p_sig->issuer_longid, p_buf, 8 );
  212.     p_buf += 8; i_read += 8;
  214.     p_sig->public_key_algo = *p_buf++; i_read++;
  216.     p_sig->digest_algo = *p_buf++; i_read++;
  218.     p_sig->hash_verification[0] = *p_buf++; i_read++;
  219.     p_sig->hash_verification[1] = *p_buf++; i_read++;
  221.     assert( i_read == 19 );
  223.     return i_read;
  224. }
  226. /*
  227.  * fill a signature_packet_v4_t from signature packet data
  228.  * verify that it was used with a DSA public key, using SHA-1 digest
  229.  */
  230. static size_t parse_signature_v4_packet( signature_packet_t *p_sig,
  231.                                       uint8_t *p_buf, size_t i_sig_len )
  232. {
  233.     size_t i_read = 1; /* we already read the version byte */
  235.     if( i_sig_len < 10 ) /* signature is at least 10 bytes + the 2 MPIs */
  236.         return 0;
  238.     p_sig->type = *p_buf++; i_read++;
  240.     p_sig->public_key_algo = *p_buf++; i_read++;
  242.     p_sig->digest_algo = *p_buf++; i_read++;
  244.     memcpy( p_sig->specific.v4.hashed_data_len, p_buf, 2 );
  245.     p_buf += 2; i_read += 2;
  247.     size_t i_hashed_data_len =
  248.         scalar_number( p_sig->specific.v4.hashed_data_len, 2 );
  249.     i_read += i_hashed_data_len;
  250.     if( i_read + 4 > i_sig_len )
  251.         return 0;
  253.     p_sig->specific.v4.hashed_data = (uint8_t*) malloc( i_hashed_data_len );
  254.     if( !p_sig->specific.v4.hashed_data )
  255.         return 0;
  256.     memcpy( p_sig->specific.v4.hashed_data, p_buf, i_hashed_data_len );
  257.     p_buf += i_hashed_data_len;
  259.     memcpy( p_sig->specific.v4.unhashed_data_len, p_buf, 2 );
  260.     p_buf += 2; i_read += 2;
  262.     size_t i_unhashed_data_len =
  263.         scalar_number( p_sig->specific.v4.unhashed_data_len, 2 );
  264.     i_read += i_unhashed_data_len;
  265.     if( i_read + 2 > i_sig_len )
  266.         return 0;
  268.     p_sig->specific.v4.unhashed_data = (uint8_t*) malloc( i_unhashed_data_len );
  269.     if( !p_sig->specific.v4.unhashed_data )
  270.         return 0;
  272.     memcpy( p_sig->specific.v4.unhashed_data, p_buf, i_unhashed_data_len );
  273.     p_buf += i_unhashed_data_len;
  275.     memcpy( p_sig->hash_verification, p_buf, 2 );
  276.     p_buf += 2; i_read += 2;
  278.     uint8_t *p, *max_pos;
  279.     p = p_sig->specific.v4.unhashed_data;
  280.     max_pos = p + scalar_number( p_sig->specific.v4.unhashed_data_len, 2 );
  282.     for( ;; )
  283.     {
  284.         if( p > max_pos )
  285.             return 0;
  287.         size_t i_subpacket_len;
  288.         if( *p < 192 )
  289.         {
  290.             if( p + 1 > max_pos )
  291.                 return 0;
  292.             i_subpacket_len = *p++;
  293.         }
  294.         else if( *p < 255 )
  295.         {
  296.             if( p + 2 > max_pos )
  297.                 return 0;
  298.             i_subpacket_len = (*p++ - 192) << 8;
  299.             i_subpacket_len += *p++ + 192;
  300.         }
  301.         else
  302.         {
  303.             if( p + 4 > max_pos )
  304.                 return 0;
  305.             i_subpacket_len = *++p << 24;
  306.             i_subpacket_len += *++p << 16;
  307.             i_subpacket_len += *++p << 8;
  308.             i_subpacket_len += *++p;
  309.         }
  311.         if( *p == ISSUER_SUBPACKET )
  312.         {
  313.             if( p + 9 > max_pos )
  314.                 return 0;
  316.             memcpy( &p_sig->issuer_longid, p+1, 8 );
  318.             return i_read;
  319.         }
  321.         p += i_subpacket_len;
  322.     }
  323. }
  325. static int parse_signature_packet( signature_packet_t *p_sig,
  326.                                    uint8_t *p_buf, size_t i_sig_len )
  327. {
  328.     if( !i_sig_len ) /* 1st sanity check, we need at least the version */
  329.         return VLC_EGENERIC;
  331.     p_sig->version = *p_buf++;
  333.     size_t i_read;
  334.     switch( p_sig->version )
  335.     {
  336.         case 3:
  337.             i_read = parse_signature_v3_packet( p_sig, p_buf, i_sig_len );
  338.             break;
  339.         case 4:
  340.             p_sig->specific.v4.hashed_data = NULL;
  341.             p_sig->specific.v4.unhashed_data = NULL;
  342.             i_read = parse_signature_v4_packet( p_sig, p_buf, i_sig_len );
  343.             break;
  344.         default:
  345.             return VLC_EGENERIC;
  346.     }
  348.     if( i_read == 0 ) /* signature packet parsing has failed */
  349.         goto error;
  351.     if( p_sig->public_key_algo != PUBLIC_KEY_ALGO_DSA )
  352.         goto error;
  354.     if( p_sig->digest_algo != DIGEST_ALGO_SHA1 )
  355.         goto error;
  357.     switch( p_sig->type )
  358.     {
  359.         case BINARY_SIGNATURE:
  360.         case TEXT_SIGNATURE:
  361.         case GENERIC_KEY_SIGNATURE:
  362.         case PERSONA_KEY_SIGNATURE:
  363.         case CASUAL_KEY_SIGNATURE:
  364.         case POSITIVE_KEY_SIGNATURE:
  365.             break;
  366.         default:
  367.             goto error;
  368.     }
  370.     p_buf--; /* rewind to the version byte */
  371.     p_buf += i_read;
  373.     if( i_read + 2 > i_sig_len )
  374.         goto error;
  376.     size_t i_r_len = mpi_len( p_buf ); i_read += 2;
  377.     if( i_read + i_r_len > i_sig_len || i_r_len > 20 )
  378.         goto error;
  380.     memcpy( p_sig->r, p_buf, 2 + i_r_len );
  381.     p_buf += 2 + i_r_len;
  382.     i_read += i_r_len;
  384.     if( i_read + 2 > i_sig_len )
  385.         goto error;
  387.     size_t i_s_len = mpi_len( p_buf ); i_read += 2;
  388.     if( i_read + i_s_len > i_sig_len || i_s_len > 20 )
  389.         goto error;
  391.     memcpy( p_sig->s, p_buf, 2 + i_s_len );
  392.     p_buf += 2 + i_s_len;
  393.     i_read += i_s_len;
  395.     assert( i_read == i_sig_len );
  396.     if( i_read < i_sig_len ) /* some extra data, hm ? */
  397.         goto error;
  399.     return VLC_SUCCESS;
  401. error:
  403.     if( p_sig->version == 4 )
  404.     {
  405.         free( p_sig->specific.v4.hashed_data );
  406.         free( p_sig->specific.v4.unhashed_data );
  407.     }
  409.     return VLC_EGENERIC;
  410. }
  412. /*
  413.  * crc_octets() was lamely copied from rfc 2440
  414.  * Copyright (C) The Internet Society (1998).  All Rights Reserved.
  415.  */
  416. #define CRC24_INIT 0xB704CEL
  417. #define CRC24_POLY 0x1864CFBL
  419. static long crc_octets( uint8_t *octets, size_t len )
  420. {
  421.     long crc = CRC24_INIT;
  422.     int i;
  423.     while (len--)
  424.     {
  425.         crc ^= (*octets++) << 16;
  426.         for (i = 0; i < 8; i++)
  427.         {
  428.             crc <<= 1;
  429.             if (crc & 0x1000000)
  430.                 crc ^= CRC24_POLY;
  431.         }
  432.     }
  433.     return crc & 0xFFFFFFL;
  434. }
  436. /*
  437.  * Transform an armored document in binary format
  438.  * Used on public keys and signatures
  439.  */
  440. static int pgp_unarmor( char *p_ibuf, size_t i_ibuf_len,
  441.                         uint8_t *p_obuf, size_t i_obuf_len )
  442. {
  443.     char *p_ipos = p_ibuf;
  444.     uint8_t *p_opos = p_obuf;
  445.     int i_end = 0;
  446.     int i_header_skipped = 0;
  448.     while( !i_end && p_ipos < p_ibuf + i_ibuf_len && *p_ipos != '=' )
  449.     {
  450.         if( *p_ipos == 'r' || *p_ipos == 'n' )
  451.         {
  452.             p_ipos++;
  453.             continue;
  454.         }
  456.         size_t i_line_len = strcspn( p_ipos, "rn" );
  457.         if( i_line_len == 0 )
  458.             continue;
  460.         if( !i_header_skipped )
  461.         {
  462.             if( !strncmp( p_ipos, "-----BEGIN PGP", 14 ) )
  463.                 i_header_skipped = 1;
  465.             p_ipos += i_line_len + 1;
  466.             continue;
  467.         }
  469.         if( !strncmp( p_ipos, "Version:", 8 ) )
  470.         {
  471.             p_ipos += i_line_len + 1;
  472.             continue;
  473.         }
  475.         if( p_ipos[i_line_len - 1] == '=' )
  476.         {
  477.             i_end = 1;
  478.             p_ipos[i_line_len - 1] = '';
  479.         }
  480.         else
  481.             p_ipos[i_line_len] = '';
  483.         p_opos += vlc_b64_decode_binary_to_buffer(  p_opos,
  484.                         p_obuf - p_opos + i_obuf_len, p_ipos );
  485.         p_ipos += i_line_len + 1;
  486.     }
  488.     /* XXX: the CRC is OPTIONAL, really require it ? */
  489.     if( p_ipos + 5 > p_ibuf + i_ibuf_len || *p_ipos++ != '=' )
  490.         return 0;
  492.     uint8_t p_crc[3];
  493.     if( vlc_b64_decode_binary_to_buffer( p_crc, 3, p_ipos ) != 3 )
  494.         return 0;
  496.     long l_crc = crc_octets( p_obuf, p_opos - p_obuf );
  497.     long l_crc2 = ( 0 << 24 ) + ( p_crc[0] << 16 ) + ( p_crc[1] << 8 ) + p_crc[2];
  499.     return l_crc2 == l_crc ? p_opos - p_obuf : 0;
  500. }
  502. /*
  503.  * Download the signature associated to a document or a binary file.
  504.  * We're given the file's url, we just append ".asc" to it and download
  505.  */
  506. static int download_signature(  vlc_object_t *p_this,
  507.                                 signature_packet_t *p_sig,
  508.                                 const char *psz_url )
  509. {
  510.     char *psz_sig = (char*) malloc( strlen( psz_url ) + 4 + 1 ); /* ".asc" +  */
  511.     if( !psz_sig )
  512.         return VLC_ENOMEM;
  514.     strcpy( psz_sig, psz_url );
  515.     strcat( psz_sig, ".asc" );
  517.     stream_t *p_stream = stream_UrlNew( p_this, psz_sig );
  518.     free( psz_sig );
  520.     if( !p_stream )
  521.         return VLC_ENOMEM;
  523.     int64_t i_size = stream_Size( p_stream );
  525.     msg_Dbg( p_this, "Downloading signature (%"PRId64" bytes)", i_size );
  526.     uint8_t *p_buf = (uint8_t*)malloc( i_size );
  527.     if( !p_buf )
  528.     {
  529.         stream_Delete( p_stream );
  530.         return VLC_ENOMEM;
  531.     }
  533.     int i_read = stream_Read( p_stream, p_buf, (int)i_size );
  535.     stream_Delete( p_stream );
  537.     if( i_read != (int)i_size )
  538.     {
  539.         msg_Dbg( p_this,
  540.             "Couldn't download full signature (only %d bytes)", i_read );
  541.         free( p_buf );
  542.         return VLC_EGENERIC;
  543.     }
  545.     if( (uint8_t)*p_buf < 0x80 ) /* ASCII */
  546.     {
  547.         msg_Dbg( p_this, "Unarmoring signature" );
  549.         uint8_t* p_unarmored = (uint8_t*) malloc( ( i_size * 3 ) / 4 + 1 );
  550.         if( !p_unarmored )
  551.         {
  552.             free( p_buf );
  553.             return VLC_EGENERIC;
  554.         }
  556.         int i_bytes = pgp_unarmor( (char*)p_buf, i_size, p_unarmored, i_size );
  557.         free( p_buf );
  559.         p_buf = p_unarmored;
  560.         i_size = i_bytes;
  562.         if( i_bytes < 2 )
  563.         {
  564.             free( p_buf );
  565.             msg_Dbg( p_this, "Unarmoring failed : corrupted signature ?" );
  566.             return VLC_EGENERIC;
  567.         }
  568.     }
  570.     if( packet_type( *p_buf ) != SIGNATURE_PACKET )
  571.     {
  572.         free( p_buf );
  573.         msg_Dbg( p_this, "Not a signature: %d", *p_buf );
  574.         return VLC_EGENERIC;
  575.     }
  577.     size_t i_header_len = packet_header_len( *p_buf );
  578.     if( ( i_header_len != 1 && i_header_len != 2 && i_header_len != 4 ) ||
  579.         i_header_len + 1 > (size_t)i_size )
  580.     {
  581.         free( p_buf );
  582.         msg_Dbg( p_this, "Invalid signature packet header" );
  583.         return VLC_EGENERIC;
  584.     }
  586.     size_t i_len = scalar_number( p_buf+1, i_header_len );
  587.     if( i_len + i_header_len + 1 != (size_t)i_size )
  588.     {
  589.         free( p_buf );
  590.         msg_Dbg( p_this, "Invalid signature packet" );
  591.         return VLC_EGENERIC;
  592.     }
  594.     int i_ret = parse_signature_packet( p_sig, p_buf+1+i_header_len, i_len );
  595.     free( p_buf );
  596.     if( i_ret != VLC_SUCCESS )
  597.     {
  598.         msg_Dbg( p_this, "Couldn't parse signature" );
  599.         return i_ret;
  600.     }
  602.     if( p_sig->type != BINARY_SIGNATURE && p_sig->type != TEXT_SIGNATURE )
  603.     {
  604.         msg_Dbg( p_this, "Invalid signature type: %d", p_sig->type );
  605.         if( p_sig->version == 4 )
  606.         {
  607.             free( p_sig->specific.v4.hashed_data );
  608.             free( p_sig->specific.v4.unhashed_data );
  609.         }
  610.         return VLC_EGENERIC;
  611.     }
  613.     return VLC_SUCCESS;
  614. }
  616. /*
  617.  * Verify an OpenPGP signature made on some SHA-1 hash, with some DSA public key
  618.  */
  619. static int verify_signature( uint8_t *p_r, uint8_t *p_s,
  620.         public_key_packet_t *p_key, uint8_t *p_hash )
  621. {
  622.     /* the data to be verified (a SHA-1 hash) */
  623.     const char *hash_sexp_s = "(data(flags raw)(value %m))";
  624.     /* the public key */
  625.     const char *key_sexp_s = "(public-key(dsa(p %m)(q %m)(g %m)(y %m)))";
  626.     /* the signature */
  627.     const char *sig_sexp_s = "(sig-val(dsa(r %m )(s %m )))";
  629.     size_t erroff;
  630.     gcry_mpi_t p, q, g, y, r, s, hash;
  631.     p = q = g = y = r = s = hash = NULL;
  632.     gcry_sexp_t key_sexp, hash_sexp, sig_sexp;
  633.     key_sexp = hash_sexp = sig_sexp = NULL;
  635.     int i_p_len = mpi_len( p_key->p );
  636.     int i_q_len = mpi_len( p_key->q );
  637.     int i_g_len = mpi_len( p_key->g );
  638.     int i_y_len = mpi_len( p_key->y );
  639.     if( gcry_mpi_scan( &p, GCRYMPI_FMT_USG, p_key->p + 2, i_p_len, NULL ) ||
  640.         gcry_mpi_scan( &q, GCRYMPI_FMT_USG, p_key->q + 2, i_q_len, NULL ) ||
  641.         gcry_mpi_scan( &g, GCRYMPI_FMT_USG, p_key->g + 2, i_g_len, NULL ) ||
  642.         gcry_mpi_scan( &y, GCRYMPI_FMT_USG, p_key->y + 2, i_y_len, NULL ) ||
  643.         gcry_sexp_build( &key_sexp, &erroff, key_sexp_s, p, q, g, y ) )
  644.         goto problem;
  646.     int i_r_len = mpi_len( p_r );
  647.     int i_s_len = mpi_len( p_s );
  648.     if( gcry_mpi_scan( &r, GCRYMPI_FMT_USG, p_r + 2, i_r_len, NULL ) ||
  649.         gcry_mpi_scan( &s, GCRYMPI_FMT_USG, p_s + 2, i_s_len, NULL ) ||
  650.         gcry_sexp_build( &sig_sexp, &erroff, sig_sexp_s, r, s ) )
  651.         goto problem;
  653.     int i_hash_len = 20;
  654.     if( gcry_mpi_scan( &hash, GCRYMPI_FMT_USG, p_hash, i_hash_len, NULL ) ||
  655.         gcry_sexp_build( &hash_sexp, &erroff, hash_sexp_s, hash ) )
  656.         goto problem;
  658.     if( gcry_pk_verify( sig_sexp, hash_sexp, key_sexp ) )
  659.         goto problem;
  661.     return VLC_SUCCESS;
  663. problem:
  664.     if( p ) gcry_mpi_release( p );
  665.     if( q ) gcry_mpi_release( q );
  666.     if( g ) gcry_mpi_release( g );
  667.     if( y ) gcry_mpi_release( y );
  668.     if( r ) gcry_mpi_release( r );
  669.     if( s ) gcry_mpi_release( s );
  670.     if( hash ) gcry_mpi_release( hash );
  671.     if( key_sexp ) gcry_sexp_release( key_sexp );
  672.     if( sig_sexp ) gcry_sexp_release( sig_sexp );
  673.     if( hash_sexp ) gcry_sexp_release( hash_sexp );
  674.     return VLC_EGENERIC;
  675. }
  677. /*
  678.  * fill a public_key_t with public key data, including:
  679.  *   * public key packet
  680.  *   * signature packet issued by key which long id is p_sig_issuer
  681.  *   * user id packet
  682.  */
  683. static int parse_public_key( const uint8_t *p_key_data, size_t i_key_len,
  684.                              public_key_t *p_key, const uint8_t *p_sig_issuer )
  685. {
  686.     uint8_t *pos = (uint8_t*) p_key_data;
  687.     uint8_t *max_pos = pos + i_key_len;
  689.     int i_status = 0;
  690. #define PUBLIC_KEY_FOUND    0x01
  691. #define USER_ID_FOUND       0x02
  692. #define SIGNATURE_FOUND     0X04
  694.     uint8_t *p_key_unarmored = NULL;
  696.     p_key->psz_username = NULL;
  697.     p_key->sig.specific.v4.hashed_data = NULL;
  698.     p_key->sig.specific.v4.unhashed_data = NULL;
  700.     if( !( *pos & 0x80 ) )
  701.     {   /* first byte is ASCII, unarmoring */
  702.         p_key_unarmored = (uint8_t*)malloc( i_key_len );
  703.         if( !p_key_unarmored )
  704.             return VLC_ENOMEM;
  705.         int i_len = pgp_unarmor( (char*)p_key_data, i_key_len,
  706.                                  p_key_unarmored, i_key_len );
  708.         if( i_len == 0 )
  709.             goto error;
  711.         pos = p_key_unarmored;
  712.         max_pos = pos + i_len;
  713.     }
  715.     while( pos < max_pos )
  716.     {
  717.         if( !(*pos & 0x80) || *pos & 0x40 )
  718.             goto error;
  720.         int i_type = packet_type( *pos );
  722.         int i_header_len = packet_header_len( *pos++ );
  723.         if( pos + i_header_len > max_pos ||
  724.             ( i_header_len != 1 && i_header_len != 2 && i_header_len != 4 ) )
  725.             goto error;
  727.         int i_packet_len = scalar_number( pos, i_header_len );
  728.         pos += i_header_len;
  730.         if( pos + i_packet_len > max_pos )
  731.             goto error;
  733.         switch( i_type )
  734.         {
  735.             case PUBLIC_KEY_PACKET:
  736.                 i_status |= PUBLIC_KEY_FOUND;
  737.                 if( parse_public_key_packet( &p_key->key, pos, i_packet_len ) != VLC_SUCCESS )
  738.                     goto error;
  739.                 break;
  741.             case SIGNATURE_PACKET: /* we accept only v4 signatures here */
  742.                 if( i_status & SIGNATURE_FOUND || !p_sig_issuer )
  743.                     break;
  744.                 int i_ret = parse_signature_packet( &p_key->sig, pos,
  745.                                                     i_packet_len );
  746.                 if( i_ret == VLC_SUCCESS )
  747.                 {
  748.                     if( p_key->sig.version != 4 )
  749.                         break;
  750.                     if( memcmp( p_key->sig.issuer_longid, p_sig_issuer, 8 ) )
  751.                     {
  752.                         free( p_key->sig.specific.v4.hashed_data );
  753.                         free( p_key->sig.specific.v4.unhashed_data );
  754.                         p_key->sig.specific.v4.hashed_data = NULL;
  755.                         p_key->sig.specific.v4.unhashed_data = NULL;
  756.                         break;
  757.                     }
  758.                     i_status |= SIGNATURE_FOUND;
  759.                 }
  760.                 break;
  762.             case USER_ID_PACKET:
  763.                 if( p_key->psz_username ) /* save only the first User ID */
  764.                     break;
  765.                 i_status |= USER_ID_FOUND;
  766.                 p_key->psz_username = (uint8_t*)malloc( i_packet_len + 1);
  767.                 if( !p_key->psz_username )
  768.                     goto error;
  770.                 memcpy( p_key->psz_username, pos, i_packet_len );
  771.                 p_key->psz_username[i_packet_len] = '';
  772.                 break;
  774.             default:
  775.                 break;
  776.         }
  777.         pos += i_packet_len;
  778.     }
  779.     free( p_key_unarmored );
  781.     if( !( i_status & ( PUBLIC_KEY_FOUND | USER_ID_FOUND ) ) )
  782.         return VLC_EGENERIC;
  784.     if( p_sig_issuer && !( i_status & SIGNATURE_FOUND ) )
  785.         return VLC_EGENERIC;
  787.     return VLC_SUCCESS;
  789. error:
  790.     if( p_key->sig.version == 4 )
  791.     {
  792.         free( p_key->sig.specific.v4.hashed_data );
  793.         free( p_key->sig.specific.v4.unhashed_data );
  794.     }
  795.     free( p_key->psz_username );
  796.     free( p_key_unarmored );
  797.     return VLC_EGENERIC;
  798. }
  800. /*
  801.  * return a sha1 hash of a file
  802.  */
  803. static uint8_t *hash_sha1_from_file( const char *psz_file,
  804.                             signature_packet_t *p_sig )
  805. {
  806.     if( p_sig->type != BINARY_SIGNATURE && p_sig->type != TEXT_SIGNATURE )
  807.         return NULL;
  809.     FILE *f = utf8_fopen( psz_file, "r" );
  810.     if( !f )
  811.         return NULL;
  813.     uint8_t buffer[4096];
  815.     gcry_md_hd_t hd;
  816.     if( gcry_md_open( &hd, GCRY_MD_SHA1, 0 ) )
  817.     {
  818.         fclose( f );
  819.         return NULL;
  820.     }
  822.     size_t i_read;
  823.     while( ( i_read = fread( buffer, 1, sizeof(buffer), f ) ) > 0 )
  824.         gcry_md_write( hd, buffer, i_read );
  826.     if( p_sig->version == 3 )
  827.     {
  828.         gcry_md_putc( hd, p_sig->type );
  829.         gcry_md_write( hd, &p_sig->specific.v3.timestamp, 4 );
  830.     }
  831.     else if( p_sig->version == 4 )
  832.     {
  833.         gcry_md_putc( hd, p_sig->version );
  834.         gcry_md_putc( hd, p_sig->type );
  835.         gcry_md_putc( hd, p_sig->public_key_algo );
  836.         gcry_md_putc( hd, p_sig->digest_algo );
  837.         gcry_md_write( hd, p_sig->specific.v4.hashed_data_len, 2 );
  838.         size_t i_len = scalar_number( p_sig->specific.v4.hashed_data_len, 2 );
  839.         gcry_md_write( hd, p_sig->specific.v4.hashed_data, i_len );
  841.         gcry_md_putc( hd, 0x04 );
  842.         gcry_md_putc( hd, 0xFF );
  844.         i_len += 6; /* hashed data + 6 bytes header */
  846.         gcry_md_putc( hd, (i_len >> 24) & 0xff );
  847.         gcry_md_putc( hd, (i_len >> 16) & 0xff );
  848.         gcry_md_putc( hd, (i_len >> 8) & 0xff );
  849.         gcry_md_putc( hd, (i_len) & 0xff );
  850.     }
  851.     else
  852.     {   /* RFC 4880 only tells about versions 3 and 4 */
  853.         gcry_md_close( hd );
  854.         return NULL;
  855.     }
  857.     fclose( f );
  858.     gcry_md_final( hd );
  860.     uint8_t *p_tmp = (uint8_t*) gcry_md_read( hd, GCRY_MD_SHA1);
  861.     uint8_t *p_hash = malloc( 20 );
  862.     if( p_hash )
  863.         memcpy( p_hash, p_tmp, 20 );
  864.     gcry_md_close( hd );
  865.     return p_hash;
  866. }
  868. /*
  869.  * download a public key (the last one) from videolan server, and parse it
  870.  */
  871. static public_key_t *download_key( vlc_object_t *p_this,
  872.                     const uint8_t *p_longid, const uint8_t *p_signature_issuer )
  873. {
  874.     char *psz_url;
  875.     if( asprintf( &psz_url, "http://download.videolan.org/pub/keys/%.2X%.2X%.2X%.2X%.2X%.2X%.2X%.2X.asc",
  876.                     p_longid[0], p_longid[1], p_longid[2], p_longid[3],
  877.                     p_longid[4], p_longid[5], p_longid[6], p_longid[7] ) == -1 )
  878.         return NULL;
  880.     stream_t *p_stream = stream_UrlNew( p_this, psz_url );
  881.     free( psz_url );
  882.     if( !p_stream )
  883.         return NULL;
  885.     int64_t i_size = stream_Size( p_stream );
  886.     if( i_size < 0 )
  887.     {
  888.         stream_Delete( p_stream );
  889.         return NULL;
  890.     }
  892.     uint8_t *p_buf = (uint8_t*)malloc( i_size );
  893.     if( !p_buf )
  894.     {
  895.         stream_Delete( p_stream );
  896.         return NULL;
  897.     }
  899.     int i_read = stream_Read( p_stream, p_buf, (int)i_size );
  900.     stream_Delete( p_stream );
  902.     if( i_read != (int)i_size )
  903.     {
  904.         msg_Dbg( p_this, "Couldn't read full GPG key" );
  905.         free( p_buf );
  906.         return NULL;
  907.     }
  909.     public_key_t *p_pkey = (public_key_t*) malloc( sizeof( public_key_t ) );
  910.     if( !p_pkey )
  911.     {
  912.         free( p_buf );
  913.         return NULL;
  914.     }
  916.     memcpy( p_pkey->longid, p_longid, 8 );
  918.     int i_error = parse_public_key( p_buf, i_read, p_pkey, p_signature_issuer );
  919.     free( p_buf );
  921.     if( i_error != VLC_SUCCESS )
  922.     {
  923.         msg_Dbg( p_this, "Couldn't parse GPG key" );
  924.         free( p_pkey );
  925.         return NULL;
  926.     }
  928.     return p_pkey;
  929. }
  931. /*
  932.  * Generate a SHA1 hash on a public key, to verify a signature made on that hash
  933.  * Note that we need the signature (v4) to compute the hash
  934.  */
  935. static uint8_t *key_sign_hash( public_key_t *p_pkey )
  936. {
  937.     if( p_pkey->sig.version != 4 )
  938.         return NULL;
  940.     if( p_pkey->sig.type < GENERIC_KEY_SIGNATURE ||
  941.         p_pkey->sig.type > POSITIVE_KEY_SIGNATURE )
  942.         return NULL;
  944.     gcry_error_t error = 0;
  945.     gcry_md_hd_t hd;
  947.     error = gcry_md_open( &hd, GCRY_MD_SHA1, 0 );
  948.     if( error )
  949.         return NULL;
  951.     gcry_md_putc( hd, 0x99 );
  953.     size_t i_p_len = mpi_len( p_pkey->key.p );
  954.     size_t i_g_len = mpi_len( p_pkey->key.g );
  955.     size_t i_q_len = mpi_len( p_pkey->key.q );
  956.     size_t i_y_len = mpi_len( p_pkey->key.y );
  958.     size_t i_size = 6 + 2*4 + i_p_len + i_g_len + i_q_len + i_y_len;
  960.     gcry_md_putc( hd, (i_size >> 8) & 0xff );
  961.     gcry_md_putc( hd, i_size & 0xff );
  963.     gcry_md_putc( hd, p_pkey->key.version );
  964.     gcry_md_write( hd, p_pkey->key.timestamp, 4 );
  965.     gcry_md_putc( hd, p_pkey->key.algo );
  967.     gcry_md_write( hd, (uint8_t*)&p_pkey->key.p, 2 );
  968.     gcry_md_write( hd, (uint8_t*)&p_pkey->key.p + 2, i_p_len );
  970.     gcry_md_write( hd, (uint8_t*)&p_pkey->key.q, 2 );
  971.     gcry_md_write( hd, (uint8_t*)&p_pkey->key.q + 2, i_q_len );
  973.     gcry_md_write( hd, (uint8_t*)&p_pkey->key.g, 2 );
  974.     gcry_md_write( hd, (uint8_t*)&p_pkey->key.g + 2, i_g_len );
  976.     gcry_md_write( hd, (uint8_t*)&p_pkey->key.y, 2 );
  977.     gcry_md_write( hd, (uint8_t*)&p_pkey->key.y + 2, i_y_len );
  979.     gcry_md_putc( hd, 0xb4 );
  981.     size_t i_len = strlen((char*)p_pkey->psz_username);
  983.     gcry_md_putc( hd, (i_len >> 24) & 0xff );
  984.     gcry_md_putc( hd, (i_len >> 16) & 0xff );
  985.     gcry_md_putc( hd, (i_len >> 8) & 0xff );
  986.     gcry_md_putc( hd, (i_len) & 0xff );
  988.     gcry_md_write( hd, p_pkey->psz_username, i_len );
  990.     size_t i_hashed_data_len =
  991.         scalar_number( p_pkey->sig.specific.v4.hashed_data_len, 2 );
  993.     gcry_md_putc( hd, p_pkey->sig.version );
  994.     gcry_md_putc( hd, p_pkey->sig.type );
  995.     gcry_md_putc( hd, p_pkey->sig.public_key_algo );
  996.     gcry_md_putc( hd, p_pkey->sig.digest_algo );
  997.     gcry_md_write( hd, p_pkey->sig.specific.v4.hashed_data_len, 2 );
  998.     gcry_md_write( hd, p_pkey->sig.specific.v4.hashed_data, i_hashed_data_len );
  1000.     gcry_md_putc( hd, 0x04 );
  1001.     gcry_md_putc( hd, 0xff );
  1003.     i_hashed_data_len += 6; /* hashed data + 6 bytes header */
  1005.     gcry_md_putc( hd, (i_hashed_data_len >> 24) & 0xff );
  1006.     gcry_md_putc( hd, (i_hashed_data_len >> 16) & 0xff );
  1007.     gcry_md_putc( hd, (i_hashed_data_len >> 8) & 0xff );
  1008.     gcry_md_putc( hd, (i_hashed_data_len) & 0xff );
  1010.     gcry_md_final( hd );
  1012.     uint8_t *p_tmp = gcry_md_read( hd, GCRY_MD_SHA1 );
  1014.     if( !p_tmp ||
  1015.         p_tmp[0] != p_pkey->sig.hash_verification[0] ||
  1016.         p_tmp[1] != p_pkey->sig.hash_verification[1] )
  1017.     {
  1018.         gcry_md_close( hd );
  1019.         return NULL;
  1020.     }
  1022.     uint8_t *p_hash = malloc( 20 );
  1023.     if( p_hash )
  1024.         memcpy( p_hash, p_tmp, 20 );
  1025.     gcry_md_close( hd );
  1026.     return p_hash;
  1027. }
  1030. /*****************************************************************************
  1031.  * Update_t functions
  1032.  *****************************************************************************/
  1034. /**
  1035.  * Create a new update VLC struct
  1036.  *
  1037.  * param p_this the calling vlc_object
  1038.  * return pointer to new update_t or NULL
  1039.  */
  1040. update_t *__update_New( vlc_object_t *p_this )
  1041. {
  1042.     update_t *p_update;
  1043.     assert( p_this );
  1045.     p_update = (update_t *)malloc( sizeof( update_t ) );
  1046.     if( !p_update ) return NULL;
  1048.     vlc_mutex_init( &p_update->lock );
  1050.     p_update->p_libvlc = p_this->p_libvlc;
  1052.     p_update->release.psz_url = NULL;
  1053.     p_update->release.psz_desc = NULL;
  1055.     p_update->p_download = NULL;
  1056.     p_update->p_check = NULL;
  1058.     p_update->p_pkey = NULL;
  1059.     vlc_gcrypt_init();
  1061.     return p_update;
  1062. }
  1064. /**
  1065.  * Delete an update_t struct
  1066.  *
  1067.  * param p_update update_t* pointer
  1068.  * return nothing
  1069.  */
  1070. void update_Delete( update_t *p_update )
  1071. {
  1072.     assert( p_update );
  1074.     if( p_update->p_check )
  1075.     {
  1076.         vlc_object_kill( p_update->p_check );
  1077.         vlc_thread_join( p_update->p_check );
  1078.         vlc_object_release( p_update->p_check );
  1079.     }
  1081.     if( p_update->p_download )
  1082.     {
  1083.         vlc_object_kill( p_update->p_download );
  1084.         vlc_thread_join( p_update->p_download );
  1085.         vlc_object_release( p_update->p_download );
  1086.     }
  1088.     vlc_mutex_destroy( &p_update->lock );
  1090.     free( p_update->release.psz_url );
  1091.     free( p_update->release.psz_desc );
  1092.     free( p_update->p_pkey );
  1094.     free( p_update );
  1095. }
  1097. /**
  1098.  * Empty the release struct
  1099.  *
  1100.  * param p_update update_t* pointer
  1101.  * return nothing
  1102.  */
  1103. static void EmptyRelease( update_t *p_update )
  1104. {
  1105.     p_update->release.i_major = 0;
  1106.     p_update->release.i_minor = 0;
  1107.     p_update->release.i_revision = 0;
  1109.     FREENULL( p_update->release.psz_url );
  1110.     FREENULL( p_update->release.psz_desc );
  1111. }
  1113. /**
  1114.  * Get the update file and parse it
  1115.  * p_update has to be locked when calling this function
  1116.  *
  1117.  * param p_update pointer to update struct
  1118.  * return true if the update is valid and authenticated
  1119.  */
  1120. static bool GetUpdateFile( update_t *p_update )
  1121. {
  1122.     stream_t *p_stream = NULL;
  1123.     int i_major = 0;
  1124.     int i_minor = 0;
  1125.     int i_revision = 0;
  1126.     unsigned char extra;
  1127.     char *psz_version_line = NULL;
  1129.     p_stream = stream_UrlNew( p_update->p_libvlc, UPDATE_VLC_STATUS_URL );
  1130.     if( !p_stream )
  1131.     {
  1132.         msg_Err( p_update->p_libvlc, "Failed to open %s for reading",
  1133.                  UPDATE_VLC_STATUS_URL );
  1134.         goto error;
  1135.     }
  1137.     /* Start reading the status file */
  1138.     if( !( psz_version_line = stream_ReadLine( p_stream ) ) )
  1139.     {
  1140.         msg_Err( p_update->p_libvlc, "Update file %s is corrupted : missing version",
  1141.                  UPDATE_VLC_STATUS_URL );
  1142.         goto error;
  1143.     }
  1145.     /* first line : version number */
  1146.     p_update->release.extra = 0;
  1147.     switch( sscanf( psz_version_line, "%i.%i.%i%c",
  1148.                     &i_major, &i_minor, &i_revision, &extra ) )
  1149.     {
  1150.         case 4:
  1151.             p_update->release.extra = extra;
  1152.         case 3:
  1153.             p_update->release.i_major = i_major;
  1154.             p_update->release.i_minor = i_minor;
  1155.             p_update->release.i_revision = i_revision;
  1156.             break;
  1157.         default:
  1158.             msg_Err( p_update->p_libvlc, "Update version false formated" );
  1159.             goto error;
  1160.     }
  1162.     /* second line : URL */
  1163.     if( !( p_update->release.psz_url = stream_ReadLine( p_stream ) ) )
  1164.     {
  1165.         msg_Err( p_update->p_libvlc, "Update file %s is corrupted : URL missing",
  1166.                  UPDATE_VLC_STATUS_URL );
  1167.         goto error;
  1168.     }
  1170.     /* Remaining data : description */
  1171.     int i_read = stream_Size( p_stream ) - stream_Tell( p_stream );
  1172.     if( i_read <= 0 )
  1173.     {
  1174.         msg_Err( p_update->p_libvlc,
  1175.                 "Update file %s is corrupted: description missing",
  1176.                 UPDATE_VLC_STATUS_URL );
  1177.         goto error;
  1178.     }
  1180.     p_update->release.psz_desc = (char*) malloc( i_read + 1 );
  1181.     if( !p_update->release.psz_desc )
  1182.         goto error;
  1184.     if( stream_Read( p_stream, p_update->release.psz_desc, i_read ) != i_read )
  1185.     {
  1186.         msg_Err( p_update->p_libvlc, "Couldn't download update file %s",
  1187.                 UPDATE_VLC_STATUS_URL );
  1188.         goto error;
  1189.     }
  1190.     p_update->release.psz_desc[i_read] = '';
  1192.     stream_Delete( p_stream );
  1193.     p_stream = NULL;
  1195.     /* Now that we know the status is valid, we must download its signature
  1196.      * to authenticate it */
  1197.     signature_packet_t sign;
  1198.     if( download_signature( VLC_OBJECT( p_update->p_libvlc ), &sign,
  1199.             UPDATE_VLC_STATUS_URL ) != VLC_SUCCESS )
  1200.     {
  1201.         msg_Err( p_update->p_libvlc, "Couldn't download signature of status file" );
  1202.         goto error;
  1203.     }
  1205.     if( sign.type != BINARY_SIGNATURE && sign.type != TEXT_SIGNATURE )
  1206.     {
  1207.         msg_Err( p_update->p_libvlc, "Invalid signature type" );
  1208.         goto error;
  1209.     }
  1211.     p_update->p_pkey = (public_key_t*)malloc( sizeof( public_key_t ) );
  1212.     if( !p_update->p_pkey )
  1213.         goto error;
  1215.     if( parse_public_key( videolan_public_key, sizeof( videolan_public_key ),
  1216.                         p_update->p_pkey, NULL ) != VLC_SUCCESS )
  1217.     {
  1218.         msg_Err( p_update->p_libvlc, "Couldn't parse embedded public key, something went really wrong..." );
  1219.         FREENULL( p_update->p_pkey );
  1220.         goto error;
  1221.     }
  1223.     memcpy( p_update->p_pkey->longid, videolan_public_key_longid, 8 );
  1225.     if( memcmp( sign.issuer_longid, p_update->p_pkey->longid , 8 ) != 0 )
  1226.     {
  1227.         msg_Dbg( p_update->p_libvlc, "Need to download the GPG key" );
  1228.         public_key_t *p_new_pkey = download_key(
  1229.                 VLC_OBJECT(p_update->p_libvlc),
  1230.                 sign.issuer_longid, videolan_public_key_longid );
  1231.         if( !p_new_pkey )
  1232.         {
  1233.             msg_Err( p_update->p_libvlc, "Couldn't download GPG key" );
  1234.             FREENULL( p_update->p_pkey );
  1235.             goto error;
  1236.         }
  1238.         uint8_t *p_hash = key_sign_hash( p_new_pkey );
  1239.         if( !p_hash )
  1240.         {
  1241.             msg_Err( p_update->p_libvlc, "Failed to hash signature" );
  1242.             free( p_new_pkey );
  1243.             FREENULL( p_update->p_pkey );
  1244.             goto error;
  1245.         }
  1247.         if( verify_signature( p_new_pkey->sig.r, p_new_pkey->sig.s,
  1248.                     &p_update->p_pkey->key, p_hash ) == VLC_SUCCESS )
  1249.         {
  1250.             free( p_hash );
  1251.             msg_Info( p_update->p_libvlc, "Key authenticated" );
  1252.             free( p_update->p_pkey );
  1253.             p_update->p_pkey = p_new_pkey;
  1254.         }
  1255.         else
  1256.         {
  1257.             free( p_hash );
  1258.             msg_Err( p_update->p_libvlc, "Key signature invalid !n" );
  1259.             goto error;
  1260.         }
  1261.     }
  1263.     gcry_md_hd_t hd;
  1264.     if( gcry_md_open( &hd, GCRY_MD_SHA1, 0 ) )
  1265.         goto error_hd;
  1267.     gcry_md_write( hd, psz_version_line, strlen( psz_version_line ) );
  1268.     FREENULL( psz_version_line );
  1269.     if( sign.type == TEXT_SIGNATURE )
  1270.         gcry_md_putc( hd, 'r' );
  1271.     gcry_md_putc( hd, 'n' );
  1272.     gcry_md_write( hd, p_update->release.psz_url,
  1273.                         strlen( p_update->release.psz_url ) );
  1274.     if( sign.type == TEXT_SIGNATURE )
  1275.         gcry_md_putc( hd, 'r' );
  1276.     gcry_md_putc( hd, 'n' );
  1278.     char *psz_desc = p_update->release.psz_desc;
  1279.     while( *psz_desc )
  1280.     {
  1281.         size_t i_len = strcspn( psz_desc, "rn" );
  1282.         if( !i_len )
  1283.             break;
  1285.         gcry_md_write( hd, psz_desc, i_len );
  1286.         if( sign.type == TEXT_SIGNATURE )
  1287.             gcry_md_putc( hd, 'r' );
  1288.         gcry_md_putc( hd, 'n' );
  1290.         psz_desc += i_len;
  1291.         while( *psz_desc == 'r' || *psz_desc == 'n' )
  1292.             psz_desc++;
  1293.     }
  1295.     if( sign.version == 3 )
  1296.     {
  1297.         gcry_md_putc( hd, sign.type );
  1298.         gcry_md_write( hd, &sign.specific.v3.timestamp, 4 );
  1299.     }
  1300.     else if( sign.version == 4 )
  1301.     {
  1302.         gcry_md_putc( hd, sign.version );
  1303.         gcry_md_putc( hd, sign.type );
  1304.         gcry_md_putc( hd, sign.public_key_algo );
  1305.         gcry_md_putc( hd, sign.digest_algo );
  1306.         gcry_md_write( hd, sign.specific.v4.hashed_data_len, 2 );
  1307.         size_t i_len = scalar_number( sign.specific.v4.hashed_data_len, 2 );
  1308.         gcry_md_write( hd, sign.specific.v4.hashed_data, i_len );
  1309.         gcry_md_putc( hd, 0x04 );
  1310.         gcry_md_putc( hd, 0xFF );
  1312.         i_len += 6; /* hashed data + 6 bytes header */
  1314.         gcry_md_putc( hd, (i_len >> 24) & 0xff );
  1315.         gcry_md_putc( hd, (i_len >> 16) & 0xff );
  1316.         gcry_md_putc( hd, (i_len >> 8) & 0xff );
  1317.         gcry_md_putc( hd, (i_len) & 0xff );
  1318.     }
  1319.     else
  1320.     {   /* RFC 4880 only tells about versions 3 and 4 */
  1321.         msg_Warn( p_update->p_libvlc, "Invalid signature version %d",
  1322.                 sign.version);
  1323.         goto error_hd;
  1324.     }
  1326.     gcry_md_final( hd );
  1328.     uint8_t *p_hash = gcry_md_read( hd, GCRY_MD_SHA1 );
  1330.     if( p_hash[0] != sign.hash_verification[0] ||
  1331.         p_hash[1] != sign.hash_verification[1] )
  1332.     {
  1333.         msg_Warn( p_update->p_libvlc, "Bad SHA1 hash for status file" );
  1334.         goto error_hd;
  1335.     }
  1337.     if( verify_signature( sign.r, sign.s, &p_update->p_pkey->key, p_hash )
  1338.             != VLC_SUCCESS )
  1339.     {
  1340.         msg_Err( p_update->p_libvlc, "BAD SIGNATURE for status file" );
  1341.         goto error_hd;
  1342.     }
  1343.     else
  1344.     {
  1345.         msg_Info( p_update->p_libvlc, "Status file authenticated" );
  1346.         gcry_md_close( hd );
  1347.         return true;
  1348.     }
  1350. error_hd:
  1351.     gcry_md_close( hd );
  1352. error:
  1353.     if( p_stream )
  1354.         stream_Delete( p_stream );
  1355.     free( psz_version_line );
  1356.     return false;
  1357. }
  1359. static void* update_CheckReal( vlc_object_t *p_this );
  1361. /**
  1362.  * Check for updates
  1363.  *
  1364.  * param p_update pointer to update struct
  1365.  * param pf_callback pointer to a function to call when the update_check is finished
  1366.  * param p_data pointer to some datas to give to the callback
  1367.  * returns nothing
  1368.  */
  1369. void update_Check( update_t *p_update, void (*pf_callback)( void*, bool ), void *p_data )
  1370. {
  1371.     assert( p_update );
  1373.     // If the object already exist, destroy it
  1374.     if( p_update->p_check )
  1375.     {
  1376.         vlc_object_kill( p_update->p_check );
  1377.         vlc_thread_join( p_update->p_check );
  1378.         vlc_object_release( p_update->p_check );
  1379.     }
  1381.     update_check_thread_t *p_uct =
  1382.         vlc_custom_create( p_update->p_libvlc, sizeof( *p_uct ),
  1383.                            VLC_OBJECT_GENERIC, "update check" );
  1384.     if( !p_uct ) return;
  1386.     p_uct->p_update = p_update;
  1387.     p_update->p_check = p_uct;
  1388.     p_uct->pf_callback = pf_callback;
  1389.     p_uct->p_data = p_data;
  1391.     vlc_thread_create( p_uct, "check for update", update_CheckReal,
  1392.                        VLC_THREAD_PRIORITY_LOW );
  1393. }
  1395. void* update_CheckReal( vlc_object_t* p_this )
  1396. {
  1397.     update_check_thread_t *p_uct = (update_check_thread_t *)p_this;
  1398.     bool b_ret;
  1399.     int canc;
  1401.     canc = vlc_savecancel ();
  1402.     vlc_mutex_lock( &p_uct->p_update->lock );
  1404.     EmptyRelease( p_uct->p_update );
  1405.     b_ret = GetUpdateFile( p_uct->p_update );
  1406.     vlc_mutex_unlock( &p_uct->p_update->lock );
  1408.     if( p_uct->pf_callback )
  1409.         (p_uct->pf_callback)( p_uct->p_data, b_ret );
  1411.     vlc_restorecancel (canc);
  1412.     return NULL;
  1413. }
  1415. /**
  1416.  * Compare a given release's version number to the current VLC's one
  1417.  *
  1418.  * param p_update structure
  1419.  * return true if we have to upgrade to the given version to be up to date
  1420.  */
  1421. static bool is_strictly_greater( int * a, int * b, int n)
  1422. {
  1423.     if( n <= 0 ) return false;
  1424.     if(a[0] > b[0] ) return true;
  1425.     if(a[0] == b[0] ) return is_strictly_greater( a+1, b+1, n-1 );
  1426.     /* a[0] < b[0] */ return false;
  1427. }
  1429. bool update_NeedUpgrade( update_t *p_update )
  1430. {
  1431.     assert( p_update );
  1433.     int current_version[] = {
  1434.         *PACKAGE_VERSION_MAJOR - '0',
  1435.         *PACKAGE_VERSION_MINOR - '0',
  1436.         *PACKAGE_VERSION_REVISION - '0',
  1437.         /* extra string of development versions is "-git", "-rc" ..
  1438.          * so make sure version a.b.c is newer than a.b.c-XXX */
  1439.         (*PACKAGE_VERSION_EXTRA == '-') ? -1 : *PACKAGE_VERSION_EXTRA
  1440.     };
  1441.     int latest_version[] = {
  1442.         p_update->release.i_major,
  1443.         p_update->release.i_minor,
  1444.         p_update->release.i_revision,
  1445.         p_update->release.extra
  1446.     };
  1448.     return is_strictly_greater( latest_version, current_version, 4 );
  1449. }
  1451. /**
  1452.  * Convert a long int size in bytes to a string
  1453.  *
  1454.  * param l_size the size in bytes
  1455.  * return the size as a string
  1456.  */
  1457. static char *size_str( long int l_size )
  1458. {
  1459.     char *psz_tmp = NULL;
  1460.     int i_retval = 0;
  1461.     if( l_size >> 30 )
  1462.         i_retval = asprintf( &psz_tmp, _("%.1f GB"), (float)l_size/(1<<30) );
  1463.     else if( l_size >> 20 )
  1464.         i_retval = asprintf( &psz_tmp, _("%.1f MB"), (float)l_size/(1<<20) );
  1465.     else if( l_size >> 10 )
  1466.         i_retval = asprintf( &psz_tmp, _("%.1f kB"), (float)l_size/(1<<10) );
  1467.     else
  1468.         i_retval = asprintf( &psz_tmp, _("%ld B"), l_size );
  1470.     return i_retval == -1 ? NULL : psz_tmp;
  1471. }
  1473. void update_WaitDownload( update_t *p_update )
  1474. {
  1475.     if( p_update->p_download )
  1476.     {
  1477.         vlc_thread_join( p_update->p_download );
  1478.         vlc_object_release( p_update->p_download );
  1479.         p_update->p_download = NULL;
  1480.     }
  1481. }
  1483. static void* update_DownloadReal( vlc_object_t *p_this );
  1485. /**
  1486.  * Download the file given in the update_t
  1487.  *
  1488.  * param p_update structure
  1489.  * param dir to store the download file
  1490.  * return nothing
  1491.  */
  1492. void update_Download( update_t *p_update, const char *psz_destdir )
  1493. {
  1494.     assert( p_update );
  1496.     // If the object already exist, destroy it
  1497.     if( p_update->p_download )
  1498.     {
  1499.         vlc_object_kill( p_update->p_download );
  1500.         vlc_thread_join( p_update->p_download );
  1501.         vlc_object_release( p_update->p_download );
  1502.     }
  1504.     update_download_thread_t *p_udt =
  1505.         vlc_custom_create( p_update->p_libvlc, sizeof( *p_udt ),
  1506.                            VLC_OBJECT_GENERIC, "update download" );
  1507.     if( !p_udt )
  1508.         return;
  1510.     p_udt->p_update = p_update;
  1511.     p_update->p_download = p_udt;
  1512.     p_udt->psz_destdir = psz_destdir ? strdup( psz_destdir ) : NULL;
  1514.     vlc_thread_create( p_udt, "download update", update_DownloadReal,
  1515.                        VLC_THREAD_PRIORITY_LOW );
  1516. }
  1518. static void* update_DownloadReal( vlc_object_t *p_this )
  1519. {
  1520.     update_download_thread_t *p_udt = (update_download_thread_t *)p_this;
  1521.     dialog_progress_bar_t *p_progress = NULL;
  1522.     long int l_size;
  1523.     long int l_downloaded = 0;
  1524.     float f_progress;
  1525.     char *psz_status = NULL;
  1526.     char *psz_downloaded = NULL;
  1527.     char *psz_size = NULL;
  1528.     char *psz_destfile = NULL;
  1529.     char *psz_tmpdestfile = NULL;
  1531.     FILE *p_file = NULL;
  1532.     stream_t *p_stream = NULL;
  1533.     void* p_buffer = NULL;
  1534.     int i_read;
  1535.     int canc;
  1537.     update_t *p_update = p_udt->p_update;
  1538.     char *psz_destdir = p_udt->psz_destdir;
  1540.     msg_Dbg( p_udt, "Opening Stream '%s'", p_update->release.psz_url );
  1541.     canc = vlc_savecancel ();
  1543.     /* Open the stream */
  1544.     p_stream = stream_UrlNew( p_udt, p_update->release.psz_url );
  1545.     if( !p_stream )
  1546.     {
  1547.         msg_Err( p_udt, "Failed to open %s for reading", p_update->release.psz_url );
  1548.         goto end;
  1549.     }
  1551.     /* Get the stream size */
  1552.     l_size = stream_Size( p_stream );
  1554.     /* Get the file name and open it*/
  1555.     psz_tmpdestfile = strrchr( p_update->release.psz_url, '/' );
  1556.     if( !psz_tmpdestfile )
  1557.     {
  1558.         msg_Err( p_udt, "The URL %s is badly formated",
  1559.                  p_update->release.psz_url );
  1560.         goto end;
  1561.     }
  1562.     psz_tmpdestfile++;
  1564.     if( asprintf( &psz_destfile, "%s%s", psz_destdir, psz_tmpdestfile ) == -1 )
  1565.         goto end;
  1567.     p_file = utf8_fopen( psz_destfile, "w" );
  1568.     if( !p_file )
  1569.     {
  1570.         msg_Err( p_udt, "Failed to open %s for writing", psz_destfile );
  1571.         dialog_FatalWait( p_udt, _("Saving file failed"),
  1572.             _("Failed to open "%s" for writing"),
  1573.              psz_destfile );
  1574.         goto end;
  1575.     }
  1577.     /* Create a buffer and fill it with the downloaded file */
  1578.     p_buffer = (void *)malloc( 1 << 10 );
  1579.     if( !p_buffer )
  1580.     {
  1581.         msg_Err( p_udt, "Can't malloc (1 << 10) bytes! download cancelled." );
  1582.         goto end;
  1583.     }
  1585.     msg_Dbg( p_udt, "Downloading Stream '%s'", p_update->release.psz_url );
  1587.     psz_size = size_str( l_size );
  1588.     if( asprintf( &psz_status, _("%snDownloading... %s/%s %.1f%% done"),
  1589.         p_update->release.psz_url, "0.0", psz_size, 0.0 ) != -1 )
  1590.     {
  1591.         p_progress = dialog_ProgressCreate( p_udt, _( "Downloading ..."),
  1592.                                             psz_status, _("Cancel") );
  1593.         free( psz_status );
  1594.     }
  1596.     while( vlc_object_alive( p_udt ) &&
  1597.            ( i_read = stream_Read( p_stream, p_buffer, 1 << 10 ) ) &&
  1598.            !dialog_ProgressCancelled( p_progress ) )
  1599.     {
  1600.         if( fwrite( p_buffer, i_read, 1, p_file ) < 1 )
  1601.         {
  1602.             msg_Err( p_udt, "Failed to write into %s", psz_destfile );
  1603.             break;
  1604.         }
  1606.         l_downloaded += i_read;
  1607.         psz_downloaded = size_str( l_downloaded );
  1608.         f_progress = (float)l_downloaded/(float)l_size;
  1610.         if( asprintf( &psz_status, _( "%snDownloading... %s/%s - %.1f%% done" ),
  1611.                       p_update->release.psz_url, psz_downloaded, psz_size,
  1612.                       f_progress*100 ) != -1 )
  1613.         {
  1614.             dialog_ProgressSet( p_progress, psz_status, f_progress );
  1615.             free( psz_status );
  1616.         }
  1617.         free( psz_downloaded );
  1618.     }
  1620.     /* Finish the progress bar or delete the file if the user had canceled */
  1621.     fclose( p_file );
  1622.     p_file = NULL;
  1624.     if( vlc_object_alive( p_udt ) &&
  1625.         !dialog_ProgressCancelled( p_progress ) )
  1626.     {
  1627.         if( asprintf( &psz_status, _("%snDone %s (100.0%%)"),
  1628.             p_update->release.psz_url, psz_size ) != -1 )
  1629.         {
  1630.             dialog_ProgressDestroy( p_progress );
  1631.             p_progress = NULL;
  1632.             free( psz_status );
  1633.         }
  1634.     }
  1635.     else
  1636.     {
  1637.         utf8_unlink( psz_destfile );
  1638.         goto end;
  1639.     }
  1641.     signature_packet_t sign;
  1642.     if( download_signature( VLC_OBJECT( p_udt ), &sign,
  1643.             p_update->release.psz_url ) != VLC_SUCCESS )
  1644.     {
  1645.         utf8_unlink( psz_destfile );
  1647.         dialog_FatalWait( p_udt, _("File could not be verified"),
  1648.             _("It was not possible to download a cryptographic signature for "
  1649.               "the downloaded file "%s". Thus, it was deleted."),
  1650.             psz_destfile );
  1651.         msg_Err( p_udt, "Couldn't download signature of downloaded file" );
  1652.         goto end;
  1653.     }
  1655.     if( memcmp( sign.issuer_longid, p_update->p_pkey->longid, 8 ) )
  1656.     {
  1657.         utf8_unlink( psz_destfile );
  1658.         msg_Err( p_udt, "Invalid signature issuer" );
  1659.         dialog_FatalWait( p_udt, _("Invalid signature"),
  1660.             _("The cryptographic signature for the downloaded file "%s" was "
  1661.               "invalid and could not be used to securely verify it. Thus, the "
  1662.               "file was deleted."),
  1663.             psz_destfile );
  1664.         goto end;
  1665.     }
  1667.     if( sign.type != BINARY_SIGNATURE )
  1668.     {
  1669.         utf8_unlink( psz_destfile );
  1670.         msg_Err( p_udt, "Invalid signature type" );
  1671.         dialog_FatalWait( p_udt, _("Invalid signature"),
  1672.             _("The cryptographic signature for the downloaded file "%s" was "
  1673.               "invalid and could not be used to securely verify it. Thus, the "
  1674.               "file was deleted."),
  1675.             psz_destfile );
  1676.         goto end;
  1677.     }
  1679.     uint8_t *p_hash = hash_sha1_from_file( psz_destfile, &sign );
  1680.     if( !p_hash )
  1681.     {
  1682.         msg_Err( p_udt, "Unable to hash %s", psz_destfile );
  1683.         utf8_unlink( psz_destfile );
  1684.         dialog_FatalWait( p_udt, _("File not verifiable"),
  1685.             _("It was not possible to securely verify the downloaded file"
  1686.               " "%s". Thus, it was deleted."),
  1687.             psz_destfile );
  1689.         goto end;
  1690.     }
  1692.     if( p_hash[0] != sign.hash_verification[0] ||
  1693.         p_hash[1] != sign.hash_verification[1] )
  1694.     {
  1695.         utf8_unlink( psz_destfile );
  1696.         dialog_FatalWait( p_udt, _("File corrupted"),
  1697.             _("Downloaded file "%s" was corrupted. Thus, it was deleted."),
  1698.              psz_destfile );
  1699.         msg_Err( p_udt, "Bad SHA1 hash for %s", psz_destfile );
  1700.         free( p_hash );
  1701.         goto end;
  1702.     }
  1704.     if( verify_signature( sign.r, sign.s, &p_update->p_pkey->key, p_hash )
  1705.             != VLC_SUCCESS )
  1706.     {
  1707.         utf8_unlink( psz_destfile );
  1708.         dialog_FatalWait( p_udt, _("File corrupted"),
  1709.             _("Downloaded file "%s" was corrupted. Thus, it was deleted."),
  1710.              psz_destfile );
  1711.         msg_Err( p_udt, "BAD SIGNATURE for %s", psz_destfile );
  1712.         free( p_hash );
  1713.         goto end;
  1714.     }
  1716.     msg_Info( p_udt, "%s authenticated", psz_destfile );
  1717.     free( p_hash );
  1719. end:
  1720.     if( p_progress )
  1721.         dialog_ProgressDestroy( p_progress );
  1722.     if( p_stream )
  1723.         stream_Delete( p_stream );
  1724.     if( p_file )
  1725.         fclose( p_file );
  1727.     free( psz_destdir );
  1728.     free( psz_destfile );
  1729.     free( p_buffer );
  1730.     free( psz_size );
  1732.     vlc_restorecancel( canc );
  1733.     return NULL;
  1734. }
  1736. update_release_t *update_GetRelease( update_t *p_update )
  1737. {
  1738.     return &p_update->release;
  1739. }
  1741. #else
  1742. update_t *__update_New( vlc_object_t *p_this )
  1743. {
  1744.     (void)p_this;
  1745.     return NULL;
  1746. }
  1748. void update_Delete( update_t *p_update )
  1749. {
  1750.     (void)p_update;
  1751. }
  1753. void update_Check( update_t *p_update, void (*pf_callback)( void*, bool ),
  1754.                    void *p_data )
  1755. {
  1756.     (void)p_update; (void)pf_callback; (void)p_data;
  1757. }
  1759. bool update_NeedUpgrade( update_t *p_update )
  1760. {
  1761.     (void)p_update;
  1762.     return false;
  1763. }
  1765. void update_WaitDownload( update_t *p_update )
  1766. {
  1767.     (void)p_update;
  1768. }
  1770. void update_Download( update_t *p_update, const char *psz_destdir )
  1771. {
  1772.     (void)p_update; (void)psz_destdir;
  1773. }
  1775. update_release_t *update_GetRelease( update_t *p_update )
  1776. {
  1777.     (void)p_update;
  1778.     return NULL;
  1779. }
  1780. #endif