Vulnerabilidade de segurança no ParseExcel

TL;DR: RCE a partir de lógica na análise de strings de formato.

Explicação resumida sobre a exploração

A causa raiz da exploração vem da chamada de eval a uma entrada de usuário não validada em Utility.pm

https://github.com/jmcnamara/spreadsheet-parseexcel/blob/e33d626d9b9cec91be7520dec1686712313957fb/lib/Spreadsheet/ParseExcel/Utility.pm#L171

# Uitlity.pm
sub ExcelFmt {
	my ( $format_str, $number, $is_1904, $number_type, $want_subformats ) = @_;

	return $number unless $number =~ $qrNUMBER;
	
	my $conditional;
	if ( $format_str =~ /^\[([<>=][^\]]+)\](.*)$/ ) {
		$conditional = $1;
		$format_str  = $2;
	}

	#...

	if ($conditional) {
		# TODO. Replace string eval with a function.
		$section = eval "$number $conditional" ? 0 : 1;
	}
    #...
}

De acordo com o que inspecionei, a implementação atual desse fluxo carece de validação adequada, e usar eval para lidar com a lógica de comparação é exagero ("over kill") neste caso. Por causa disso, tanto ParseExcel::parse quanto ParseXLSX::parse (usados para ler dados de arquivos Excel) são vulneráveis a RCE.

Onde está $format_str?

ValFmt é o chamador mais provável de ExcelFmt, então vou explicar melhor esse método https://github.com/jmcnamara/spreadsheet-parseexcel/blob/e33d626d9b9cec91be7520dec1686712313957fb/lib/Spreadsheet/ParseExcel/FmtDefault.pm#L141-L161

sub ValFmt {
    my ( $oThis, $oCell, $oBook ) = @_;

    my ( $Dt, $iFmtIdx, $iNumeric, $Flg1904 );

    if ( $oCell->{Type} eq 'Text' ) {
        $Dt =
          ( ( defined $oCell->{Val} ) && ( $oCell->{Val} ne '' ) )
          ? $oThis->TextFmt( $oCell->{Val}, $oCell->{Code} ) # Perform some encoding logic => doesn't cause RCE
          : '';

        return $Dt;
    }
    else {
        $Dt      = $oCell->{Val};
        $Flg1904 = $oBook->{Flg1904};
        my $sFmtStr = $oThis->FmtString( $oCell, $oBook );

        # where RCE lies => $oCell->{Type} must be either "Date" or "Number"
        return ExcelFmt( $sFmtStr, $Dt, $Flg1904, $oCell->{Type} ); 
    }
}

Se $oCell->{Type} for Date ou Number, ExcelFmt será chamado.

O valor $format_str é o retorno de outro método: FmtString https://github.com/jmcnamara/spreadsheet-parseexcel/blob/e33d626d9b9cec91be7520dec1686712313957fb/lib/Spreadsheet/ParseExcel/FmtDefault.pm#L101-L136

sub FmtString {
    my ( $oThis, $oCell, $oBook ) = @_;

    my $sFmtStr =
      $oThis->FmtStringDef( $oBook->{Format}[ $oCell->{FormatNo} ]->{FmtIdx},
        $oBook ); # maps to the correct format string
        
    #...

    unless ( defined($sFmtStr) ) {
        # assigns default format string depending on the value, can ignore
        #...
    }
    return $sFmtStr;
}

Outra função é chamada, então vamos examinar também FmtStringDef https://github.com/jmcnamara/spreadsheet-parseexcel/blob/e33d626d9b9cec91be7520dec1686712313957fb/lib/Spreadsheet/ParseExcel/FmtDefault.pm#L87-L96

sub FmtStringDef {
    my ( $oThis, $iFmtIdx, $oBook, $rhFmt ) = @_;
    my $sFmtStr = $oBook->{FormatStr}->{$iFmtIdx}; # does the mapping

    # More with assigning default format string, can ignore
    #...
}

Todas as variáveis estão claras, podemos concluir o vetor de ataque da seguinte forma:

• Injete a string de formato maliciosa com o índice $iFmtIdx
• Garanta que um formato de célula $oBook->{Format}[$cellFmtIdx] aponte para $iFmtIdx
• Garanta que uma célula aponte para esse formato de célula ($oCell->{FormatNo} = $cellFmtIdx) ![[flow 1.png]]

Nas seções abaixo, vou detalhar como o payload propagou o código do shell até o comando eval. Haverá 2 seções: uma para parsing de arquivos .xls usando ParseExcel e outra para parsing de arquivos .xlsx usando ParseXLSX.

PoC

