xref: /aoo4110/main/package/source/manifest/ManifestImport.cxx (revision b1cdbd2c)

/**************************************************************
 *
 * 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
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



// MARKER( update_precomp.py ): autogen include statement, do not remove
#include "precompiled_package.hxx"
#include <ManifestImport.hxx>
#include <ManifestDefines.hxx>
#include <sax/tools/converter.hxx>

#include <com/sun/star/xml/sax/XAttributeList.hpp>
#include <com/sun/star/xml/crypto/DigestID.hpp>
#include <com/sun/star/xml/crypto/CipherID.hpp>

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

// helper for ignoring multiple settings of the same property
#define setProperty(e,v) do{ if(!maValues[e].hasValue()) maValues[e] <<= v;} while(0)

static const char* getMnfstPropName( int nManifestPropId )
{
	const char* pName;
	switch( nManifestPropId )
	{
		case PKG_MNFST_MEDIATYPE:	pName = "MediaType"; break;
		case PKG_MNFST_VERSION:		pName = "Version"; break;
		case PKG_MNFST_FULLPATH:	pName = "FullPath"; break;
		case PKG_MNFST_INIVECTOR:	pName = "InitialisationVector"; break;
		case PKG_MNFST_SALT:		pName = "Salt"; break;
		case PKG_MNFST_ITERATION:	pName = "IterationCount"; break;
		case PKG_MNFST_UCOMPSIZE:	pName = "Size"; break;
		case PKG_MNFST_DIGEST:		pName = "Digest"; break;
		case PKG_MNFST_ENCALG:		pName = "EncryptionAlgorithm"; break;
		case PKG_MNFST_STARTALG:	pName = "StartKeyAlgorithm"; break;
		case PKG_MNFST_DIGESTALG:	pName = "DigestAlgorithm"; break;
		case PKG_MNFST_DERKEYSIZE:	pName = "DerivedKeySize"; break;
		default: pName = NULL;
	}
	return pName;
}

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

, sCdataAttribute     			( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_CDATA ) )
, sMediaTypeAttribute 			( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_MEDIA_TYPE ) )
, sVersionAttribute 			( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_VERSION ) )
, sFullPathAttribute  			( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_FULL_PATH ) )
, sSizeAttribute 				( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_SIZE ) )
, sSaltAttribute 				( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_SALT ) )
, sInitialisationVectorAttribute(RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_INITIALISATION_VECTOR ) )
, sIterationCountAttribute 		( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_ITERATION_COUNT ) )
, sKeySizeAttribute            ( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_KEY_SIZE ) )
, sAlgorithmNameAttribute 		( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_ALGORITHM_NAME ) )
, sStartKeyAlgNameAttribute    ( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_START_KEY_GENERATION_NAME ) )
, sKeyDerivationNameAttribute 	( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_KEY_DERIVATION_NAME ) )
, sChecksumAttribute 			( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_CHECKSUM ) )
, sChecksumTypeAttribute 		( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_CHECKSUM_TYPE ) )
{
    aStack.reserve( 10 );
}

// ---------------------------------------------------
ManifestImport::~ManifestImport ( void )
{
}

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

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

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

	if ( aConvertedName.equalsAscii( ELEMENT_FILE_ENTRY ) )
	{
		setProperty( PKG_MNFST_FULLPATH, aConvertedAttribs[sFullPathAttribute]);
		setProperty( PKG_MNFST_MEDIATYPE, aConvertedAttribs[sMediaTypeAttribute]);

		const OUString& sVersion = aConvertedAttribs[sVersionAttribute];
        if ( sVersion.getLength() )
       		setProperty( PKG_MNFST_VERSION, sVersion );

		const OUString& sSize = aConvertedAttribs[sSizeAttribute];
		if ( sSize.getLength() )
       		setProperty( PKG_MNFST_UCOMPSIZE, sSize.toInt32() );
	}
	else if ( aStack.size() > 1 )
	{
        ManifestStack::reverse_iterator aIter = aStack.rbegin();
        aIter++;

		if ( aIter->m_aConvertedName.equalsAscii( ELEMENT_FILE_ENTRY ) )
        {
            if ( aConvertedName.equalsAscii( ELEMENT_ENCRYPTION_DATA ) )
            {
                // If this element exists, then this stream is encrypted and we need
                // to import the initialisation vector, salt and iteration count used
                nDerivedKeySize = 0;
                if ( !bIgnoreEncryptData )
                {
                    sal_Int32 nDigestId = 0;
                    const OUString& rChecksumType = aConvertedAttribs[sChecksumTypeAttribute];
                    if( rChecksumType.equalsAscii( SHA1_1K_NAME )
                    ||  rChecksumType.equalsAscii( SHA1_1K_URL ) )
       		            nDigestId = xml::crypto::DigestID::SHA1_1K;
                    else if ( rChecksumType.equalsAscii( SHA256_1K_URL ) )
       		            nDigestId = xml::crypto::DigestID::SHA256_1K;
                    else
                        bIgnoreEncryptData = true;

                    if ( !bIgnoreEncryptData )
                    {
                        setProperty( PKG_MNFST_DIGESTALG, nDigestId );
                        const OUString& sChecksumData = aConvertedAttribs[sChecksumAttribute];
                        uno::Sequence < sal_Int8 > aDecodeBuffer;
                        ::sax::Converter::decodeBase64( aDecodeBuffer, sChecksumData );
                        setProperty( PKG_MNFST_DIGEST, aDecodeBuffer );
                    }
                }
            }
        }
        else if ( aIter->m_aConvertedName.equalsAscii( ELEMENT_ENCRYPTION_DATA ) )
        {
            if ( aConvertedName.equalsAscii( ELEMENT_ALGORITHM ) )
            {
                if ( !bIgnoreEncryptData )
                {
                    sal_Int32 nCypherId = 0;
                    const OUString& rAlgoName = aConvertedAttribs[sAlgorithmNameAttribute];
                    if ( rAlgoName.equalsAscii( BLOWFISH_NAME )
                    ||   rAlgoName.equalsAscii( BLOWFISH_URL ) )
                    	 nCypherId = xml::crypto::CipherID::BLOWFISH_CFB_8;
                    else if( rAlgoName.equalsAscii( AES256_URL ) )
                    {
                    	 nCypherId = xml::crypto::CipherID::AES_CBC_W3C_PADDING;
                        OSL_ENSURE( !nDerivedKeySize || nDerivedKeySize == 32, "Unexpected derived key length!" );
                        nDerivedKeySize = 32;
                    }
                    else if( rAlgoName.equalsAscii( AES192_URL ) )
                    {
                    	 nCypherId = xml::crypto::CipherID::AES_CBC_W3C_PADDING;
                        OSL_ENSURE( !nDerivedKeySize || nDerivedKeySize == 24, "Unexpected derived key length!" );
                        nDerivedKeySize = 24;
                    }
                    else if( rAlgoName.equalsAscii( AES128_URL ) )
                    {
                    	 nCypherId = xml::crypto::CipherID::AES_CBC_W3C_PADDING;
                        OSL_ENSURE( !nDerivedKeySize || nDerivedKeySize == 16, "Unexpected derived key length!" );
                        nDerivedKeySize = 16;
                    }
                    else
                        bIgnoreEncryptData = true;

                    if ( !bIgnoreEncryptData )
                    {
                    	 setProperty( PKG_MNFST_ENCALG, nCypherId );
                        const OUString& sInitVector = aConvertedAttribs[sInitialisationVectorAttribute];
                        uno::Sequence < sal_Int8 > aDecodeBuffer;
                        ::sax::Converter::decodeBase64 ( aDecodeBuffer, sInitVector );
                    	 setProperty( PKG_MNFST_INIVECTOR, aDecodeBuffer );
                    }
                }
            }
            else if ( aConvertedName.equalsAscii( ELEMENT_KEY_DERIVATION ) )
            {
                if ( !bIgnoreEncryptData )
                {
                    const OUString& rKeyDerivString = aConvertedAttribs[sKeyDerivationNameAttribute];
                    if ( rKeyDerivString.equalsAscii( PBKDF2_NAME ) || rKeyDerivString.equalsAscii( PBKDF2_URL ) )
                    {
                        const OUString& rSaltString = aConvertedAttribs[sSaltAttribute];
                        uno::Sequence < sal_Int8 > aDecodeBuffer;
                        ::sax::Converter::decodeBase64 ( aDecodeBuffer, rSaltString );
                    	 setProperty( PKG_MNFST_SALT, aDecodeBuffer );

                        const OUString& rIterationCount = aConvertedAttribs[sIterationCountAttribute];
                        setProperty( PKG_MNFST_ITERATION, rIterationCount.toInt32() );

                        const OUString& rKeySize = aConvertedAttribs[sKeySizeAttribute];
                        if ( rKeySize.getLength() )
                        {
                            const sal_Int32 nKey = rKeySize.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( sal_False, "Default derived key length differs from the expected one!" );

                        setProperty( PKG_MNFST_DERKEYSIZE, nDerivedKeySize );
                    }
                    else
                        bIgnoreEncryptData = true;
                }
            }
            else if ( aConvertedName.equalsAscii( ELEMENT_START_KEY_GENERATION ) )
            {
                const OUString& rSKeyAlg = aConvertedAttribs[sStartKeyAlgNameAttribute];
                if ( rSKeyAlg.equalsAscii( SHA256_URL ) )
                	setProperty( PKG_MNFST_STARTALG, xml::crypto::DigestID::SHA256 );
                else if ( rSKeyAlg.equalsAscii( SHA1_NAME ) || rSKeyAlg.equalsAscii( SHA1_URL ) )
                	setProperty( PKG_MNFST_STARTALG, xml::crypto::DigestID::SHA1 );
                else
                    bIgnoreEncryptData = true;
            }
        }
	}
}

// ---------------------------------------------------
void SAL_CALL ManifestImport::endElement( const OUString& aName )
	throw( xml::sax::SAXException, uno::RuntimeException )
{
	if( aStack.empty() )
		return;

	const OUString aConvertedName = ConvertName( aName );
	if( !aStack.rbegin()->m_aConvertedName.equals( aConvertedName ) )
		return;

	aStack.pop_back();

	if( !aConvertedName.equalsAscii( ELEMENT_FILE_ENTRY ) )
		return;

	// create the property sequence
	// Put full-path property first for MBA
	// TODO: get rid of fullpath-first requirement
	const bool bHasFullPath = maValues[PKG_MNFST_FULLPATH].hasValue();
	OSL_ENSURE( bHasFullPath, "Full path missing in manifest" );

	int nNumProperty = bHasFullPath ? 1 : 0;
	PropertyValue aProperties[ PKG_SIZE_ENCR_MNFST ];
	for( int i = 0; i < PKG_SIZE_ENCR_MNFST; ++i)
	{
		if(! maValues[i].hasValue() )
			continue;

		const int nDest = (i == PKG_MNFST_FULLPATH) ? 0 : nNumProperty++;
		PropertyValue& rProp = aProperties[ nDest ];
		rProp.Name = OUString::createFromAscii( getMnfstPropName(i));
		rProp.Value = maValues[i];
		maValues[i].clear();
	}

	// add the property sequence to the vector of manifests
	rManVector.push_back ( PropertyValues( aProperties, nNumProperty ) );
	bIgnoreEncryptData = false;
}

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

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

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

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

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

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

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

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

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

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

    return aConvertedName;
}


// ---------------------------------------------------
::rtl::OUString ManifestImport::ConvertNameWithNamespace( const ::rtl::OUString& aName, const StringHashMap& aNamespaces )
{
    ::rtl::OUString aNsAlias;
    ::rtl::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 );
    }

    ::rtl::OUString aResult;

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

    return aResult;
}

// ---------------------------------------------------
::rtl::OUString ManifestImport::ConvertName( const ::rtl::OUString& aName )
{
    ::rtl::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;
}