libreoffice/package/source/manifest/ManifestImport.cxx

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */

#include <ManifestImport.hxx>
#include <ManifestDefines.hxx>
#include <sax/tools/converter.hxx>
#include <osl/diagnose.h>
#include <com/sun/star/xml/sax/XAttributeList.hpp>
#include <com/sun/star/xml/crypto/DigestID.hpp>
#include <com/sun/star/xml/crypto/CipherID.hpp>
#include <com/sun/star/beans/PropertyValue.hpp>
#include <comphelper/sequence.hxx>

using namespace com::sun::star::uno;
using namespace com::sun::star::beans;
using namespace com::sun::star;
using namespace std;

ManifestImport::ManifestImport( vector < Sequence < PropertyValue > > & rNewManVector )
: bIgnoreEncryptData    ( false )
, nDerivedKeySize( 0 )
, rManVector ( rNewManVector )

, sFileEntryElement     ( ELEMENT_FILE_ENTRY )
, sManifestElement      ( ELEMENT_MANIFEST )
, sEncryptionDataElement( ELEMENT_ENCRYPTION_DATA )
, sAlgorithmElement ( ELEMENT_ALGORITHM )
, sStartKeyAlgElement   ( ELEMENT_START_KEY_GENERATION )
, sKeyDerivationElement( ELEMENT_KEY_DERIVATION )

, sCdataAttribute               ( ATTRIBUTE_CDATA )
, sMediaTypeAttribute           ( ATTRIBUTE_MEDIA_TYPE )
, sVersionAttribute             ( ATTRIBUTE_VERSION )
, sFullPathAttribute            ( ATTRIBUTE_FULL_PATH )
, sSizeAttribute                ( ATTRIBUTE_SIZE )
, sSaltAttribute                ( ATTRIBUTE_SALT )
, sInitialisationVectorAttribute ( ATTRIBUTE_INITIALISATION_VECTOR )
, sIterationCountAttribute      ( ATTRIBUTE_ITERATION_COUNT )
, sKeySizeAttribute             ( ATTRIBUTE_KEY_SIZE )
, sAlgorithmNameAttribute       ( ATTRIBUTE_ALGORITHM_NAME )
, sStartKeyAlgNameAttribute     ( ATTRIBUTE_START_KEY_GENERATION_NAME )
, sKeyDerivationNameAttribute   ( ATTRIBUTE_KEY_DERIVATION_NAME )
, sChecksumAttribute            ( ATTRIBUTE_CHECKSUM )
, sChecksumTypeAttribute        ( ATTRIBUTE_CHECKSUM_TYPE )

, sFullPathProperty             ( "FullPath" )
, sMediaTypeProperty            ( "MediaType" )
, sVersionProperty              ( "Version" )
, sIterationCountProperty       ( "IterationCount" )
, sDerivedKeySizeProperty       ( "DerivedKeySize" )
, sSaltProperty                 ( "Salt" )
, sInitialisationVectorProperty ( "InitialisationVector" )
, sSizeProperty                 ( "Size" )
, sDigestProperty               ( "Digest" )
, sEncryptionAlgProperty        ( "EncryptionAlgorithm" )
, sStartKeyAlgProperty          ( "StartKeyAlgorithm" )
, sDigestAlgProperty            ( "DigestAlgorithm" )

, sWhiteSpace                   ( " " )

, sSHA256_URL                   ( SHA256_URL )
, sSHA1_Name                    ( SHA1_NAME )
, sSHA1_URL                     ( SHA1_URL )

, sSHA256_1k_URL                ( SHA256_1K_URL )
, sSHA1_1k_Name                 ( SHA1_1K_NAME )
, sSHA1_1k_URL                  ( SHA1_1K_URL )

, sBlowfish_Name                ( BLOWFISH_NAME )
, sBlowfish_URL                 ( BLOWFISH_URL )
, sAES128_URL                   ( AES128_URL )
, sAES192_URL                   ( AES192_URL )
, sAES256_URL                   ( AES256_URL )