Para demonstrar, abaixo está o link para nossos arquivos Excel maliciosos criados (em .xls e .xlsx) que executam whoami e armazenam o resultado no arquivo /tmp/inject.txt. https://gist.github.com/haile01/0f4f19e4441895ef33ff27385080478b

Exploração em arquivo XLS

Considere um programa Perl simples para analisar arquivo xls como abaixo, que usa ParseExcel::parse. A RCE ocorrerá durante o parsing, antes mesmo de qualquer dado ser obtido.

use strict;
use Spreadsheet::ParseExcel;

my $parser = Spreadsheet::ParseExcel->new();
# file.xls is malicious file from end user
my $workbook = $parser->parse("test.xls");

Injetando a string de formato

Arquivos binários do Excel 97 são estruturados em blocos de dados binários chamados de registro BIFF. Cada registro começa com um cabeçalho chamado opCode (em little-endian), depois o comprimento do registro e seus dados reais.

https://github.com/jmcnamara/spreadsheet-parseexcel/blob/19ea68d2ebf640e06df4f6937fcb43d76a5ec96b/lib/Spreadsheet/ParseExcel.pm#L438

sub QueryNext {
    my ( $q ) = @_;


    if ( $q->{streamPos} + 4 >= $q->{streamLen} ) {
        return 0;
    }

    my $data = substr( $q->{stream}, $q->{streamPos}, 4 );

    ( $q->{opcode}, $q->{length} ) = unpack( 'v2', $data );

    # No biff record should be larger than around 20,000.
    if ( $q->{length} >= 20000 ) {
        return 0;
    }

    if ( $q->{length} > 0 ) {
        $q->{data} = substr( $q->{stream}, $q->{streamPos} + 4, $q->{length} );
    }
    else {
        $q->{data}                     = undef;
        $q->{dont_decrypt_next_record} = 1;
    }

    if ( $q->{encryption} == MS_BIFF_CRYPTO_RC4 ) {
        # Handles with decryption
    }
    elsif ( $q->{encryption} == MS_BIFF_CRYPTO_XOR ) {
        # not implemented
        return 0;
    }
    elsif ( $q->{encryption} == MS_BIFF_CRYPTO_NONE ) {

    }

    $q->{streamPos} += 4 + $q->{length};

    return 1;
}

Depois disso, um manipulador correspondente para o tipo de registro é usado para extrair os dados desse registro BIFF. https://github.com/jmcnamara/spreadsheet-parseexcel/blob/19ea68d2ebf640e06df4f6937fcb43d76a5ec96b/lib/Spreadsheet/ParseExcel.pm#L576-L580

if ( defined $self->{FuncTbl}->{$record} && !$workbook->{_skip_chart} )
{
		$self->{FuncTbl}->{$record}
			->( $workbook, $record, $record_length, $record_header );
}

A string de formato é tratada por _subFormat, com opCode = 0x41E https://github.com/jmcnamara/spreadsheet-parseexcel/blob/19ea68d2ebf640e06df4f6937fcb43d76a5ec96b/lib/Spreadsheet/ParseExcel.pm#L1563-L1585

sub _subFormat {

    my ( $oBook, $bOp, $bLen, $sWk ) = @_;
    my $sFmt;

    if ( $oBook->{BIFFVersion} <= verBIFF5 ) {
        $sFmt = substr( $sWk, 3, unpack( 'c', substr( $sWk, 2, 1 ) ) );
        $sFmt = $oBook->{FmtClass}->TextFmt( $sFmt, '_native_' );
    }
    else {
        $sFmt = _convBIFF8String( $oBook, substr( $sWk, 2 ) );
    }

    my $format_index = unpack( 'v', substr( $sWk, 0, 2 ) );

    # Excel 4 and earlier used an index of 0 to indicate that a built-in format
    # that was stored implicitly.
    if ( $oBook->{BIFFVersion} <= verBIFF4 && $format_index == 0 ) {
        $format_index = keys %{ $oBook->{FormatStr} };
    }

    $oBook->{FormatStr}->{$format_index} = $sFmt;
}

Não tinha certeza de qual versão do BIFF estava sendo usada no meu arquivo .xls, mas de acordo com os dados no arquivo binário, deve corresponder ao caso else (> verBIFF5).

A estrutura do registro de string de formato nas versões mais novas do BIFF deve ser 1E 04 [comprimento do registro - 2 bytes] [índice da string de formato - 2 bytes] [comprimento da string de formato - 1 byte] [flags da string - 2 bytes] [conteúdo da string de formato]

Seguindo a estrutura correta, posso injetar qualquer string de formato no arquivo .xls.