Ignore:
Timestamp:
07/28/11 21:51:30 (13 years ago)
Author:
r2d
Message:

Security fixes by DEATH (and some changes by myself)

File:
1 edited

Legend:

Unmodified
Added
Removed

  • libmpc/trunk/libmpcdec/mpc_demux.c

    r466 r473  
    7272}
    7373
     74// Returns the amount of unread bytes in the demux buffer.
     75// Unchecked version - may return a negative value when we've been reading
     76// past the end of the valid data as a result of some problem with the file.
     77static mpc_int32_t mpc_unread_bytes_unchecked(mpc_demux * d) {
     78        return d->bytes_total + d->buffer - d->bits_reader.buff - ((8 - d->bits_reader.count) >> 3);
     79}
     80
     81// Returns the amount of unread bytes in the demux buffer.
     82static mpc_uint32_t mpc_unread_bytes(mpc_demux * d) {
     83        mpc_int32_t unread_bytes = mpc_unread_bytes_unchecked(d);
     84
     85        if (unread_bytes < 0) return 0;
     86       
     87        return (mpc_uint32_t) unread_bytes;
     88}
     89
     90
     91
     92// Returns the number of bytes available in the buffer.
    7493static mpc_uint32_t
    7594mpc_demux_fill(mpc_demux * d, mpc_uint32_t min_bytes, int flags)
    7695{
    77         mpc_uint32_t unread_bytes = d->bytes_total + d->buffer - d->bits_reader.buff
    78                         - ((8 - d->bits_reader.count) >> 3);
     96        mpc_uint32_t unread_bytes = (mpc_uint32_t) mpc_unread_bytes_unchecked(d);
    7997        int offset = 0;
    8098
     99        if ((mpc_int32_t)
     100                unread_bytes < 0) return 0; // Error - we've been reading past the end of the buffer - abort
     101
    81102        if (min_bytes == 0 || min_bytes > DEMUX_BUFFER_SIZE ||
    82                     (unread_bytes < min_bytes && flags & MPC_BUFFER_FULL))
     103                    (unread_bytes < min_bytes && (flags & MPC_BUFFER_FULL) != 0 ))
    83104                min_bytes = DEMUX_BUFFER_SIZE;
    84105
    … …  
    86107                mpc_uint32_t bytes2read = min_bytes - unread_bytes;
    87108                mpc_uint32_t bytes_free = DEMUX_BUFFER_SIZE - d->bytes_total;
     109                mpc_uint32_t bytesread;
    88110
    89111                if (flags & MPC_BUFFER_SWAP) {
    … …  
    102124                        d->bytes_total = unread_bytes + offset;
    103125                }
    104                 bytes2read = d->r->read(d->r, d->buffer + d->bytes_total, bytes2read);
    105                 if (flags & MPC_BUFFER_SWAP){
     126                bytesread = d->r->read(d->r, d->buffer + d->bytes_total, bytes2read);
     127                if (bytesread < bytes2read) {
     128                        memset(d->buffer + d->bytes_total + bytesread, 0, bytes2read - bytesread); // FIXME : why ?
     129                }
     130                if (flags & MPC_BUFFER_SWAP) {
    106131                        unsigned int i, * tmp = (unsigned int *) (d->buffer + d->bytes_total);
    107132                        for(i = 0 ;i < (bytes2read >> 2); i++)
    108133                                tmp[i] = mpc_swap32(tmp[i]);
    109134                }
    110                 d->bytes_total += bytes2read;
    111                 return bytes2read;
    112         }
    113 
    114         return (mpc_uint32_t) -1;
     135                d->bytes_total += bytesread;
     136                unread_bytes += bytesread;
     137        }
     138
     139        return unread_bytes;
    115140}
    116141
    … …  
    121146 * @param min_bytes number of bytes to load after seeking
    122147 */
    123 static void
     148static mpc_status
    124149mpc_demux_seek(mpc_demux * d, mpc_seek_t fpos, mpc_uint32_t min_bytes) {
    125150        mpc_seek_t start_pos, end_pos;
    … …  
    141166                bit_offset = (int) (fpos - (next_pos << 3));
    142167
    143                 d->r->seek(d->r, (mpc_int32_t) next_pos);
    144168                mpc_demux_clear_buff(d);
     169                if (!d->r->seek(d->r, (mpc_int32_t) next_pos))
     170                        return MPC_STATUS_FAIL;
    145171        }
    146172
    … …  
    151177        d->bits_reader.buff += bit_offset >> 3;
    152178        d->bits_reader.count = 8 - (bit_offset & 7);
     179
     180        return MPC_STATUS_OK;
    153181}
    154182
    … …  
    170198 * @param d demuxer context
    171199 * @return size of tag, in bytes
    172  * @return MPC_STATUS_FILE on errors of any kind
     200 * @return MPC_STATUS_FAIL on errors of any kind
    173201 */
    174202static mpc_int32_t mpc_demux_skip_id3v2(mpc_demux * d)
    … …  
    193221        footerPresent = tmp[0] & 0x10;
    194222        if ( tmp[0] & 0x0F )
    195                 return MPC_STATUS_FILE; // not (yet???) allowed
     223                return MPC_STATUS_FAIL; // not (yet???) allowed
    196224
    197225        tmp[0] = mpc_bits_read(&d->bits_reader, 8); // read size
    … …  
    201229
    202230        if ( (tmp[0] | tmp[1] | tmp[2] | tmp[3]) & 0x80 )
    203                 return MPC_STATUS_FILE; // not allowed
     231                return MPC_STATUS_FAIL; // not allowed
    204232
    205233    // read headerSize (syncsave: 4 * $0xxxxxxx = 28 significant bits)
    … …  
    215243        // This is called before file headers get read, streamversion etc isn't yet known, demuxing isn't properly initialized and we can't call mpc_demux_seek() from here.
    216244        mpc_demux_clear_buff(d);
    217         if (!d->r->seek(d->r, size)) return MPC_STATUS_FILE;
     245        if (!d->r->seek(d->r, size))
     246                return MPC_STATUS_FAIL;
    218247
    219248        return size;
    … …  
    236265        d->seek_table = malloc((size_t)(seek_table_size * sizeof(mpc_seek_t)));
    237266        if (d->seek_table == 0)
    238                 return MPC_STATUS_FILE;
     267                return MPC_STATUS_FAIL;
    239268        d->seek_table[0] = (mpc_seek_t)mpc_demux_pos(d);
    240269        d->seek_table_size = 1;
    … …  
    243272}
    244273
    245 static void mpc_demux_ST(mpc_demux * d)
     274static mpc_status mpc_demux_ST(mpc_demux * d)
    246275{
    247276        mpc_uint64_t tmp;
    … …  
    252281
    253282        if (d->seek_table != 0)
    254                 return;
     283                return MPC_STATUS_OK;
    255284
    256285        mpc_bits_get_size(&r, &tmp);
    … …  
    274303
    275304        if (d->seek_table_size == 1)
    276                 return;
     305                return MPC_STATUS_OK;
    277306
    278307        mpc_bits_get_size(&r, &tmp);
    … …  
    290319                        table[i >> diff_pwr] = last[i & 1];
    291320        }
    292 }
    293 
    294 static void mpc_demux_SP(mpc_demux * d, int size, int block_size)
     321        return MPC_STATUS_OK;
     322}
     323
     324static mpc_status mpc_demux_SP(mpc_demux * d, int size, int block_size)
    295325{
    296326        mpc_seek_t cur;
    … …  
    301331        cur = mpc_demux_pos(d);
    302332        mpc_bits_get_size(&d->bits_reader, &ptr);
    303         mpc_demux_seek(d, (ptr - size) * 8 + cur, 11);
     333        MPC_AUTO_FAIL( mpc_demux_seek(d, (ptr - size) * 8 + cur, 11) );
    304334        st_head_size = mpc_bits_get_block(&d->bits_reader, &b);
    305335        if (memcmp(b.key, "ST", 2) == 0) {
    306336                d->chap_pos = (ptr - size + b.size + st_head_size) * 8 + cur;
    307337                d->chap_nb = -1;
    308                 mpc_demux_fill(d, (mpc_uint32_t) b.size, 0);
    309                 mpc_demux_ST(d);
    310         }
    311         mpc_demux_seek(d, cur, 11 + block_size);
    312 }
    313 
    314 static void mpc_demux_chap_find(mpc_demux * d)
     338                if (mpc_demux_fill(d, (mpc_uint32_t) b.size, 0) < b.size)
     339                        return MPC_STATUS_FAIL;
     340                MPC_AUTO_FAIL( mpc_demux_ST(d) );
     341        }
     342        return mpc_demux_seek(d, cur, 11 + block_size);
     343}
     344
     345static void mpc_demux_chap_empty(mpc_demux * d) {
     346        free(d->chap); d->chap = 0;
     347        d->chap_nb = 0; // -1 for undefined, 0 for no chapters
     348        d->chap_pos = 0;
     349}
     350
     351static mpc_status mpc_demux_chap_find_inner(mpc_demux * d)
    315352{
    316353        mpc_block b;
    … …  
    320357
    321358        if (d->si.stream_version < 8)
    322                 return;
     359                return MPC_STATUS_OK;
    323360
    324361        if (d->chap_pos == 0) {
    325362                mpc_uint64_t cur_pos = (d->si.header_position + 4) * 8;
    326                 mpc_demux_seek(d, cur_pos, 11); // seek to the beginning of the stream
     363                MPC_AUTO_FAIL( mpc_demux_seek(d, cur_pos, 11) ); // seek to the beginning of the stream
    327364                size = mpc_bits_get_block(&d->bits_reader, &b);
    328365                while (memcmp(b.key, "SE", 2) != 0) {
    329                         if (mpc_check_key(b.key) != MPC_STATUS_OK)
    330                                 return;
     366                        mpc_uint64_t new_pos = cur_pos + (size + b.size) * 8;
     367                        MPC_AUTO_FAIL(mpc_check_key(b.key));
     368
    331369                        if (memcmp(b.key, "CT", 2) == 0) {
    332370                                if (d->chap_pos == 0) d->chap_pos = cur_pos;
    333                         } else
     371                        } else {
    334372                                d->chap_pos = 0;
    335                         cur_pos += (size + b.size) * 8;
    336                         mpc_demux_seek(d, cur_pos, 11);
     373                        }
     374                        if (new_pos <= cur_pos)
     375                                return MPC_STATUS_FAIL;
     376                        cur_pos = new_pos;
     377                       
     378                        MPC_AUTO_FAIL( mpc_demux_seek(d, cur_pos, 11) );
    337379                        size = mpc_bits_get_block(&d->bits_reader, &b);
    338380                }
    … …  
    350392                chap_size += size;
    351393                tag_size += b.size - size;
    352                 mpc_demux_seek(d, d->chap_pos + (chap_size + tag_size) * 8, 20);
     394                MPC_AUTO_FAIL( mpc_demux_seek(d, d->chap_pos + (chap_size + tag_size) * 8, 20) );
    353395                size = mpc_bits_get_block(&d->bits_reader, &b);
    354396        }
    … …  
    357399                char * ptag;
    358400                d->chap = malloc(sizeof(mpc_chap_info) * d->chap_nb + tag_size);
    359                 if (d->chap != 0) {
    360                         ptag = (char*)(d->chap + d->chap_nb);
    361 
    362                         mpc_demux_seek(d, d->chap_pos, 11);
     401                if (d->chap == 0)
     402                        return MPC_STATUS_FAIL;
     403
     404                ptag = (char*)(d->chap + d->chap_nb);
     405
     406                MPC_AUTO_FAIL( mpc_demux_seek(d, d->chap_pos, 11) );
     407                size = mpc_bits_get_block(&d->bits_reader, &b);
     408                while (memcmp(b.key, "CT", 2) == 0) {
     409                        mpc_uint_t tmp_size;
     410                        char * tmp_ptag = ptag;
     411                        if (mpc_demux_fill(d, 11 + (mpc_uint32_t) b.size, 0) < b.size)
     412                                return MPC_STATUS_FAIL;
     413                        size = mpc_bits_get_size(&d->bits_reader, &d->chap[i].sample) + 4;
     414                        d->chap[i].gain = (mpc_uint16_t) mpc_bits_read(&d->bits_reader, 16);
     415                        d->chap[i].peak = (mpc_uint16_t) mpc_bits_read(&d->bits_reader, 16);
     416
     417                        tmp_size = b.size - size;
     418                        do {
     419                                mpc_uint_t rd_size = tmp_size;
     420                                mpc_uint8_t * tmp_buff = d->bits_reader.buff + ((8 - d->bits_reader.count) >> 3);
     421                                mpc_uint32_t avail_bytes = d->bytes_total + d->buffer - tmp_buff;
     422                                rd_size = mini(rd_size, avail_bytes);
     423                                memcpy(tmp_ptag, tmp_buff, rd_size);
     424                                tmp_size -= rd_size;
     425                                tmp_ptag += rd_size;
     426                                d->bits_reader.buff += rd_size;
     427                                mpc_demux_fill(d, tmp_size, 0);
     428                        } while (tmp_size > 0);
     429
     430                        d->chap[i].tag_size = b.size - size;
     431                        d->chap[i].tag = ptag;
     432                        ptag += b.size - size;
     433                        i++;
    363434                        size = mpc_bits_get_block(&d->bits_reader, &b);
    364                         while (memcmp(b.key, "CT", 2) == 0) {
    365                                 int tmp_size;
    366                                 char * tmp_ptag = ptag;
    367                                 mpc_demux_fill(d, 11 + (mpc_uint32_t) b.size, 0);
    368                                 size = mpc_bits_get_size(&d->bits_reader, &d->chap[i].sample) + 4;
    369                                 d->chap[i].gain = (mpc_uint16_t) mpc_bits_read(&d->bits_reader, 16);
    370                                 d->chap[i].peak = (mpc_uint16_t) mpc_bits_read(&d->bits_reader, 16);
    371 
    372                                 tmp_size = b.size - size;
    373                                 do {
    374                                         int rd_size = tmp_size;
    375                                         mpc_uint8_t * tmp_buff = d->bits_reader.buff + ((8 - d->bits_reader.count) >> 3);
    376                                         mpc_uint32_t avail_bytes = d->bytes_total + d->buffer - tmp_buff;
    377                                         rd_size = mini(rd_size, avail_bytes);
    378                                         memcpy(tmp_ptag, tmp_buff, rd_size);
    379                                         tmp_size -= rd_size;
    380                                         tmp_ptag += rd_size;
    381                                         d->bits_reader.buff += rd_size;
    382                                         mpc_demux_fill(d, tmp_size, 0);
    383                                 } while (tmp_size > 0);
    384 
    385                                 d->chap[i].tag_size = b.size - size;
    386                                 d->chap[i].tag = ptag;
    387                                 ptag += b.size - size;
    388                                 i++;
    389                                 size = mpc_bits_get_block(&d->bits_reader, &b);
    390                         }
    391                 } else {
    392                         d->chap_nb = 0; // malloc failed, chapters will not be available
    393435                }
    394436        }
    395437
    396438        d->bits_reader.buff -= size;
     439        return MPC_STATUS_OK;
     440}
     441
     442static mpc_status mpc_demux_chap_find(mpc_demux * d) {
     443        mpc_status s = mpc_demux_chap_find_inner(d);
     444        if (MPC_IS_FAILURE(s))
     445                mpc_demux_chap_empty(d);
     446        return s;
    397447}
    398448
    … …  
    434484    // get header position
    435485        d->si.header_position = mpc_demux_skip_id3v2(d);
    436         if(d->si.header_position < 0) return MPC_STATUS_FILE;
     486        if(d->si.header_position < 0)
     487                return MPC_STATUS_FAIL;
    437488
    438489        d->si.tag_offset = d->si.total_file_length = d->r->get_size(d->r);
    … …  
    447498                d->si.stream_version = magic[3] & 15;
    448499                d->si.pns = magic[3] >> 4;
    449                 if (d->si.stream_version == 7) {
    450                         mpc_status ret;
    451                         mpc_demux_fill(d, 6 * 4, MPC_BUFFER_SWAP); // header block size + endian convertion
    452                         ret = streaminfo_read_header_sv7(&d->si, &d->bits_reader);
    453                         if (ret != MPC_STATUS_OK) return ret;
    454                 } else {
    455                         return MPC_STATUS_INVALIDSV;
    456                 }
     500                if (d->si.stream_version != 7)
     501                        return MPC_STATUS_FAIL;
     502                if (mpc_demux_fill(d, 6 * 4, MPC_BUFFER_SWAP) < 6 * 4) // header block size + endian convertion
     503                        return MPC_STATUS_FAIL;
     504                MPC_AUTO_FAIL( streaminfo_read_header_sv7(&d->si, &d->bits_reader) );
    457505        } else if (memcmp(magic, "MPCK", 4) == 0) {
    458506                mpc_block b;
    … …  
    462510                while( memcmp(b.key, "AP", 2) != 0 ){ // scan all blocks until audio
    463511                        if (mpc_check_key(b.key) != MPC_STATUS_OK)
    464                                 return MPC_STATUS_INVALIDSV;
     512                                return MPC_STATUS_FAIL;
    465513                        if (b.size > (mpc_uint64_t) DEMUX_BUFFER_SIZE - 11)
    466                                 return MPC_STATUS_INVALIDSV;
    467                         mpc_demux_fill(d, 11 + (mpc_uint32_t) b.size, 0);
    468                         if (memcmp(b.key, "SH", 2) == 0){
    469                                 int ret = streaminfo_read_header_sv8(&d->si, &d->bits_reader, (mpc_uint32_t) b.size);
    470                                 if (ret != MPC_STATUS_OK) return ret;
    471                         } else if (memcmp(b.key, "RG", 2) == 0)
     514                                return MPC_STATUS_FAIL;
     515                       
     516                        if (mpc_demux_fill(d, 11 + (mpc_uint32_t) b.size, 0) <= b.size)
     517                                return MPC_STATUS_FAIL;
     518
     519                        if (memcmp(b.key, "SH", 2) == 0) {
     520                                MPC_AUTO_FAIL( streaminfo_read_header_sv8(&d->si, &d->bits_reader, (mpc_uint32_t) b.size) );
     521                        } else if (memcmp(b.key, "RG", 2) == 0) {
    472522                                streaminfo_gain(&d->si, &d->bits_reader);
    473                         else if (memcmp(b.key, "EI", 2) == 0)
     523                        } else if (memcmp(b.key, "EI", 2) == 0) {
    474524                                streaminfo_encoder_info(&d->si, &d->bits_reader);
    475                         else if (memcmp(b.key, "SO", 2) == 0)
    476                                 mpc_demux_SP(d, size, (mpc_uint32_t) b.size);
    477                         else if (memcmp(b.key, "ST", 2) == 0)
    478                                 mpc_demux_ST(d);
     525                        } else if (memcmp(b.key, "SO", 2) == 0) {
     526                                MPC_AUTO_FAIL( mpc_demux_SP(d, size, (mpc_uint32_t) b.size) );
     527                        } else if (memcmp(b.key, "ST", 2) == 0) {
     528                                MPC_AUTO_FAIL( mpc_demux_ST(d) );
     529                        }
    479530                        d->bits_reader.buff += b.size;
    480531                        size = mpc_bits_get_block(&d->bits_reader, &b);
    … …  
    482533                d->bits_reader.buff -= size;
    483534                if (d->si.stream_version == 0) // si not initialized !!!
    484                         return MPC_STATUS_INVALIDSV;
    485         } else
    486                 return MPC_STATUS_INVALIDSV;
     535                        return MPC_STATUS_FAIL;
     536        } else {
     537                return MPC_STATUS_FAIL;
     538        }
    487539
    488540        return MPC_STATUS_OK;
    … …  
    525577}
    526578
    527 mpc_status mpc_demux_decode(mpc_demux * d, mpc_frame_info * i)
     579static mpc_status mpc_demux_decode_inner(mpc_demux * d, mpc_frame_info * i)
    528580{
    529581        mpc_bits_reader r;
    … …  
    541593                        mpc_bits_get_block(&d->bits_reader, &b);
    542594                        while( memcmp(b.key, "AP", 2) != 0 ) { // scan all blocks until audio
    543                                 if (mpc_check_key(b.key) != MPC_STATUS_OK)
    544                                         goto error;
     595                                MPC_AUTO_FAIL( mpc_check_key(b.key) );
     596
    545597                                if (memcmp(b.key, "SE", 2) == 0) { // end block
    546598                                        i->bits = -1;
    547599                                        return MPC_STATUS_OK;
    548600                                }
    549                                 if (mpc_demux_fill(d, 11 + (mpc_uint32_t) b.size, MPC_BUFFER_FULL) == 0)
    550                                         goto error;
     601
     602                                if (mpc_demux_fill(d, 11 + (mpc_uint32_t) b.size, MPC_BUFFER_FULL) < b.size)
     603                                        return MPC_STATUS_FAIL;
     604
    551605                                d->bits_reader.buff += b.size;
    552606                                mpc_bits_get_block(&d->bits_reader, &b);
    … …  
    563617                d->block_frames--;
    564618                if (d->block_bits < 0 || (d->block_frames == 0 && d->block_bits > 7))
    565                         goto error;
     619                        return MPC_STATUS_FAIL;
    566620        } else {
    567621                if (d->d->decoded_samples == (d->seek_table_size << d->seek_pwr) * MPC_FRAME_LENGTH) {
    … …  
    575629                mpc_decoder_decode_frame(d->d, &d->bits_reader, i);
    576630                if (i->bits != -1 && d->block_bits != ((d->bits_reader.buff - r.buff) << 3) + r.count - d->bits_reader.count)
    577                         goto error;
     631                        return MPC_STATUS_FAIL;
    578632        }
    579633        if (i->bits != -1 && d->buffer + d->bytes_total < d->bits_reader.buff + ((8 - d->bits_reader.count) >> 3))
    580                 goto error;
     634                return MPC_STATUS_FAIL;
    581635
    582636        return MPC_STATUS_OK;
    583 error:
     637}
     638
     639mpc_status mpc_demux_decode(mpc_demux * d, mpc_frame_info * i) {
     640        mpc_status s = mpc_demux_decode_inner(d, i);
     641        if (MPC_IS_FAILURE(s))
    584642                i->bits = -1; // we pretend it's end of file
    585                 return MPC_STATUS_INVALIDSV;
     643        return s;
    586644}
    587645
    … …  
    658716                                                  mpc_bool_t use_title, mpc_bool_t clip_prevention)
    659717{
    660         float peak = use_title ? d->si.peak_title : d->si.peak_album;
    661         float gain = use_title ? d->si.gain_title : d->si.gain_album;
     718        float peak = (float) ( use_title ? d->si.peak_title : d->si.peak_album );
     719        float gain = (float) ( use_title ? d->si.gain_title : d->si.gain_album );
    662720
    663721        if(!use_gain && !clip_prevention)
    … …  
    667725                peak = 1.;
    668726        else
    669                 peak = (1 << 15) / pow(10, peak / (20 * 256));
     727                peak = (float) ( (1 << 15) / pow(10, peak / (20 * 256)) );
    670728
    671729        if(!gain)
    672730                gain = 1.;
    673731        else
    674                 gain = pow(10, (level - gain / 256) / 20);
     732                gain = (float) pow(10, (level - gain / 256) / 20);
    675733
    676734        if(clip_prevention && (peak < gain || !use_gain))
Note: See TracChangeset for help on using the changeset viewer.