, sPBKDF2_Name                  ( PBKDF2_NAME )
, sPBKDF2_URL                   ( PBKDF2_URL )
{
    aStack.reserve( 10 );
}

ManifestImport::~ManifestImport()
{
}

void SAL_CALL ManifestImport::startDocument(  )
        throw( xml::sax::SAXException, uno::RuntimeException, std::exception )
{
}

void SAL_CALL ManifestImport::endDocument(  )
        throw( xml::sax::SAXException, uno::RuntimeException, std::exception )
{
}

void ManifestImport::doFileEntry(StringHashMap &rConvertedAttribs)
        throw( uno::RuntimeException )
{
    aSequence.resize(PKG_SIZE_ENCR_MNFST);

    aSequence[PKG_MNFST_FULLPATH].Name = sFullPathProperty;
    aSequence[PKG_MNFST_FULLPATH].Value <<= rConvertedAttribs[sFullPathAttribute];
    aSequence[PKG_MNFST_MEDIATYPE].Name = sMediaTypeProperty;
    aSequence[PKG_MNFST_MEDIATYPE].Value <<= rConvertedAttribs[sMediaTypeAttribute];

    OUString sVersion = rConvertedAttribs[sVersionAttribute];
    if ( sVersion.getLength() )
    {
        aSequence[PKG_MNFST_VERSION].Name = sVersionProperty;
        aSequence[PKG_MNFST_VERSION].Value <<= sVersion;
    }

    OUString sSize = rConvertedAttribs[sSizeAttribute];
    if ( sSize.getLength() )
    {
        sal_Int64 nSize = sSize.toInt64();
        aSequence[PKG_MNFST_UCOMPSIZE].Name = sSizeProperty;
        aSequence[PKG_MNFST_UCOMPSIZE].Value <<= nSize;
    }
}

void ManifestImport::doEncryptionData(StringHashMap &rConvertedAttribs)
        throw( uno::RuntimeException )
{
    // If this element exists, then this stream is encrypted and we need
    // to import the initialisation vector, salt and iteration count used
    nDerivedKeySize = 0;
    OUString aString = rConvertedAttribs[sChecksumTypeAttribute];
    if ( !bIgnoreEncryptData )
    {
        if ( aString.equals( sSHA1_1k_Name ) || aString.equals( sSHA1_1k_URL ) )
        {
            aSequence[PKG_MNFST_DIGESTALG].Name = sDigestAlgProperty;
            aSequence[PKG_MNFST_DIGESTALG].Value <<= xml::crypto::DigestID::SHA1_1K;
        }
        else if ( aString.equals( sSHA256_1k_URL ) )
        {
            aSequence[PKG_MNFST_DIGESTALG].Name = sDigestAlgProperty;
            aSequence[PKG_MNFST_DIGESTALG].Value <<= xml::crypto::DigestID::SHA256_1K;
        }
        else
            bIgnoreEncryptData = true;

        if ( !bIgnoreEncryptData )
        {
            aString = rConvertedAttribs[sChecksumAttribute];
            uno::Sequence < sal_Int8 > aDecodeBuffer;
            ::sax::Converter::decodeBase64(aDecodeBuffer, aString);
            aSequence[PKG_MNFST_DIGEST].Name = sDigestProperty;
            aSequence[PKG_MNFST_DIGEST].Value <<= aDecodeBuffer;
        }
    }
}

