/*
* reads the RSA private key from file
* the file must be conform to PCKS#1, PEM-encoded, unencrypted
*/
int RSAKey::readPEM( )
{
string s_header_tag( "-----BEGIN RSA PRIVATE KEY-----" );
string s_footer_tag( "-----END RSA PRIVATE KEY-----" );
string s_line;
string s_data_b64;
unsigned char *ps_data_der = NULL;
size_t length;
/* open key file */
ifstream file( this->s_path.c_str(), ios::in );
if( ! file.is_open() )
{
msg_Err( this->p_demux, "could not open private key file" );
goto error;
}
/* check for header tag */
if( ! getline( file, s_line ) )
{
msg_Err( this->p_demux, "could not read private key file" );
goto error;
}
if( s_line.compare( s_header_tag ) )
{
msg_Err( this->p_demux, "unexpected header tag found in private key file" );
goto error;
}
/* read file until footer tag is found */
while( getline( file, s_line ) )
{
if( ! s_line.compare( s_footer_tag ) )
break;
try
{
s_data_b64.append( s_line );
}
catch( ... )
{
msg_Err( this->p_demux, "error while handling string" );
goto error;
}
}
if( ! file )
{
msg_Err( this->p_demux, "error while reading private key file; footer tag may be missing" );
goto error;
}
/* decode data from Base64 */
if( ! ( length = vlc_b64_decode_binary( &ps_data_der, s_data_b64.c_str() ) ) )
{
msg_Err( this->p_demux, "could not decode from Base64" );
goto error;
}
/* extract key S-expression from DER-encoded data */
if( this->readDER( ps_data_der, length ) )
goto error;
/* clear data */
free( ps_data_der );
return VLC_SUCCESS;
error:
free( ps_data_der );
return VLC_EGENERIC;
}
static vlc_keystore_entry*
kwallet_read_password_list( vlc_keystore* p_keystore, char* psz_entry_name,
unsigned int* pi_count )
{
vlc_keystore_sys* p_sys = p_keystore->p_sys;
DBusMessage* msg = NULL;
DBusMessage* repmsg = NULL;
DBusMessageIter args;
DBusMessageIter sub_iter;
DBusMessageIter dict_iter;
DBusMessageIter var_iter;
vlc_keystore_entry* p_entries = NULL;
size_t i_size;
uint8_t* p_secret_decoded;
char* p_reply;
char* p_secret;
int i = 0;
/* init */
*pi_count = 0;
if ( !( msg = vlc_dbus_new_method( p_keystore, "readPasswordList" ) ) )
{
msg_Err( p_keystore, "kwallet_read_password_list : vlc_dbus_new_method failed" );
goto error;
}
/* argument init */
dbus_message_iter_init_append( msg, &args );
if ( !dbus_message_iter_append_basic( &args, DBUS_TYPE_INT32, &p_sys->i_handle ) ||
!dbus_message_iter_append_basic( &args, DBUS_TYPE_STRING, &psz_folder ) ||
!dbus_message_iter_append_basic( &args, DBUS_TYPE_STRING, &psz_entry_name ) ||
!dbus_message_iter_append_basic( &args, DBUS_TYPE_STRING, &p_sys->psz_app_id ) )
goto error;
/* sending message */
if ( !( repmsg = vlc_dbus_send_message( p_keystore, msg ) ) )
{
msg_Err( p_keystore, "kwallet_read_password_list : vlc_dbus_send_message failed" );
goto error;
}
/* handling reply */
if ( !dbus_message_iter_init( repmsg, &args ) )
{
msg_Err( p_keystore, "kwallet_read_password_list : Message has no arguments" );
goto error;
}
else if ( dbus_message_iter_get_arg_type(&args) != DBUS_TYPE_ARRAY )
{
msg_Err( p_keystore, "kwallet_read_password_list : Wrong reply type" );
goto error;
}
else
{
/* calculating p_entries's size */
dbus_message_iter_recurse( &args, &sub_iter );
do
{
if ( dbus_message_iter_get_arg_type( &sub_iter ) != DBUS_TYPE_DICT_ENTRY )
continue;
dbus_message_iter_recurse( &sub_iter, &dict_iter );
if ( dbus_message_iter_get_arg_type( &dict_iter ) != DBUS_TYPE_STRING )
continue;
dbus_message_iter_next(&dict_iter);
if ( dbus_message_iter_get_arg_type( &dict_iter ) != DBUS_TYPE_VARIANT )
continue;
++( *pi_count );
} while ( dbus_message_iter_next( &sub_iter ) );
if ( *pi_count == 0 )
goto error;
if ( !( p_entries = calloc( *pi_count, sizeof( vlc_keystore_entry ) ) ) )
goto error;
dbus_message_iter_init( repmsg, &args );
/* recurse into the reply array */
dbus_message_iter_recurse( &args, &sub_iter );
do
{
if ( dbus_message_iter_get_arg_type( &sub_iter ) != DBUS_TYPE_DICT_ENTRY )
{
msg_Err( p_keystore, "Wrong type not DBUS_TYPE_DICT_ENTRY" );
continue;
}
/* recurse into the dict-entry in the array */
dbus_message_iter_recurse( &sub_iter, &dict_iter );
if ( dbus_message_iter_get_arg_type( &dict_iter ) != DBUS_TYPE_STRING )
{
msg_Err( p_keystore, "First type of Dict-Entry is not a string" );
continue;
}
dbus_message_iter_get_basic( &dict_iter, &p_reply );
dbus_message_iter_next(&dict_iter);
if ( dbus_message_iter_get_arg_type( &dict_iter ) != DBUS_TYPE_VARIANT )
{
msg_Err( p_keystore, "Second type of Dict-Entry is not a variant" );
continue;
}
/* recurse into the variant in the dict-entry */
dbus_message_iter_recurse( &dict_iter, &var_iter );
dbus_message_iter_get_basic( &var_iter, &p_secret );
i_size = vlc_b64_decode_binary( &p_secret_decoded, p_secret);
if ( key2values( p_reply, &p_entries[i] ) )
goto error;
if ( ( vlc_keystore_entry_set_secret( &p_entries[i],
p_secret_decoded,
i_size ) ) )
goto error;
free(p_secret_decoded);
i += 1;
} while ( dbus_message_iter_next( &sub_iter ) );
}
dbus_message_unref( msg );
dbus_message_unref( repmsg );
return p_entries;
error:
*pi_count = 0;
vlc_keystore_release_entries( p_entries, i );
if ( msg )
dbus_message_unref( msg );
if ( repmsg )
dbus_message_unref( repmsg );
return NULL;
}
/* decrypts the RSA encrypted text read from the XML file,
* and saves the AES key and the other needed info
* uses libgcrypt for decryption
*/
int AESKey::decryptRSA( string s_cipher_text_b64 )
{
RSAKey rsa_key( this->p_demux );
unsigned char *ps_cipher_text = NULL;
unsigned char *ps_plain_text = NULL;
gcry_mpi_t cipher_text_mpi = NULL;
gcry_sexp_t cipher_text_sexp = NULL;
gcry_sexp_t plain_text_sexp = NULL;
gcry_mpi_t plain_text_mpi = NULL;
gcry_sexp_t tmp_sexp = NULL;
gcry_error_t err;
size_t length;
int i_ret = VLC_EGENERIC;
/* get RSA private key file path */
if( rsa_key.setPath() )
goto end;
/* read private key from file */
if( rsa_key.readPEM() )
goto end;
/* remove spaces and newlines from encoded cipher text
* (usually added for indentation in XML files)
* */
try
{
s_cipher_text_b64.erase( remove_if( s_cipher_text_b64.begin(), s_cipher_text_b64.end(), static_cast<int(*)(int)>(isspace) ),
s_cipher_text_b64.end() );
}
catch( ... )
{
msg_Err( this->p_demux, "error while handling string" );
goto end;
}
/* decode cipher from BASE64 to binary */
if( ! ( length = vlc_b64_decode_binary( &ps_cipher_text, s_cipher_text_b64.c_str() ) ) )
{
msg_Err( this->p_demux, "could not decode cipher from Base64" );
goto end;
}
/* initialize libgcrypt */
vlc_gcrypt_init ();
/* create S-expression for ciphertext */
if( ( err = gcry_mpi_scan( &cipher_text_mpi, GCRYMPI_FMT_USG, ps_cipher_text, 256, NULL ) ) )
{
msg_Err( this->p_demux, "could not scan MPI from cipher text: %s", gcry_strerror( err ) );
goto end;
}
if( ( err = gcry_sexp_build( &cipher_text_sexp, NULL, "(enc-val(flags oaep)(rsa(a %m)))", cipher_text_mpi ) ) )
{
msg_Err( this->p_demux, "could not build S-expression for cipher text: %s", gcry_strerror( err ) );
goto end;
}
/* decrypt */
if( ( err = gcry_pk_decrypt( &plain_text_sexp, cipher_text_sexp, rsa_key.priv_key ) ) )
{
msg_Err( this->p_demux, "error while decrypting RSA encrypted info: %s", gcry_strerror( err ) );
goto end;
}
/* extract plain-text from S-expression */
if( ! ( tmp_sexp = gcry_sexp_find_token( plain_text_sexp, "value", 0 ) ) )
/* when using padding flags, the decrypted S-expression is of the form
* "(value <plaintext>)", where <plaintext> is an MPI */
{
msg_Err( this->p_demux, "decrypted text is in an unexpected form; decryption may have failed" );
goto end;
}
/* we could have used the gcry_sexp_nth_data to get the data directly,
* but as that function is newly introduced (libgcrypt v1.6),
* we prefer compatibility, even though that means passing the data through an MPI first */
if( ! ( plain_text_mpi = gcry_sexp_nth_mpi( tmp_sexp, 1, GCRYMPI_FMT_USG ) ) )
{
msg_Err( this->p_demux, "could not extract MPI from decrypted S-expression" );
goto end;
}
if( ( err = gcry_mpi_aprint( GCRYMPI_FMT_USG, &ps_plain_text, &length, plain_text_mpi ) ) )
{
msg_Err( this->p_demux, "error while extracting plain text from MPI: %s", gcry_strerror( err ) );
goto end;
}
/* interpret the plaintext data */
switch( length )
{
case 138: /* SMPTE DCP */
if( this->extractInfo( ps_plain_text, true ) )
goto end;
break;
case 134: /* Interop DCP */
if( this->extractInfo( ps_plain_text, false ) )
goto end;
break;
case -1:
msg_Err( this->p_demux, "could not decrypt" );
goto end;
default:
msg_Err( this->p_demux, "CipherValue field length does not match SMPTE nor Interop standards" );
goto end;
}
i_ret = VLC_SUCCESS;
end:
free( ps_cipher_text );
gcry_mpi_release( cipher_text_mpi );
gcry_sexp_release( cipher_text_sexp );
gcry_sexp_release( plain_text_sexp );
gcry_mpi_release( plain_text_mpi );
gcry_sexp_release( tmp_sexp );
gcry_free( ps_plain_text );
return i_ret;
}
void vorbis_ParseComment( es_format_t *p_fmt, vlc_meta_t **pp_meta,
const uint8_t *p_data, int i_data,
int *i_attachments, input_attachment_t ***attachments,
int *i_cover_score, int *i_cover_idx,
int *i_seekpoint, seekpoint_t ***ppp_seekpoint,
float (* ppf_replay_gain)[AUDIO_REPLAY_GAIN_MAX],
float (* ppf_replay_peak)[AUDIO_REPLAY_GAIN_MAX] )
{
int n;
int i_comment;
if( i_data < 8 )
return;
n = GetDWLE(p_data); RM(4);
if( n < 0 || n > i_data )
return;
#if 0
if( n > 0 )
{
/* TODO report vendor string ? */
char *psz_vendor = psz_vendor = strndup( p_data, n );
free( psz_vendor );
}
#endif
RM(n);
if( i_data < 4 )
return;
i_comment = GetDWLE(p_data); RM(4);
if( i_comment <= 0 )
return;
/* */
vlc_meta_t *p_meta = *pp_meta;
if( !p_meta )
*pp_meta = p_meta = vlc_meta_New();
if( !p_meta )
return;
/* */
bool hasTitle = false;
bool hasArtist = false;
bool hasGenre = false;
bool hasCopyright = false;
bool hasAlbum = false;
bool hasTrackNum = false;
bool hasDescription = false;
bool hasRating = false;
bool hasDate = false;
bool hasLanguage = false;
bool hasPublisher = false;
bool hasEncodedBy = false;
bool hasTrackTotal = false;
chapters_array_t chapters_array = { 0, NULL };
for( ; i_comment > 0; i_comment-- )
{
char *psz_comment;
if( i_data < 4 )
break;
n = GetDWLE(p_data); RM(4);
if( n > i_data )
break;
if( n <= 0 )
continue;
psz_comment = strndup( (const char*)p_data, n );
RM(n);
EnsureUTF8( psz_comment );
#define IF_EXTRACT(txt,var) \
if( !strncasecmp(psz_comment, txt, strlen(txt)) ) \
{ \
const char *oldval = vlc_meta_Get( p_meta, vlc_meta_ ## var ); \
if( oldval && has##var) \
{ \
char * newval; \
if( asprintf( &newval, "%s,%s", oldval, &psz_comment[strlen(txt)] ) == -1 ) \
newval = NULL; \
vlc_meta_Set( p_meta, vlc_meta_ ## var, newval ); \
free( newval ); \
} \
else \
vlc_meta_Set( p_meta, vlc_meta_ ## var, &psz_comment[strlen(txt)] ); \
has##var = true; \
}
#define IF_EXTRACT_ONCE(txt,var) \
if( !strncasecmp(psz_comment, txt, strlen(txt)) && !has##var ) \
{ \
vlc_meta_Set( p_meta, vlc_meta_ ## var, &psz_comment[strlen(txt)] ); \
has##var = true; \
}
#define IF_EXTRACT_FMT(txt,var,fmt,target) \
IF_EXTRACT(txt,var)\
if( fmt && !strncasecmp(psz_comment, txt, strlen(txt)) )\
{\
if ( fmt->target ) free( fmt->target );\
fmt->target = strdup(&psz_comment[strlen(txt)]);\
}
IF_EXTRACT("TITLE=", Title )
else IF_EXTRACT("ARTIST=", Artist )
else IF_EXTRACT("GENRE=", Genre )
else IF_EXTRACT("COPYRIGHT=", Copyright )
else IF_EXTRACT("ALBUM=", Album )
else if( !hasTrackNum && !strncasecmp(psz_comment, "TRACKNUMBER=", strlen("TRACKNUMBER=" ) ) )
{
/* Yeah yeah, such a clever idea, let's put xx/xx inside TRACKNUMBER
* Oh, and let's not use TRACKTOTAL or TOTALTRACKS... */
short unsigned u_track, u_total;
if( sscanf( &psz_comment[strlen("TRACKNUMBER=")], "%hu/%hu", &u_track, &u_total ) == 2 )
{
char str[6];
snprintf(str, 6, "%u", u_track);
vlc_meta_Set( p_meta, vlc_meta_TrackNumber, str );
hasTrackNum = true;
snprintf(str, 6, "%u", u_total);
vlc_meta_Set( p_meta, vlc_meta_TrackTotal, str );
hasTrackTotal = true;
}
else
{
vlc_meta_Set( p_meta, vlc_meta_TrackNumber, &psz_comment[strlen("TRACKNUMBER=")] );
hasTrackNum = true;
}
}
else IF_EXTRACT_ONCE("TRACKTOTAL=", TrackTotal )
else IF_EXTRACT_ONCE("TOTALTRACKS=", TrackTotal )
else IF_EXTRACT("DESCRIPTION=", Description )
else IF_EXTRACT("COMMENT=", Description )
else IF_EXTRACT("COMMENTS=", Description )
else IF_EXTRACT("RATING=", Rating )
else IF_EXTRACT("DATE=", Date )
else IF_EXTRACT_FMT("LANGUAGE=", Language, p_fmt, psz_language )
else IF_EXTRACT("ORGANIZATION=", Publisher )
else IF_EXTRACT("ENCODER=", EncodedBy )
else if( !strncasecmp( psz_comment, "METADATA_BLOCK_PICTURE=", strlen("METADATA_BLOCK_PICTURE=")))
{
if( attachments == NULL )
continue;
uint8_t *p_picture;
size_t i_size = vlc_b64_decode_binary( &p_picture, &psz_comment[strlen("METADATA_BLOCK_PICTURE=")]);
input_attachment_t *p_attachment = ParseFlacPicture( p_picture,
i_size, *i_attachments, i_cover_score, i_cover_idx );
free( p_picture );
if( p_attachment )
{
TAB_APPEND_CAST( (input_attachment_t**),
*i_attachments, *attachments, p_attachment );
}
}
else if ( ppf_replay_gain && ppf_replay_peak && !strncmp(psz_comment, "REPLAYGAIN_", 11) )
{
char *p = strchr( psz_comment, '=' );
if (!p) continue;
if ( !strncasecmp(psz_comment, "REPLAYGAIN_TRACK_GAIN=", 22) )
{
(*ppf_replay_gain)[AUDIO_REPLAY_GAIN_TRACK] = us_atof( ++p );
}
else if ( !strncasecmp(psz_comment, "REPLAYGAIN_ALBUM_GAIN=", 22) )
{
(*ppf_replay_gain)[AUDIO_REPLAY_GAIN_ALBUM] = us_atof( ++p );
}
else if ( !strncasecmp(psz_comment, "REPLAYGAIN_ALBUM_PEAK=", 22) )
{
(*ppf_replay_peak)[AUDIO_REPLAY_GAIN_ALBUM] = us_atof( ++p );
}
else if ( !strncasecmp(psz_comment, "REPLAYGAIN_TRACK_PEAK=", 22) )
{
(*ppf_replay_peak)[AUDIO_REPLAY_GAIN_TRACK] = us_atof( ++p );
}
}
else if( !strncasecmp(psz_comment, "CHAPTER", 7) )
{
unsigned int i_chapt;
seekpoint_t *p_seekpoint = NULL;
for( int i = 0; psz_comment[i] && psz_comment[i] != '='; i++ )
if( psz_comment[i] >= 'a' && psz_comment[i] <= 'z' )
psz_comment[i] -= 'a' - 'A';
if( strstr( psz_comment, "NAME=" ) &&
sscanf( psz_comment, "CHAPTER%uNAME=", &i_chapt ) == 1 )
{
char *p = strchr( psz_comment, '=' );
p_seekpoint = getChapterEntry( i_chapt, &chapters_array );
if ( !p || ! p_seekpoint ) continue;
if ( ! p_seekpoint->psz_name )
p_seekpoint->psz_name = strdup( ++p );
}
else if( sscanf( psz_comment, "CHAPTER%u=", &i_chapt ) == 1 )
{
unsigned int h, m, s, ms;
char *p = strchr( psz_comment, '=' );
if( p && sscanf( ++p, "%u:%u:%u.%u", &h, &m, &s, &ms ) == 4 )
{
p_seekpoint = getChapterEntry( i_chapt, &chapters_array );
if ( ! p_seekpoint ) continue;
p_seekpoint->i_time_offset =
(((int64_t)h * 3600 + (int64_t)m * 60 + (int64_t)s) * 1000 + ms) * 1000;
}
}
}
else if( strchr( psz_comment, '=' ) )
{
/* generic (PERFORMER/LICENSE/ORGANIZATION/LOCATION/CONTACT/ISRC,
* undocumented tags and replay gain ) */
char *p = strchr( psz_comment, '=' );
*p++ = '\0';
for( int i = 0; psz_comment[i]; i++ )
if( psz_comment[i] >= 'a' && psz_comment[i] <= 'z' )
psz_comment[i] -= 'a' - 'A';
vlc_meta_AddExtra( p_meta, psz_comment, p );
}
#undef IF_EXTRACT
free( psz_comment );
}
