ParseExcel Sicherheitslücke

TL;DR: RCE durch Logik beim Parsen von Formatzeichenfolgen.

Kurze Erklärung des Exploits

Die Hauptursache des Exploits liegt im Aufruf von eval auf eine nicht validierte Benutzereingabe in 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;
	}
    #...
}

Nach meiner Inspektion fehlt der aktuellen Implementierung dieses Ablaufs eine ordnungsgemäße Validierung, während die Verwendung von eval für Vergleichslogiken in diesem Fall übertrieben ist. Aus diesem Grund sind sowohl ParseExcel::parse als auch ParseXLSX::parse (zum Lesen von Daten aus Excel-Dateien) anfällig für RCE.

Wo ist $format_str?

ValFmt ist der wahrscheinlichste Aufrufer von ExcelFmt, daher werde ich diese Methode näher erläutern. 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} ); 
    }
}

Wenn $oCell->{Type} Date oder Number ist, wird ExcelFmt aufgerufen.

Der Wert $format_str stammt aus einer anderen Methode: 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;
}

Eine weitere Funktion wird aufgerufen, also werden wir auch FmtStringDef untersuchen. 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
    #...
}

Alle Variablen sind klar, wir können den Angriffsvektor wie folgt zusammenfassen:

• Füge die bösartige Formatzeichenfolge mit Index $iFmtIdx ein
• Stelle sicher, dass ein Zellenformat $oBook->{Format}[$cellFmtIdx] auf $iFmtIdx verweist
• Stelle sicher, dass eine Zelle auf dieses Zellenformat verweist ($oCell->{FormatNo} = $cellFmtIdx) ![[flow 1.png]]

In den folgenden Abschnitten werde ich detailliert erklären, wie die Nutzlast den Shell-Code an den eval-Befehl weitergeleitet hat. Es wird zwei Abschnitte geben: für das Parsen von .xls-Dateien mit ParseExcel und für das Parsen von .xlsx-Dateien mit ParseXLSX.

PoC

Zur Demonstration finden Sie unten den Link zu unseren präparierten bösartigen Excel-Dateien (im .xls- und .xlsx-Format), die whoami ausführen und das Ergebnis in der Datei /tmp/inject.txt speichern. https://gist.github.com/haile01/0f4f19e4441895ef33ff27385080478b

Exploitation auf XLS-Datei

Nehmen Sie ein einfaches Perl-Programm zum Parsen einer xls-Datei wie unten, das ParseExcel::parse verwendet. RCE wird während des Parsens ausgelöst, noch bevor Daten abgerufen werden.

use strict;
use Spreadsheet::ParseExcel;

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

Einfügen der Formatzeichenfolge

Excel-97-Binärdateien sind in Blöcke von Binärdaten strukturiert, die als BIFF-Datensätze bezeichnet werden. Jeder Datensatz beginnt mit einem Header namens opCode (im Little-Endian-Format), gefolgt von der Länge des Datensatzes und seinen eigentlichen Daten.

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;
}

Danach wird ein entsprechender Handler für den Datensatztyp verwendet, um die BIFF-Datensatzdaten zu extrahieren. 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 );
}

Die Formatzeichenfolge wird von _subFormat mit opCode = 0x41E behandelt. 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;
}

Ich war mir nicht sicher, welche BIFF-Version in meiner .xls-Datei verwendet wurde, aber den Daten in der Binärdatei zufolge sollte sie dem else-Fall entsprechen (> verBIFF5).

Die Struktur des Formatzeichenfolgen-Datensatzes in neueren BIFF-Versionen sollte wie folgt sein: 1E 04 [Datensatzlänge - 2 Bytes] [Formatzeichenfolgen-Index - 2 Bytes] [Länge der Formatzeichenfolge - 1 Byte] [String-Flags - 2 Bytes] [Inhalt der Formatzeichenfolge]

Durch Befolgen der korrekten Struktur kann ich jede beliebige Formatzeichenfolge in die .xls-Datei einfügen.