void ManifestImport::doAlgorithm(StringHashMap &rConvertedAttribs)
        throw( uno::RuntimeException )
{
    if ( !bIgnoreEncryptData )
    {
        OUString aString = rConvertedAttribs[sAlgorithmNameAttribute];
        if ( aString.equals( sBlowfish_Name ) || aString.equals( sBlowfish_URL ) )
        {
            aSequence[PKG_MNFST_ENCALG].Name = sEncryptionAlgProperty;
            aSequence[PKG_MNFST_ENCALG].Value <<= xml::crypto::CipherID::BLOWFISH_CFB_8;
        }
        else if ( aString.equals( sAES256_URL ) )
        {
            aSequence[PKG_MNFST_ENCALG].Name = sEncryptionAlgProperty;
            aSequence[PKG_MNFST_ENCALG].Value <<= xml::crypto::CipherID::AES_CBC_W3C_PADDING;
            OSL_ENSURE( !nDerivedKeySize || nDerivedKeySize == 32, "Unexpected derived key length!" );
            nDerivedKeySize = 32;
        }
        else if ( aString.equals( sAES192_URL ) )
        {
            aSequence[PKG_MNFST_ENCALG].Name = sEncryptionAlgProperty;
            aSequence[PKG_MNFST_ENCALG].Value <<= xml::crypto::CipherID::AES_CBC_W3C_PADDING;
            OSL_ENSURE( !nDerivedKeySize || nDerivedKeySize == 24, "Unexpected derived key length!" );
            nDerivedKeySize = 24;
        }
        else if ( aString.equals( sAES128_URL ) )
        {
            aSequence[PKG_MNFST_ENCALG].Name = sEncryptionAlgProperty;
            aSequence[PKG_MNFST_ENCALG].Value <<= xml::crypto::CipherID::AES_CBC_W3C_PADDING;
            OSL_ENSURE( !nDerivedKeySize || nDerivedKeySize == 16, "Unexpected derived key length!" );
            nDerivedKeySize = 16;
        }
        else
            bIgnoreEncryptData = true;

        if ( !bIgnoreEncryptData )
        {
            aString = rConvertedAttribs[sInitialisationVectorAttribute];
            uno::Sequence < sal_Int8 > aDecodeBuffer;
            ::sax::Converter::decodeBase64(aDecodeBuffer, aString);
            aSequence[PKG_MNFST_INIVECTOR].Name = sInitialisationVectorProperty;
            aSequence[PKG_MNFST_INIVECTOR].Value <<= aDecodeBuffer;
        }
    }
}

void ManifestImport::doKeyDerivation(StringHashMap &rConvertedAttribs)
        throw( uno::RuntimeException )
{
    if ( !bIgnoreEncryptData )
    {
        OUString aString = rConvertedAttribs[sKeyDerivationNameAttribute];
        if ( aString.equals( sPBKDF2_Name ) || aString.equals( sPBKDF2_URL ) )
        {
            aString = rConvertedAttribs[sSaltAttribute];
            uno::Sequence < sal_Int8 > aDecodeBuffer;
            ::sax::Converter::decodeBase64(aDecodeBuffer, aString);
            aSequence[PKG_MNFST_SALT].Name = sSaltProperty;
            aSequence[PKG_MNFST_SALT].Value <<= aDecodeBuffer;

            aString = rConvertedAttribs[sIterationCountAttribute];
            aSequence[PKG_MNFST_ITERATION].Name = sIterationCountProperty;
            aSequence[PKG_MNFST_ITERATION].Value <<= aString.toInt32();

            aString = rConvertedAttribs[sKeySizeAttribute];
            if ( aString.getLength() )
            {
                sal_Int32 nKey = aString.toInt32();
                OSL_ENSURE( !nDerivedKeySize || nKey == nDerivedKeySize , "Provided derived key length differs from the expected one!" );
                nDerivedKeySize = nKey;
            }
            else if ( !nDerivedKeySize )
                nDerivedKeySize = 16;
            else if ( nDerivedKeySize != 16 )
                OSL_ENSURE( false, "Default derived key length differs from the expected one!" );

            aSequence[PKG_MNFST_DERKEYSIZE].Name = sDerivedKeySizeProperty;
            aSequence[PKG_MNFST_DERKEYSIZE].Value <<= nDerivedKeySize;
        }
        else
            bIgnoreEncryptData = true;
    }
}

