freetype: get_face always checks codepoint
[vlc.git] / modules / access / dcp / dcpdecrypt.cpp
1 /*****************************************************************************
2  * Copyright (C) 2013 VLC authors and VideoLAN
3  *
4  * Author:
5  *          Simona-Marinela Prodea <simona dot marinela dot prodea at gmail dot com>
6  *
7  * This program is free software; you can redistribute it and/or modify it
8  * under the terms of the GNU Lesser General Public License as published by
9  * the Free Software Foundation; either version 2.1 of the License, or
10  * (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  * GNU Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public License
18  * along with this program; if not, write to the Free Software Foundation,
19  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
20  *****************************************************************************/
21
22 /**
23  * The code used for reading a DER-encoded private key, that is,
24  * RSAKey::parseTag function and RSAKey::readDER function,
25  * is taken almost as is from libgcrypt tests/fipsdrv.c
26  */
27
28 /**
29  * @file dcpdecrypt.cpp
30  * @brief Handle encrypted DCPs
31  */
32
33 #ifdef HAVE_CONFIG_H
34 # include "config.h"
35 #endif
36
37 /* VLC core API headers */
38 #include <vlc_common.h>
39 #include <vlc_xml.h>
40 #include <vlc_strings.h>
41
42 #include <fstream>
43 #include <algorithm>
44 #include <cctype>
45
46 #include "dcpparser.h"
47
48 /* creates a printable, RFC 4122-conform UUID, from a given array of bytes
49  */
50 static string createUUID( unsigned char *ps_string )
51 {
52     string s_uuid;
53     char h[3];
54     int i, ret;
55
56     if( ! ps_string )
57         return "";
58
59     try
60     {
61         s_uuid.append( "urn:uuid:" );
62         for( i = 0; i < 16; i++ )
63         {
64             ret = snprintf( h, 3, "%02hhx", ps_string[i] );  /* each byte can be written as 2 hex digits */
65             if( ret != 2 )
66                 return "";
67             s_uuid.append( h );
68             if( i == 3 || i == 5 || i == 7 || i == 9 )
69                 s_uuid.append( "-" );
70         }
71     }
72     catch( ... )
73     {
74         return "";
75     }
76
77     return s_uuid;
78 }
79
80 /*
81  * KDM class
82  */
83
84 int KDM::Parse()
85 {
86     string s_node, s_value;
87     const string s_root_node = "DCinemaSecurityMessage";
88     int type;
89
90     AESKeyList *_p_key_list = NULL;
91
92     /* init XML parser */
93     if( this->OpenXml() )
94     {
95         msg_Err( p_demux, "failed to initialize KDM XML parser" );
96         return VLC_EGENERIC;
97     }
98
99     msg_Dbg( this->p_demux, "parsing KDM..." );
100
101     /* read first node and check if it is a KDM */
102     if( ! ( ( XML_READER_STARTELEM == XmlFile::ReadNextNode( this->p_demux, this->p_xmlReader, s_node ) ) && ( s_node == s_root_node ) ) )
103     {
104         msg_Err( this->p_demux, "not a valid XML KDM" );
105         goto error;
106     }
107
108     while( ( type = XmlFile::ReadNextNode( this->p_demux, this->p_xmlReader, s_node ) ) > 0 )
109         if( type == XML_READER_STARTELEM && s_node == "AuthenticatedPrivate" )
110         {
111             _p_key_list = new (nothrow) AESKeyList;
112             if( unlikely( _p_key_list == NULL ) )
113                 goto error;
114             p_dcp->p_key_list = _p_key_list;
115             if( this->ParsePrivate( s_node, type ) )
116                 goto error;
117
118             /* keys found, so break */
119             break;
120         }
121
122     if ( (_p_key_list == NULL) ||  (_p_key_list->size() == 0) )
123     {
124         msg_Err( p_demux, "Key list empty" );
125         goto error;
126     }
127
128     /* close KDM XML */
129     this->CloseXml();
130     return VLC_SUCCESS;
131 error:
132     this->CloseXml();
133     return VLC_EGENERIC;
134 }
135
136 int KDM::ParsePrivate( const string _s_node, int _i_type )
137 {
138     string s_node;
139     int i_type;
140     AESKey *p_key;
141
142     /* check that we are where we're supposed to be */
143     if( _i_type != XML_READER_STARTELEM )
144         goto error;
145     if( _s_node != "AuthenticatedPrivate" )
146         goto error;
147
148     /* loop on EncryptedKey nodes */
149     while( ( i_type = XmlFile::ReadNextNode( this->p_demux, this->p_xmlReader, s_node ) ) > 0 )
150     {
151         switch( i_type )
152         {
153             case XML_READER_STARTELEM:
154                 if( s_node != "EncryptedKey" )
155                     goto error;
156                 p_key = new (nothrow) AESKey( this->p_demux );
157                 if( unlikely( p_key == NULL ) )
158                     return VLC_EGENERIC;
159                 if( p_key->Parse( p_xmlReader, s_node, i_type ) )
160                 {
161                     delete p_key;
162                     return VLC_EGENERIC;
163                 }
164                 p_dcp->p_key_list->push_back( p_key );
165                 break;
166
167             case XML_READER_ENDELEM:
168                 if( s_node == _s_node )
169                     return VLC_SUCCESS;
170                 break;
171             default:
172             case XML_READER_TEXT:
173                 goto error;
174         }
175     }
176
177     /* shouldn't get here */
178 error:
179     msg_Err( p_demux, "error while parsing AuthenticatedPrivate portion of KDM" );
180     return VLC_EGENERIC;
181 }
182
183 /*
184  * AESKey class
185  */
186
187 int AESKey::Parse( xml_reader_t *p_xml_reader, string _s_node, int _i_type)
188 {
189     string s_node;
190     string s_value;
191     int i_type;
192
193     if( _i_type != XML_READER_STARTELEM)
194         goto error;
195     if( _s_node != "EncryptedKey" )
196         goto error;
197
198     while( ( i_type = XmlFile::ReadNextNode( this->p_demux, p_xml_reader, s_node ) ) > 0 )
199     {
200         switch( i_type )
201         {
202             case XML_READER_STARTELEM:
203                 if( s_node == "CipherValue" )
204                 {
205                     if( XmlFile::ReadEndNode( this->p_demux, p_xml_reader, s_node, i_type, s_value ) )
206                         goto error;
207                     if( this->decryptRSA( s_value ) )
208                         return VLC_EGENERIC;
209                 }
210                 break;
211             case XML_READER_ENDELEM:
212                 if( s_node == _s_node )
213                     return VLC_SUCCESS;
214                 break;
215             default:
216             case XML_READER_TEXT:
217                 goto error;
218         }
219     }
220
221     /* shouldn't get here */
222 error:
223     msg_Err( this->p_demux, "error while parsing EncryptedKey" );
224     return VLC_EGENERIC;
225 }
226
227 /* decrypts the RSA encrypted text read from the XML file,
228  * and saves the AES key and the other needed info
229  * uses libgcrypt for decryption
230  */
231 int AESKey::decryptRSA( string s_cipher_text_b64 )
232 {
233     RSAKey rsa_key( this->p_demux );
234     unsigned char *ps_cipher_text = NULL;
235     unsigned char *ps_plain_text = NULL;
236     gcry_mpi_t cipher_text_mpi = NULL;
237     gcry_sexp_t cipher_text_sexp = NULL;
238     gcry_sexp_t plain_text_sexp = NULL;
239     gcry_mpi_t plain_text_mpi = NULL;
240     gcry_sexp_t tmp_sexp = NULL;
241     gcry_error_t err;
242     size_t length;
243     int i_ret = VLC_EGENERIC;
244
245     /* get RSA private key file path */
246     if( rsa_key.setPath() )
247         goto end;
248
249     /* read private key from file */
250     if( rsa_key.readPEM() )
251         goto end;
252
253     /* remove spaces and newlines from encoded cipher text
254      * (usually added for indentation in XML files)
255      * */
256     try
257     {
258         s_cipher_text_b64.erase( remove_if( s_cipher_text_b64.begin(), s_cipher_text_b64.end(), static_cast<int(*)(int)>(isspace) ),
259                                  s_cipher_text_b64.end() );
260     }
261     catch( ... )
262     {
263         msg_Err( this->p_demux, "error while handling string" );
264         goto end;
265     }
266
267     /* decode cipher from BASE64 to binary */
268     if( ! ( length = vlc_b64_decode_binary( &ps_cipher_text, s_cipher_text_b64.c_str() ) ) )
269     {
270         msg_Err( this->p_demux, "could not decode cipher from Base64" );
271         goto end;
272     }
273
274     /* initialize libgcrypt */
275     vlc_gcrypt_init ();
276
277     /* create S-expression for ciphertext */
278     if( ( err = gcry_mpi_scan( &cipher_text_mpi, GCRYMPI_FMT_USG, ps_cipher_text, 256, NULL ) ) )
279     {
280         msg_Err( this->p_demux, "could not scan MPI from cipher text: %s", gcry_strerror( err ) );
281         goto end;
282     }
283     if( ( err = gcry_sexp_build( &cipher_text_sexp, NULL, "(enc-val(flags oaep)(rsa(a %m)))", cipher_text_mpi ) ) )
284     {
285         msg_Err( this->p_demux, "could not build S-expression for cipher text: %s", gcry_strerror( err ) );
286         goto end;
287     }
288
289     /* decrypt */
290     if( ( err = gcry_pk_decrypt( &plain_text_sexp, cipher_text_sexp, rsa_key.priv_key ) ) )
291     {
292         msg_Err( this->p_demux, "error while decrypting RSA encrypted info: %s", gcry_strerror( err ) );
293         goto end;
294     }
295
296     /* extract plain-text from S-expression */
297     if( ! ( tmp_sexp = gcry_sexp_find_token( plain_text_sexp, "value", 0 ) ) )
298         /* when using padding flags, the decrypted S-expression is of the form
299          * "(value <plaintext>)", where <plaintext> is an MPI */
300     {
301         msg_Err( this->p_demux, "decrypted text is in an unexpected form; decryption may have failed" );
302         goto end;
303     }
304     /* we could have used the gcry_sexp_nth_data to get the data directly,
305      * but as that function is newly introduced (libgcrypt v1.6),
306      * we prefer compatibility, even though that means passing the data through an MPI first */
307     if( ! ( plain_text_mpi = gcry_sexp_nth_mpi( tmp_sexp, 1, GCRYMPI_FMT_USG ) ) )
308     {
309         msg_Err( this->p_demux, "could not extract MPI from decrypted S-expression" );
310         goto end;
311     }
312
313     if( ( err = gcry_mpi_aprint( GCRYMPI_FMT_USG, &ps_plain_text, &length, plain_text_mpi ) ) )
314     {
315         msg_Err( this->p_demux, "error while extracting plain text from MPI: %s", gcry_strerror( err ) );
316         goto end;
317     }
318
319     /* interpret the plaintext data */
320     switch( length )
321     {
322         case 138:   /* SMPTE    DCP */
323             if( this->extractInfo( ps_plain_text, true ) )
324                 goto end;
325             break;
326         case 134:   /* Interop  DCP */
327             if( this->extractInfo( ps_plain_text, false ) )
328                 goto end;
329             break;
330         case static_cast<size_t>( -1 ):
331             msg_Err( this->p_demux, "could not decrypt" );
332             goto end;
333         default:
334             msg_Err( this->p_demux, "CipherValue field length does not match SMPTE nor Interop standards" );
335             goto end;
336     }
337
338     i_ret = VLC_SUCCESS;
339
340 end:
341     free( ps_cipher_text );
342     gcry_mpi_release( cipher_text_mpi );
343     gcry_sexp_release( cipher_text_sexp );
344     gcry_sexp_release( plain_text_sexp );
345     gcry_mpi_release( plain_text_mpi );
346     gcry_sexp_release( tmp_sexp );
347     gcry_free( ps_plain_text );
348     return i_ret;
349 }
350
351 /* extracts and saves the AES key info from the plaintext;
352  * parameter smpte is true for SMPTE DCP, false for Interop;
353  * see SMPTE 430-1-2006, section 6.1.2 for the exact structure of the plaintext
354  */
355 int AESKey::extractInfo( unsigned char * ps_plain_text, bool smpte )
356 {
357
358     string s_rsa_structID( "f1dc124460169a0e85bc300642f866ab" ); /* unique Structure ID for all RSA-encrypted AES keys in a KDM */
359     string s_carrier;
360     char psz_hex[3];
361     int i_ret, i_pos = 0;
362
363     /* check for the structure ID */
364     while( i_pos < 16 )
365     {
366         i_ret = snprintf( psz_hex, 3, "%02hhx", ps_plain_text[i_pos] );
367         if( i_ret != 2 )
368         {
369             msg_Err( this->p_demux, "error while extracting structure ID from decrypted cipher" );
370             return VLC_EGENERIC;
371         }
372         try
373         {
374             s_carrier.append( psz_hex );
375         }
376         catch( ... )
377         {
378             msg_Err( this->p_demux, "error while handling string" );
379             return VLC_EGENERIC;
380         }
381         i_pos++;
382     }
383     if( s_carrier.compare( s_rsa_structID ) )
384     {
385         msg_Err( this->p_demux, "incorrect RSA structure ID: KDM may be broken" );
386         return VLC_EGENERIC;
387     }
388
389     i_pos += 36;        /* TODO thumbprint, CPL ID */
390     if( smpte )         /* only SMPTE DCPs have the 4-byte "KeyType" field */
391         i_pos += 4;
392
393     /* extract the AES key UUID */
394     if( ( this->s_key_id = createUUID( ps_plain_text + i_pos ) ).empty() )
395     {
396         msg_Err( this->p_demux, "error while extracting AES Key UUID" );
397         return VLC_EGENERIC;
398     }
399     i_pos += 16;
400
401     i_pos += 50; /* TODO KeyEpoch */
402
403     /* extract the AES key */
404     memcpy( this->ps_key, ps_plain_text + i_pos, 16 );
405
406     return VLC_SUCCESS;
407 }
408
409
410 /*
411  * RSAKey class
412  */
413
414 /*
415  * gets the private key path (always stored in the VLC config dir and called "priv.key" )
416  */
417 int RSAKey::setPath( )
418 {
419     char *psz_config_dir = NULL;
420
421     if( ! ( psz_config_dir = config_GetUserDir( VLC_CONFIG_DIR ) ) )
422     {
423         msg_Err( this->p_demux, "could not read user config dir" );
424         goto error;
425     }
426     try
427     {
428         this->s_path.assign( psz_config_dir );
429         this->s_path.append( "/priv.key" );
430     }
431     catch( ... )
432     {
433         msg_Err( this->p_demux, "error while handling string" );
434         goto error;
435     }
436
437     free( psz_config_dir );
438     return VLC_SUCCESS;
439
440 error:
441     free( psz_config_dir );
442     return VLC_EGENERIC;
443 }
444
445 /*
446  * reads the RSA private key from file
447  * the file must be conform to PCKS#1, PEM-encoded, unencrypted
448  */
449 int RSAKey::readPEM( )
450 {
451     string s_header_tag( "-----BEGIN RSA PRIVATE KEY-----" );
452     string s_footer_tag( "-----END RSA PRIVATE KEY-----" );
453     string s_line;
454     string s_data_b64;
455     unsigned char *ps_data_der = NULL;
456     size_t length;
457
458     /* open key file */
459     ifstream file( this->s_path.c_str(), ios::in );
460     if( ! file.is_open() )
461     {
462         msg_Err( this->p_demux, "could not open private key file" );
463         goto error;
464     }
465
466     /* check for header tag */
467     if( ! getline( file, s_line ) )
468     {
469         msg_Err( this->p_demux, "could not read private key file" );
470         goto error;
471     }
472     if( s_line.compare( s_header_tag ) )
473     {
474         msg_Err( this->p_demux, "unexpected header tag found in private key file" );
475         goto error;
476     }
477
478     /* read file until footer tag is found */
479     while( getline( file, s_line ) )
480     {
481         if( ! s_line.compare( s_footer_tag ) )
482             break;
483         try
484         {
485             s_data_b64.append( s_line );
486         }
487         catch( ... )
488         {
489             msg_Err( this->p_demux, "error while handling string" );
490             goto error;
491         }
492     }
493     if( ! file )
494     {
495         msg_Err( this->p_demux, "error while reading private key file; footer tag may be missing" );
496         goto error;
497     }
498
499     /* decode data from Base64 */
500     if( ! ( length = vlc_b64_decode_binary( &ps_data_der, s_data_b64.c_str() ) ) )
501     {
502         msg_Err( this->p_demux, "could not decode from Base64" );
503         goto error;
504     }
505
506     /* extract key S-expression from DER-encoded data */
507     if( this->readDER( ps_data_der, length ) )
508         goto error;
509
510     /* clear data */
511     free( ps_data_der );
512     return VLC_SUCCESS;
513
514 error:
515     free( ps_data_der );
516     return VLC_EGENERIC;
517 }
518
519 /*
520  * Parse the DER-encoded data at ps_data_der
521  * saving the key in an S-expression
522  */
523 int RSAKey::readDER( unsigned char const* ps_data_der, size_t length )
524 {
525     struct tag_info tag_inf;
526     gcry_mpi_t key_params[8] = { NULL };
527     gcry_error_t err;
528
529     /* parse the ASN1 structure */
530     if( parseTag( &ps_data_der, &length, &tag_inf )
531             || tag_inf.tag != TAG_SEQUENCE || tag_inf.class_ || !tag_inf.cons || tag_inf.ndef )
532         goto bad_asn1;
533     if( parseTag( &ps_data_der, &length, &tag_inf )
534        || tag_inf.tag != TAG_INTEGER || tag_inf.class_ || tag_inf.cons || tag_inf.ndef )
535         goto bad_asn1;
536     if( tag_inf.length != 1 || *ps_data_der )
537         goto bad_asn1;  /* The value of the first integer is no 0. */
538     ps_data_der += tag_inf.length;
539     length -= tag_inf.length;
540
541     for( int i = 0; i < 8; i++ )
542     {
543         if( parseTag( &ps_data_der, &length, &tag_inf )
544                 || tag_inf.tag != TAG_INTEGER || tag_inf.class_ || tag_inf.cons || tag_inf.ndef )
545             goto bad_asn1;
546         err = gcry_mpi_scan( key_params + i, GCRYMPI_FMT_USG, ps_data_der, tag_inf.length, NULL );
547         if( err )
548         {
549             msg_Err( this->p_demux, "error scanning RSA parameter %d: %s", i, gpg_strerror( err ) );
550             goto error;
551         }
552         ps_data_der += tag_inf.length;
553         length -= tag_inf.length;
554     }
555
556     /* Convert from OpenSSL parameter ordering to the OpenPGP order.
557      * First check that p < q; if not swap p and q and recompute u.
558      */
559     if( gcry_mpi_cmp( key_params[3], key_params[4] ) > 0 )
560     {
561         gcry_mpi_swap( key_params[3], key_params[4] );
562         gcry_mpi_invm( key_params[7], key_params[3], key_params[4] );
563     }
564
565     /* Build the S-expression.  */
566     err = gcry_sexp_build( & this->priv_key, NULL,
567                          "(private-key(rsa(n%m)(e%m)(d%m)(p%m)(q%m)(u%m)))",
568                          key_params[0], key_params[1], key_params[2],
569                          key_params[3], key_params[4], key_params[7] );
570     if( err )
571     {
572         msg_Err( this->p_demux, "error building S-expression: %s", gpg_strerror( err ) );
573         goto error;
574     }
575
576     /* clear data */
577     for( int i = 0; i < 8; i++ )
578         gcry_mpi_release( key_params[i] );
579     return VLC_SUCCESS;
580
581 bad_asn1:
582     msg_Err( this->p_demux, "could not parse ASN1 structure; key might be corrupted" );
583
584 error:
585     for( int i = 0; i < 8; i++ )
586         gcry_mpi_release( key_params[i] );
587     return VLC_EGENERIC;
588 }
589
590 /*
591  * Parse the buffer at the address BUFFER which consists of the number
592  * of octets as stored at BUFLEN.  Return the tag and the length part
593  * from the TLV triplet.  Update BUFFER and BUFLEN on success.  Checks
594  * that the encoded length does not exhaust the length of the provided
595  * buffer.
596  */
597 int RSAKey::parseTag( unsigned char const **buffer, size_t *buflen, struct tag_info *ti)
598 {
599   int c;
600   unsigned long tag;
601   const unsigned char *buf = *buffer;
602   size_t length = *buflen;
603
604   ti->length = 0;
605   ti->ndef = 0;
606   ti->nhdr = 0;
607
608   /* Get the tag */
609   if (!length)
610     return -1; /* Premature EOF.  */
611   c = *buf++; length--;
612   ti->nhdr++;
613
614   ti->class_ = (c & 0xc0) >> 6;
615   ti->cons   = !!(c & 0x20);
616   tag        = (c & 0x1f);
617
618   if (tag == 0x1f)
619     {
620       tag = 0;
621       do
622         {
623           tag <<= 7;
624           if (!length)
625             return -1; /* Premature EOF.  */
626           c = *buf++; length--;
627           ti->nhdr++;
628           tag |= (c & 0x7f);
629         }
630       while ( (c & 0x80) );
631     }
632   ti->tag = tag;
633
634   /* Get the length */
635   if (!length)
636     return -1; /* Premature EOF. */
637   c = *buf++; length--;
638   ti->nhdr++;
639
640   if ( !(c & 0x80) )
641     ti->length = c;
642   else if (c == 0x80)
643     ti->ndef = 1;
644   else if (c == 0xff)
645     return -1; /* Forbidden length value.  */
646   else
647     {
648       unsigned long len = 0;
649       int count = c & 0x7f;
650
651       for (; count; count--)
652         {
653           len <<= 8;
654           if (!length)
655             return -1; /* Premature EOF.  */
656           c = *buf++; length--;
657           ti->nhdr++;
658           len |= (c & 0xff);
659         }
660       ti->length = len;
661     }
662
663   if (ti->class_ == 0 && !ti->tag)
664     ti->length = 0;
665
666   if (ti->length > length)
667     return -1; /* Data larger than buffer.  */
668
669   *buffer = buf;
670   *buflen = length;
671   return 0;
672 }