mirror of https://github.com/Cisco-Talos/clamav
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
503 lines
15 KiB
503 lines
15 KiB
/*
|
|
* Extract RAR archives
|
|
*
|
|
* Copyright (C) 2005 trog@uncon.org
|
|
*
|
|
* This code is based on the work of Alexander L. Roshal (C)
|
|
*
|
|
* The unRAR sources may be used in any software to handle RAR
|
|
* archives without limitations free of charge, but cannot be used
|
|
* to re-create the RAR compression algorithm, which is proprietary.
|
|
* Distribution of modified unRAR sources in separate form or as a
|
|
* part of other software is permitted, provided that it is clearly
|
|
* stated in the documentation and source comments that the code may
|
|
* not be used to develop a RAR (WinRAR) compatible archiver.
|
|
*
|
|
*/
|
|
|
|
#include "libclamunrar/unrar.h"
|
|
#include "libclamunrar/unrar15.h"
|
|
#include <string.h>
|
|
|
|
#define STARTL1 2
|
|
static unsigned int dec_l1[]={0x8000,0xa000,0xc000,0xd000,0xe000,0xea00,
|
|
0xee00,0xf000,0xf200,0xf200,0xffff};
|
|
static unsigned int pos_l1[]={0,0,0,2,3,5,7,11,16,20,24,32,32};
|
|
|
|
#define STARTL2 3
|
|
static unsigned int dec_l2[]={0xa000,0xc000,0xd000,0xe000,0xea00,0xee00,
|
|
0xf000,0xf200,0xf240,0xffff};
|
|
static unsigned int pos_l2[]={0,0,0,0,5,7,9,13,18,22,26,34,36};
|
|
|
|
#define STARTHF0 4
|
|
static unsigned int dec_hf0[]={0x8000,0xc000,0xe000,0xf200,0xf200,0xf200,
|
|
0xf200,0xf200,0xffff};
|
|
static unsigned int pos_hf0[]={0,0,0,0,0,8,16,24,33,33,33,33,33};
|
|
|
|
|
|
#define STARTHF1 5
|
|
static unsigned int dec_hf1[]={0x2000,0xc000,0xe000,0xf000,0xf200,0xf200,
|
|
0xf7e0,0xffff};
|
|
static unsigned int pos_hf1[]={0,0,0,0,0,0,4,44,60,76,80,80,127};
|
|
|
|
|
|
#define STARTHF2 5
|
|
static unsigned int dec_hf2[]={0x1000,0x2400,0x8000,0xc000,0xfa00,0xffff,
|
|
0xffff,0xffff};
|
|
static unsigned int pos_hf2[]={0,0,0,0,0,0,2,7,53,117,233,0,0};
|
|
|
|
|
|
#define STARTHF3 6
|
|
static unsigned int dec_hf3[]={0x800,0x2400,0xee00,0xfe80,0xffff,0xffff,
|
|
0xffff};
|
|
static unsigned int pos_hf3[]={0,0,0,0,0,0,0,2,16,218,251,0,0};
|
|
|
|
|
|
#define STARTHF4 8
|
|
static unsigned int dec_hf4[]={0xff00,0xffff,0xffff,0xffff,0xffff,0xffff};
|
|
static unsigned int pos_hf4[]={0,0,0,0,0,0,0,0,0,255,0,0,0};
|
|
|
|
static void unpack_init_data15(int solid, unpack_data_t *unpack_data)
|
|
{
|
|
if (!solid) {
|
|
unpack_data->avr_plcb = unpack_data->avr_ln1 = unpack_data->avr_ln2 =
|
|
unpack_data->avr_ln3 = unpack_data->num_huf =
|
|
unpack_data->buf60 = 0;
|
|
unpack_data->avr_plc = 0x3500;
|
|
unpack_data->max_dist3 = 0x2001;
|
|
unpack_data->nhfb = unpack_data->nlzb = 0x80;
|
|
}
|
|
|
|
unpack_data->flags_cnt = 0;
|
|
unpack_data->flag_buf = 0;
|
|
unpack_data->st_mode = 0;
|
|
unpack_data->lcount = 0;
|
|
unpack_data->read_top = 0;
|
|
}
|
|
|
|
static void corr_huff(unpack_data_t *unpack_data, unsigned int *char_set,
|
|
unsigned int *num_to_place)
|
|
{
|
|
int i, j;
|
|
|
|
for (i=7 ; i >= 0 ; i--) {
|
|
for (j=0 ; j < 32 ; j++, char_set++) {
|
|
*char_set = (*char_set & ~0xff) | i;
|
|
}
|
|
}
|
|
memset(num_to_place, 0, sizeof(unpack_data->ntopl));
|
|
for (i=6 ; i >= 0 ; i--) {
|
|
num_to_place[i] = (7-i) * 32;
|
|
}
|
|
}
|
|
|
|
static void init_huff(unpack_data_t *unpack_data)
|
|
{
|
|
unsigned int i;
|
|
|
|
for (i=0 ; i<256 ; i++) {
|
|
unpack_data->place[i] = unpack_data->placea[i] = unpack_data->placeb[i] = i;
|
|
unpack_data->placec[i] = (~i+1) & 0xff;
|
|
unpack_data->chset[i] = unpack_data->chsetb[i] = i << 8;
|
|
unpack_data->chseta[i] = i;
|
|
unpack_data->chsetc[i] = ((~i+1) & 0xff) << 8;
|
|
}
|
|
memset(unpack_data->ntopl, 0, sizeof(unpack_data->ntopl));
|
|
memset(unpack_data->ntoplb, 0, sizeof(unpack_data->ntoplb));
|
|
memset(unpack_data->ntoplc, 0, sizeof(unpack_data->ntoplc));
|
|
corr_huff(unpack_data, unpack_data->chsetb, unpack_data->ntoplb);
|
|
}
|
|
|
|
static void copy_string15(unpack_data_t *unpack_data, unsigned int distance,
|
|
unsigned int length)
|
|
{
|
|
unpack_data->dest_unp_size -= length;
|
|
while (length--) {
|
|
unpack_data->window[unpack_data->unp_ptr] =
|
|
unpack_data->window[(unpack_data->unp_ptr - distance) & MAXWINMASK];
|
|
unpack_data->unp_ptr = (unpack_data->unp_ptr + 1) & MAXWINMASK;
|
|
}
|
|
}
|
|
|
|
static unsigned int decode_num(unpack_data_t *unpack_data, int num, unsigned int start_pos,
|
|
unsigned int *dec_tab, unsigned int *pos_tab)
|
|
{
|
|
int i;
|
|
|
|
for (num&=0xfff0, i=0 ; dec_tab[i] <= num ; i++) {
|
|
start_pos++;
|
|
}
|
|
rar_addbits(unpack_data, start_pos);
|
|
return (((num-(i ? dec_tab[i-1]:0)) >> (16-start_pos)) + pos_tab[start_pos]);
|
|
}
|
|
|
|
static void huff_decode(unpack_data_t *unpack_data)
|
|
{
|
|
unsigned int cur_byte, new_byte_place, length, distance, bit_field;
|
|
int byte_place;
|
|
|
|
bit_field = rar_getbits(unpack_data);
|
|
|
|
if (unpack_data->avr_plc > 0x75ff) {
|
|
byte_place = decode_num(unpack_data, bit_field,
|
|
STARTHF4, dec_hf4, pos_hf4);
|
|
} else if (unpack_data->avr_plc > 0x5dff) {
|
|
byte_place = decode_num(unpack_data, bit_field,
|
|
STARTHF3, dec_hf3, pos_hf3);
|
|
} else if (unpack_data->avr_plc > 0x35ff) {
|
|
byte_place = decode_num(unpack_data, bit_field,
|
|
STARTHF2, dec_hf2, pos_hf2);
|
|
} else if (unpack_data->avr_plc > 0x0dff) {
|
|
byte_place = decode_num(unpack_data, bit_field,
|
|
STARTHF1, dec_hf1, pos_hf1);
|
|
} else {
|
|
byte_place = decode_num(unpack_data, bit_field,
|
|
STARTHF0, dec_hf0, pos_hf0);
|
|
}
|
|
|
|
byte_place &= 0xff;
|
|
if (unpack_data->st_mode) {
|
|
if (byte_place == 0 && bit_field > 0xfff) {
|
|
byte_place = 0x100;
|
|
}
|
|
if (--byte_place == -1) {
|
|
bit_field = rar_getbits(unpack_data);
|
|
rar_addbits(unpack_data, 1);
|
|
if (bit_field & 0x8000) {
|
|
unpack_data->num_huf = unpack_data->st_mode = 0;
|
|
return;
|
|
} else {
|
|
length = (bit_field & 0x4000) ? 4 : 3;
|
|
rar_addbits(unpack_data, 1);
|
|
distance = decode_num(unpack_data, rar_getbits(unpack_data),
|
|
STARTHF2, dec_hf2, pos_hf2);
|
|
distance = (distance << 5) | (rar_getbits(unpack_data) >> 11);
|
|
rar_addbits(unpack_data, 5);
|
|
copy_string15(unpack_data, distance, length);
|
|
return;
|
|
}
|
|
}
|
|
} else if (unpack_data->num_huf++ >= 16 && unpack_data->flags_cnt == 0) {
|
|
unpack_data->st_mode = 1;
|
|
}
|
|
unpack_data->avr_plc += byte_place;
|
|
unpack_data->avr_plc -= unpack_data->avr_plc >> 8;
|
|
unpack_data->nhfb += 16;
|
|
if (unpack_data->nhfb > 0xff) {
|
|
unpack_data->nhfb = 0x90;
|
|
unpack_data->nlzb >>= 1;
|
|
}
|
|
|
|
unpack_data->window[unpack_data->unp_ptr++] =
|
|
(unsigned char) (unpack_data->chset[byte_place & 0xff] >>8);
|
|
--unpack_data->dest_unp_size;
|
|
|
|
while (1) {
|
|
cur_byte = unpack_data->chset[byte_place & 0xff];
|
|
new_byte_place = unpack_data->ntopl[cur_byte++ & 0xff]++;
|
|
if ((cur_byte & 0xff) > 0xa1) {
|
|
corr_huff(unpack_data, unpack_data->chset, unpack_data->ntopl);
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
unpack_data->chset[byte_place & 0xff] = unpack_data->chset[new_byte_place & 0xff];
|
|
unpack_data->chset[new_byte_place & 0xff] = cur_byte;
|
|
}
|
|
|
|
|
|
|
|
static void get_flag_buf(unpack_data_t *unpack_data)
|
|
{
|
|
unsigned int flags, new_flags_place, flags_place;
|
|
|
|
flags_place = decode_num(unpack_data, rar_getbits(unpack_data), STARTHF2,
|
|
dec_hf2, pos_hf2);
|
|
for (;;) {
|
|
flags = unpack_data->chsetc[flags_place & 0xff];
|
|
unpack_data->flag_buf = flags >> 8;
|
|
new_flags_place = unpack_data->ntoplc[flags++ & 0xff]++;
|
|
if ((flags & 0xff) != 0) {
|
|
break;
|
|
}
|
|
corr_huff(unpack_data, unpack_data->chsetc, unpack_data->ntoplc);
|
|
}
|
|
unpack_data->chsetc[flags_place & 0xff] = unpack_data->chsetc[new_flags_place & 0xff];
|
|
unpack_data->chsetc[new_flags_place & 0xff] = flags;
|
|
}
|
|
|
|
static void short_lz(unpack_data_t *unpack_data)
|
|
{
|
|
static unsigned int short_len1[]={1,3,4,4,5,6,7,8,8,4,4,5,6,6,4,0};
|
|
static unsigned int short_xor1[]={0,0xa0,0xd0,0xe0,0xf0,0xf8,0xfc,0xfe,
|
|
0xff,0xc0,0x80,0x90,0x98,0x9c,0xb0};
|
|
static unsigned int short_len2[]={2,3,3,3,4,4,5,6,6,4,4,5,6,6,4,0};
|
|
static unsigned int short_xor2[]={0,0x40,0x60,0xa0,0xd0,0xe0,0xf0,0xf8,
|
|
0xfc,0xc0,0x80,0x90,0x98,0x9c,0xb0};
|
|
|
|
unsigned int length, save_length, last_distance, distance, bit_field;
|
|
int distance_place;
|
|
|
|
unpack_data->num_huf = 0;
|
|
bit_field = rar_getbits(unpack_data);
|
|
if (unpack_data->lcount == 2) {
|
|
rar_addbits(unpack_data, 1);
|
|
if (bit_field >= 0x8000) {
|
|
copy_string15(unpack_data,
|
|
(unsigned int)unpack_data->last_dist,
|
|
unpack_data->last_length);
|
|
return;
|
|
}
|
|
bit_field <<= 1;
|
|
unpack_data->lcount = 0;
|
|
}
|
|
|
|
bit_field >>= 8;
|
|
short_len1[1] = short_len2[3] = unpack_data->buf60+3;
|
|
if (unpack_data->avr_ln1 < 37) {
|
|
for (length=0 ;; length++) {
|
|
if (((bit_field^short_xor1[length]) &
|
|
(~(0xff>>short_len1[length]))) == 0) {
|
|
break;
|
|
}
|
|
}
|
|
rar_addbits(unpack_data, short_len1[length]);
|
|
} else {
|
|
for (length=0; ;length++) {
|
|
if (((bit_field^short_xor2[length]) &
|
|
(~(0xff>>short_len2[length]))) == 0) {
|
|
break;
|
|
}
|
|
}
|
|
rar_addbits(unpack_data, short_len2[length]);
|
|
}
|
|
|
|
if (length >= 9) {
|
|
if (length == 9) {
|
|
unpack_data->lcount++;
|
|
copy_string15(unpack_data, (unsigned int) unpack_data->last_dist,
|
|
unpack_data->last_length);
|
|
return;
|
|
}
|
|
if (length == 14) {
|
|
unpack_data->lcount = 0;
|
|
length = decode_num(unpack_data, rar_getbits(unpack_data),
|
|
STARTL2, dec_l2, pos_l2) + 5;
|
|
distance = (rar_getbits(unpack_data) >> 1) | 0x8000;
|
|
rar_addbits(unpack_data, 15);
|
|
unpack_data->last_length = length;
|
|
unpack_data->last_dist = distance;
|
|
copy_string15(unpack_data, distance, length);
|
|
return;
|
|
}
|
|
|
|
unpack_data->lcount = 0;
|
|
save_length = length;
|
|
distance = unpack_data->old_dist[(unpack_data->old_dist_ptr-(length-9)) & 3];
|
|
length = decode_num(unpack_data,
|
|
rar_getbits(unpack_data), STARTL1, dec_l1, pos_l1) + 2;
|
|
if (length == 0x101 && save_length == 10) {
|
|
unpack_data->buf60 ^= 1;
|
|
return;
|
|
}
|
|
if (distance > 256) {
|
|
length++;
|
|
}
|
|
if (distance >= unpack_data->max_dist3) {
|
|
length++;
|
|
}
|
|
|
|
unpack_data->old_dist[unpack_data->old_dist_ptr++] = distance;
|
|
unpack_data->old_dist_ptr = unpack_data->old_dist_ptr & 3;
|
|
unpack_data->last_length = length;
|
|
unpack_data->last_dist = distance;
|
|
copy_string15(unpack_data, distance, length);
|
|
return;
|
|
}
|
|
|
|
unpack_data->lcount = 0;
|
|
unpack_data->avr_ln1 += length;
|
|
unpack_data->avr_ln1 -= unpack_data->avr_ln1 >> 4;
|
|
|
|
distance_place = decode_num(unpack_data, rar_getbits(unpack_data),
|
|
STARTHF2, dec_hf2, pos_hf2) & 0xff;
|
|
distance = unpack_data->chseta[distance_place & 0xff];
|
|
if (--distance_place != -1) {
|
|
unpack_data->placea[distance & 0xff]--;
|
|
last_distance = unpack_data->chseta[distance_place & 0xff];
|
|
unpack_data->placea[last_distance & 0xff]++;
|
|
unpack_data->chseta[(distance_place+1) & 0xff] = last_distance;
|
|
unpack_data->chseta[distance_place & 0xff] = distance;
|
|
}
|
|
length += 2;
|
|
unpack_data->old_dist[unpack_data->old_dist_ptr++] = ++distance;
|
|
unpack_data->old_dist_ptr = unpack_data->old_dist_ptr & 3;
|
|
unpack_data->last_length = length;
|
|
unpack_data->last_dist = distance;
|
|
copy_string15(unpack_data, distance, length);
|
|
}
|
|
|
|
static void long_lz(unpack_data_t *unpack_data)
|
|
{
|
|
unsigned int length, distance, distance_place, new_distance_place;
|
|
unsigned int old_avr2, old_avr3, bit_field;
|
|
|
|
unpack_data->num_huf = 0;
|
|
unpack_data->nlzb += 16;
|
|
|
|
if (unpack_data->nlzb > 0xff) {
|
|
unpack_data->nlzb = 0x90;
|
|
unpack_data->nhfb >>= 1;
|
|
}
|
|
old_avr2 = unpack_data->avr_ln2;
|
|
|
|
bit_field = rar_getbits(unpack_data);
|
|
if (unpack_data->avr_ln2 >= 122) {
|
|
length = decode_num(unpack_data, bit_field, STARTL2, dec_l2, pos_l2);
|
|
} else if (unpack_data->avr_ln2 >= 64) {
|
|
length = decode_num(unpack_data, bit_field, STARTL1, dec_l1, pos_l1);
|
|
} else if (bit_field < 0x100) {
|
|
length = bit_field;
|
|
rar_addbits(unpack_data, 16);
|
|
} else {
|
|
for (length=0 ; ((bit_field << length) & 0x8000)==0 ; length++) {
|
|
/* Empty loop */
|
|
}
|
|
rar_addbits(unpack_data, length+1);
|
|
}
|
|
|
|
unpack_data->avr_ln2 += length;
|
|
unpack_data->avr_ln2 -= unpack_data->avr_ln2 >> 5;
|
|
|
|
bit_field = rar_getbits(unpack_data);
|
|
if (unpack_data->avr_plcb > 0x28ff) {
|
|
distance_place = decode_num(unpack_data, bit_field, STARTHF2,
|
|
dec_hf2, pos_hf2);
|
|
} else if (unpack_data->avr_plcb > 0x6ff) {
|
|
distance_place = decode_num(unpack_data, bit_field, STARTHF1,
|
|
dec_hf1, pos_hf1);
|
|
} else {
|
|
distance_place = decode_num(unpack_data, bit_field, STARTHF0,
|
|
dec_hf0, pos_hf0);
|
|
}
|
|
|
|
unpack_data->avr_plcb += distance_place;
|
|
unpack_data->avr_plcb -= unpack_data->avr_plcb >> 8;
|
|
for (;;) {
|
|
distance = unpack_data->chsetb[distance_place & 0xff];
|
|
new_distance_place = unpack_data->ntoplb[distance++ & 0xff]++;
|
|
if (!(distance & 0xff)) {
|
|
corr_huff(unpack_data, unpack_data->chsetb, unpack_data->ntoplb);
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
unpack_data->chsetb[distance_place & 0xff] = unpack_data->chsetb[new_distance_place & 0xff];
|
|
unpack_data->chsetb[new_distance_place & 0xff] = distance;
|
|
|
|
distance = ((distance & 0xff00) | (rar_getbits(unpack_data) >> 8)) >> 1;
|
|
rar_addbits(unpack_data, 7);
|
|
|
|
old_avr3 = unpack_data->avr_ln3;
|
|
if (length != 1 && length != 4) {
|
|
if (length==0 && distance <= unpack_data->max_dist3) {
|
|
unpack_data->avr_ln3++;
|
|
unpack_data->avr_ln3 -= unpack_data->avr_ln3 >> 8;
|
|
} else if (unpack_data->avr_ln3 > 0) {
|
|
unpack_data->avr_ln3--;
|
|
}
|
|
}
|
|
|
|
length += 3;
|
|
|
|
if (distance >= unpack_data->max_dist3) {
|
|
length++;
|
|
}
|
|
if (distance <= 256) {
|
|
length += 8;
|
|
}
|
|
if (old_avr3 > 0xb0 || (unpack_data->avr_plc >= 0x2a00 && old_avr2 < 0x40)) {
|
|
unpack_data->max_dist3 = 0x7f00;
|
|
} else {
|
|
unpack_data->max_dist3 = 0x2001;
|
|
}
|
|
unpack_data->old_dist[unpack_data->old_dist_ptr++] = distance;
|
|
unpack_data->old_dist_ptr = unpack_data->old_dist_ptr & 3;
|
|
unpack_data->last_length = length;
|
|
unpack_data->last_dist = distance;
|
|
copy_string15(unpack_data, distance, length);
|
|
}
|
|
|
|
int rar_unpack15(int fd, int solid, unpack_data_t *unpack_data)
|
|
{
|
|
rar_unpack_init_data(solid, unpack_data);
|
|
unpack_init_data15(solid, unpack_data);
|
|
if (!rar_unp_read_buf(fd, unpack_data)) {
|
|
return FALSE;
|
|
}
|
|
if (!solid) {
|
|
init_huff(unpack_data);
|
|
unpack_data->unp_ptr = 0;
|
|
} else {
|
|
unpack_data->unp_ptr = unpack_data->wr_ptr;
|
|
}
|
|
--unpack_data->dest_unp_size;
|
|
|
|
if (unpack_data->dest_unp_size >= 0) {
|
|
get_flag_buf(unpack_data);
|
|
unpack_data->flags_cnt = 8;
|
|
}
|
|
|
|
while (unpack_data->dest_unp_size >= 0) {
|
|
unpack_data->unp_ptr &= MAXWINMASK;
|
|
|
|
if (unpack_data->in_addr > unpack_data->read_top-30 &&
|
|
!rar_unp_read_buf(fd, unpack_data)) {
|
|
break;
|
|
}
|
|
|
|
if (((unpack_data->wr_ptr - unpack_data->unp_ptr) & MAXWINMASK) < 270 &&
|
|
(unpack_data->wr_ptr != unpack_data->unp_ptr)) {
|
|
rar_unp_write_buf_old(unpack_data);
|
|
}
|
|
if (unpack_data->st_mode) {
|
|
huff_decode(unpack_data);
|
|
continue;
|
|
}
|
|
|
|
if (--unpack_data->flags_cnt < 0) {
|
|
get_flag_buf(unpack_data);
|
|
unpack_data->flags_cnt = 7;
|
|
}
|
|
|
|
if (unpack_data->flag_buf & 0x80) {
|
|
unpack_data->flag_buf <<= 1;
|
|
if (unpack_data->nlzb > unpack_data->nhfb) {
|
|
long_lz(unpack_data);
|
|
} else {
|
|
huff_decode(unpack_data);
|
|
}
|
|
} else {
|
|
unpack_data->flag_buf <<= 1;
|
|
if (--unpack_data->flags_cnt < 0) {
|
|
get_flag_buf(unpack_data);
|
|
unpack_data->flags_cnt = 7;
|
|
}
|
|
if (unpack_data->flag_buf & 0x80) {
|
|
unpack_data->flag_buf <<= 1;
|
|
if (unpack_data->nlzb > unpack_data->nhfb) {
|
|
huff_decode(unpack_data);
|
|
} else {
|
|
long_lz(unpack_data);
|
|
}
|
|
} else {
|
|
unpack_data->flag_buf <<= 1;
|
|
short_lz(unpack_data);
|
|
}
|
|
}
|
|
}
|
|
rar_unp_write_buf_old(unpack_data);
|
|
return TRUE;
|
|
}
|
|
|