void ManifestImport::doStartKeyAlg(StringHashMap &rConvertedAttribs)
        throw( uno::RuntimeException )
{
    OUString aString = rConvertedAttribs[sStartKeyAlgNameAttribute];
    if ( aString.equals( sSHA256_URL ) )
    {
        aSequence[PKG_MNFST_STARTALG].Name = sStartKeyAlgProperty;
        aSequence[PKG_MNFST_STARTALG].Value <<= xml::crypto::DigestID::SHA256;
    }
    else if ( aString.equals( sSHA1_Name ) || aString.equals( sSHA1_URL ) )
    {
        aSequence[PKG_MNFST_STARTALG].Name = sStartKeyAlgProperty;
        aSequence[PKG_MNFST_STARTALG].Value <<= xml::crypto::DigestID::SHA1;
    }
    else
        bIgnoreEncryptData = true;
}

void SAL_CALL ManifestImport::startElement( const OUString& aName, const uno::Reference< xml::sax::XAttributeList >& xAttribs )
        throw( xml::sax::SAXException, uno::RuntimeException, std::exception )
{
    StringHashMap aConvertedAttribs;
    OUString aConvertedName = PushNameAndNamespaces( aName, xAttribs, aConvertedAttribs );

    size_t nLevel = aStack.size();

    assert(nLevel >= 1);

    switch (nLevel)
    {
        case 1:
        {
            if (aConvertedName != ELEMENT_MANIFEST) //manifest:manifest
                aStack.back().m_bValid = false;
            break;
        }
        case 2:
        {
            if (aConvertedName == sFileEntryElement) //manifest:file-entry
                doFileEntry(aConvertedAttribs);
            else
                aStack.back().m_bValid = false;
            break;
        }
        case 3:
        {
            ManifestStack::reverse_iterator aIter = aStack.rbegin();
            ++aIter;

            if (!aIter->m_bValid)
                aStack.back().m_bValid = false;
            else if (aConvertedName.equals(sEncryptionDataElement))   //manifest:encryption-data
                doEncryptionData(aConvertedAttribs);
            else
                aStack.back().m_bValid = false;
            break;
        }
        case 4:
        {
            ManifestStack::reverse_iterator aIter = aStack.rbegin();
            ++aIter;

            if (!aIter->m_bValid)
                aStack.back().m_bValid = false;
            else if (aConvertedName.equals(sAlgorithmElement))   //manifest:algorithm,
                doAlgorithm(aConvertedAttribs);
            else if (aConvertedName.equals(sKeyDerivationElement)) //manifest:key-derivation,
                doKeyDerivation(aConvertedAttribs);
            else if (aConvertedName.equals(sStartKeyAlgElement))   //manifest:start-key-generation
                doStartKeyAlg(aConvertedAttribs);
            else
                aStack.back().m_bValid = false;
            break;
        }
        default:
            aStack.back().m_bValid = false;
            break;
    }
}

namespace
{
    bool isEmpty(const com::sun::star::beans::PropertyValue &rProp)
    {
        return rProp.Name.isEmpty();
    }
}

void SAL_CALL ManifestImport::endElement( const OUString& aName )
    throw( xml::sax::SAXException, uno::RuntimeException, std::exception )
{
    OUString aConvertedName = ConvertName( aName );
    if ( !aStack.empty() && aStack.rbegin()->m_aConvertedName.equals( aConvertedName ) )
    {
        if ( aConvertedName.equals( sFileEntryElement ) && aStack.back().m_bValid )
        {
            com::sun::star::beans::PropertyValue aEmpty;
            aSequence.erase(std::remove_if(aSequence.begin(), aSequence.end(),
                isEmpty), aSequence.end());

            bIgnoreEncryptData = false;
            rManVector.push_back ( comphelper::containerToSequence(aSequence) );

            aSequence.clear();
        }

        aStack.pop_back();
    }
}

void SAL_CALL ManifestImport::characters( const OUString& /*aChars*/ )
        throw( xml::sax::SAXException, uno::RuntimeException, std::exception )
{
}

void SAL_CALL ManifestImport::ignorableWhitespace( const OUString& /*aWhitespaces*/ )
        throw( xml::sax::SAXException, uno::RuntimeException, std::exception )
{
}

void SAL_CALL ManifestImport::processingInstruction( const OUString& /*aTarget*/, const OUString& /*aData*/ )
        throw( xml::sax::SAXException, uno::RuntimeException, std::exception )
{
}

void SAL_CALL ManifestImport::setDocumentLocator( const uno::Reference< xml::sax::XLocator >& /*xLocator*/ )
        throw( xml::sax::SAXException, uno::RuntimeException, std::exception )
{
}

OUString ManifestImport::PushNameAndNamespaces( const OUString& aName, const uno::Reference< xml::sax::XAttributeList >& xAttribs, StringHashMap& o_aConvertedAttribs )
{
    StringHashMap aNamespaces;
    ::std::vector< ::std::pair< OUString, OUString > > aAttribsStrs;

    if ( xAttribs.is() )
    {
        sal_Int16 nAttrCount = xAttribs.is() ? xAttribs->getLength() : 0;
        aAttribsStrs.reserve( nAttrCount );

        for( sal_Int16 nInd = 0; nInd < nAttrCount; nInd++ )
        {
            OUString aAttrName = xAttribs->getNameByIndex( nInd );
            OUString aAttrValue = xAttribs->getValueByIndex( nInd );
            if ( aAttrName.getLength() >= 5
              && aAttrName.startsWith("xmlns")
              && ( aAttrName.getLength() == 5 || aAttrName[5] == ':' ) )
            {
                // this is a namespace declaration
                OUString aNsName( ( aAttrName.getLength() == 5 ) ? OUString() : aAttrName.copy( 6 ) );
                aNamespaces[aNsName] = aAttrValue;
            }
            else
            {
                // this is no namespace declaration
                aAttribsStrs.push_back( pair< OUString, OUString >( aAttrName, aAttrValue ) );
            }
        }
    }

    OUString aConvertedName = ConvertNameWithNamespace( aName, aNamespaces );
    if ( !aConvertedName.getLength() )
        aConvertedName = ConvertName( aName );

    aStack.push_back( ManifestScopeEntry( aConvertedName, aNamespaces ) );

    for ( size_t nInd = 0; nInd < aAttribsStrs.size(); nInd++ )
    {
        // convert the attribute names on filling
        o_aConvertedAttribs[ConvertName( aAttribsStrs[nInd].first )] = aAttribsStrs[nInd].second;
    }

    return aConvertedName;
}

OUString ManifestImport::ConvertNameWithNamespace( const OUString& aName, const StringHashMap& aNamespaces )
{
    OUString aNsAlias;
    OUString aPureName = aName;

    sal_Int32 nInd = aName.indexOf( ( sal_Unicode )':' );
    if ( nInd != -1 && nInd < aName.getLength() )
    {
        aNsAlias = aName.copy( 0, nInd );
        aPureName = aName.copy( nInd + 1 );
    }

    OUString aResult;

    StringHashMap::const_iterator aIter = aNamespaces.find( aNsAlias );
    if ( aIter != aNamespaces.end()
      && ( aIter->second == MANIFEST_NAMESPACE || aIter->second == MANIFEST_OASIS_NAMESPACE ) )
    {
        // no check for manifest.xml consistency currently since the old versions have supported inconsistent documents as well
        aResult = MANIFEST_NSPREFIX;
        aResult += aPureName;
    }

    return aResult;
}

OUString ManifestImport::ConvertName( const OUString& aName )
{
    OUString aConvertedName;
    for ( ManifestStack::reverse_iterator aIter = aStack.rbegin(); !aConvertedName.getLength() && aIter != aStack.rend(); ++aIter )
    {
        if ( !aIter->m_aNamespaces.empty() )
            aConvertedName = ConvertNameWithNamespace( aName, aIter->m_aNamespaces );
    }

    if ( !aConvertedName.getLength() )
        aConvertedName = aName;

    return aConvertedName;
}

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */