/* -*- 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 <com/sun/star/xml/sax/XExtendedDocumentHandler.hpp>

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

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

#include <com/sun/star/xml/crypto/KDFID.hpp>

#include <com/sun/star/beans/PropertyValue.hpp>

#include <com/sun/star/beans/NamedValue.hpp>

#include <com/sun/star/uno/RuntimeException.hpp>

#include "ManifestDefines.hxx"

#include "ManifestExport.hxx"

#include <osl/diagnose.h>

#include <rtl/ustrbuf.hxx>

#include <rtl/ref.hxx>

#include <sal/log.hxx>

#include <comphelper/base64.hxx>

#include <comphelper/documentconstants.hxx>

#include <comphelper/attributelist.hxx>

using namespace ::com::sun::star;

ManifestExport::ManifestExport( uno::Reference< xml::sax::XDocumentHandler > const & xHandler,  const uno::Sequence< uno::Sequence < beans::PropertyValue > >& rManList )

{

    static constexpr OUString sKeyInfo                      ( u"KeyInfo"_ustr );

    static constexpr OUString sPgpKeyIDProperty             ( u"KeyId"_ustr );

    static constexpr OUString sPgpKeyPacketProperty         ( u"KeyPacket"_ustr );

    static constexpr OUString sCipherValueProperty          ( u"CipherValue"_ustr );

    static constexpr OUString sFullPathProperty             ( u"FullPath"_ustr );

    static constexpr OUString sVersionProperty              ( u"Version"_ustr );

    static constexpr OUString sMediaTypeProperty            ( u"MediaType"_ustr );

    static constexpr OUString sIterationCountProperty       ( u"IterationCount"_ustr );

    static constexpr OUString sDerivedKeySizeProperty       ( u"DerivedKeySize"_ustr );

    static constexpr OUString sSaltProperty                 ( u"Salt"_ustr );

    static constexpr OUString sInitialisationVectorProperty ( u"InitialisationVector"_ustr );

    static constexpr OUString sSizeProperty                 ( u"Size"_ustr );

    static constexpr OUString sDigestProperty               ( u"Digest"_ustr );

    static constexpr OUString sEncryptionAlgProperty        ( u"EncryptionAlgorithm"_ustr );

    static constexpr OUString sStartKeyAlgProperty          ( u"StartKeyAlgorithm"_ustr );

    static constexpr OUString sDigestAlgProperty            ( u"DigestAlgorithm"_ustr );

    static constexpr OUString sWhiteSpace                   ( u" "_ustr );

    rtl::Reference<::comphelper::AttributeList> pRootAttrList = new ::comphelper::AttributeList;

    // find the mediatype of the document if any

    OUString aDocMediaType;

    OUString aDocVersion;

    bool isWholesomeEncryption(false);

    const uno::Sequence<beans::PropertyValue>* pRootFolderPropSeq = nullptr;

    for (const uno::Sequence < beans::PropertyValue >& rSequence : rManList)

    {

        OUString aMediaType;

        OUString aPath;

        OUString aVersion;

        for (const beans::PropertyValue& rValue : rSequence)

        {

            if (rValue.Name == sMediaTypeProperty )

            {

                rValue.Value >>= aMediaType;

            }

            else if (rValue.Name == sFullPathProperty )

            {

                rValue.Value >>= aPath;

            }

            else if (rValue.Name == sVersionProperty )

            {

                rValue.Value >>= aVersion;

            }

            if ( !aPath.isEmpty() && !aMediaType.isEmpty() && !aVersion.isEmpty() )

                break;

        }

        if ( aPath == "/" )

        {

            assert(aDocMediaType.isEmpty());

            // unfortunately no aMediaType in some cases where non-documents

            // are stored as StorageFormats::PACKAGE instead of sensible

            // StorageFormats::ZIP, such as SvxXMLXTableExportComponent and

            // SwXMLTextBlocks, which results in an empty "mimetype" etc but

            // can't be easily fixed; try to exclude these cases by checking

            // for aVersion, but of course then forgetting to set both version

            // and type on an actual document can't be found :(

            assert(!aMediaType.isEmpty() || aVersion.isEmpty());

            aDocMediaType = aMediaType;

            aDocVersion = aVersion;

            pRootFolderPropSeq = &rSequence;

        }

        if (aPath == "encrypted-package")

        {

            isWholesomeEncryption = true;

            assert(aDocMediaType.isEmpty() || aDocMediaType == aMediaType);

        }

    }

    assert(pRootFolderPropSeq);

    bool bProvideDTD = false;

    bool bAcceptNonemptyVersion = false;

    bool bStoreStartKeyGeneration = false;

    if ( !aDocMediaType.isEmpty() )

    {

        if ( aDocMediaType == MIMETYPE_OASIS_OPENDOCUMENT_TEXT

          || aDocMediaType == MIMETYPE_OASIS_OPENDOCUMENT_TEXT_WEB

          || aDocMediaType == MIMETYPE_OASIS_OPENDOCUMENT_TEXT_GLOBAL

          || aDocMediaType == MIMETYPE_OASIS_OPENDOCUMENT_DRAWING

          || aDocMediaType == MIMETYPE_OASIS_OPENDOCUMENT_PRESENTATION

          || aDocMediaType == MIMETYPE_OASIS_OPENDOCUMENT_SPREADSHEET

          || aDocMediaType == MIMETYPE_OASIS_OPENDOCUMENT_CHART

          || aDocMediaType == MIMETYPE_OASIS_OPENDOCUMENT_DATABASE

          || aDocMediaType == MIMETYPE_OASIS_OPENDOCUMENT_FORMULA

          || aDocMediaType == MIMETYPE_OASIS_OPENDOCUMENT_TEXT_TEMPLATE

          || aDocMediaType == MIMETYPE_OASIS_OPENDOCUMENT_TEXT_GLOBAL_TEMPLATE

          || aDocMediaType == MIMETYPE_OASIS_OPENDOCUMENT_DRAWING_TEMPLATE

          || aDocMediaType == MIMETYPE_OASIS_OPENDOCUMENT_PRESENTATION_TEMPLATE

          || aDocMediaType == MIMETYPE_OASIS_OPENDOCUMENT_SPREADSHEET_TEMPLATE

          || aDocMediaType == MIMETYPE_OASIS_OPENDOCUMENT_CHART_TEMPLATE

          || aDocMediaType == MIMETYPE_OASIS_OPENDOCUMENT_FORMULA_TEMPLATE )

        {

            // oasis format

            pRootAttrList->AddAttribute ( ATTRIBUTE_XMLNS,

                                        MANIFEST_OASIS_NAMESPACE );

            bAcceptNonemptyVersion = true;

            if ( aDocVersion.compareTo( ODFVER_012_TEXT ) >= 0 )

            {

                // this is ODF12 or later generation, let encrypted

                // streams contain start-key-generation entry

                bStoreStartKeyGeneration = true;

                pRootAttrList->AddAttribute ( ATTRIBUTE_VERSION, aDocVersion );

                // plus gpg4libre extensions - loext NS for that

                pRootAttrList->AddAttribute ( ATTRIBUTE_XMLNS_LOEXT,

                                              MANIFEST_LOEXT_NAMESPACE );

            }

        }

        else

        {

            // even if it is no SO6 format the namespace must be specified

            // thus SO6 format is used as default one

            pRootAttrList->AddAttribute ( ATTRIBUTE_XMLNS,

                                        MANIFEST_NAMESPACE );

            bProvideDTD = true;

        }

    }

    xHandler->startDocument();

    uno::Reference < xml::sax::XExtendedDocumentHandler > xExtHandler ( xHandler, uno::UNO_QUERY );

    if ( xExtHandler.is() && bProvideDTD )

    {

        xExtHandler->unknown ( MANIFEST_DOCTYPE );

        xHandler->ignorableWhitespace ( sWhiteSpace );

    }

    xHandler->startElement( ELEMENT_MANIFEST, pRootAttrList );

    const uno::Any *pKeyInfoProperty = nullptr;

    if ( pRootFolderPropSeq )

    {

        // do we have package-wide encryption info?

        for (const beans::PropertyValue& rValue : *pRootFolderPropSeq)

        {

            if (rValue.Name == sKeyInfo )

                pKeyInfoProperty = &rValue.Value;

        }

        if ( pKeyInfoProperty )

        {

            // no start-key-generation needed, our session key has

            // max size already

            bStoreStartKeyGeneration = false;

            // yeah, so that goes directly below the manifest:manifest

            // element

            OUStringBuffer aBuffer;

            xHandler->ignorableWhitespace ( sWhiteSpace );

            // ==== manifest:keyinfo & children

            bool const isODF13(aDocVersion.compareTo(ODFVER_013_TEXT) >= 0);

            if (!isODF13)

            {

                xHandler->startElement(ELEMENT_MANIFEST_KEYINFO, nullptr);

            }

            xHandler->ignorableWhitespace ( sWhiteSpace );

            uno::Sequence< uno::Sequence < beans::NamedValue > > aKeyInfoSequence;

            *pKeyInfoProperty >>= aKeyInfoSequence;

            for (const uno::Sequence<beans::NamedValue>& rKeyInfoSequence : aKeyInfoSequence)

            {

                uno::Sequence < sal_Int8 > aPgpKeyID;

                uno::Sequence < sal_Int8 > aPgpKeyPacket;

                uno::Sequence < sal_Int8 > aCipherValue;

                for (const beans::NamedValue& rNValue : rKeyInfoSequence)

                {

                    if (rNValue.Name == sPgpKeyIDProperty )

                        rNValue.Value >>= aPgpKeyID;

                    else if (rNValue.Name == sPgpKeyPacketProperty )

                        rNValue.Value >>= aPgpKeyPacket;

                    else if (rNValue.Name == sCipherValueProperty )

                        rNValue.Value >>= aCipherValue;

                }

                if (aPgpKeyID.hasElements() && aCipherValue.hasElements() )

                {

                    // ==== manifest:encrypted-key & children - one for each recipient

                    xHandler->startElement(isODF13 ? ELEMENT_ENCRYPTEDKEY13 : ELEMENT_ENCRYPTEDKEY, nullptr);

                    xHandler->ignorableWhitespace ( sWhiteSpace );

                    rtl::Reference<::comphelper::AttributeList> pNewAttrList = new ::comphelper::AttributeList;

                    // TODO: the algorithm should rather be configurable

                    pNewAttrList->AddAttribute(

                        isODF13 ? ATTRIBUTE_ALGORITHM13 : ATTRIBUTE_ALGORITHM,

                                                 u"http://www.w3.org/2001/04/xmlenc#rsa-oaep-mgf1p"_ustr );

                    xHandler->startElement(isODF13 ? ELEMENT_ENCRYPTIONMETHOD13 : ELEMENT_ENCRYPTIONMETHOD, pNewAttrList);

                    xHandler->endElement(isODF13 ? ELEMENT_ENCRYPTIONMETHOD13 : ELEMENT_ENCRYPTIONMETHOD);

                    xHandler->ignorableWhitespace ( sWhiteSpace );

                    // note: the mismatch here corresponds to ODF 1.3 cs01 schema

                    xHandler->startElement(isODF13 ? ELEMENT_MANIFEST13_KEYINFO : ELEMENT_MANIFEST_KEYINFO, nullptr);

                    xHandler->ignorableWhitespace ( sWhiteSpace );

                    xHandler->startElement(isODF13 ? ELEMENT_PGPDATA13 : ELEMENT_PGPDATA, nullptr);

                    xHandler->ignorableWhitespace ( sWhiteSpace );

                    xHandler->startElement(isODF13 ? ELEMENT_PGPKEYID13 : ELEMENT_PGPKEYID, nullptr);

                    ::comphelper::Base64::encode(aBuffer, aPgpKeyID);

                    xHandler->characters( aBuffer.makeStringAndClear() );

                    xHandler->endElement(isODF13 ? ELEMENT_PGPKEYID13 : ELEMENT_PGPKEYID);

                    xHandler->ignorableWhitespace ( sWhiteSpace );

                    // key packet is optional

                    if (aPgpKeyPacket.hasElements())

                    {

                        xHandler->startElement(isODF13 ? ELEMENT_PGPKEYPACKET13 : ELEMENT_PGPKEYPACKET, nullptr);

                        ::comphelper::Base64::encode(aBuffer, aPgpKeyPacket);

                        xHandler->characters( aBuffer.makeStringAndClear() );

                        xHandler->endElement(isODF13 ? ELEMENT_PGPKEYPACKET13 : ELEMENT_PGPKEYPACKET);

                        xHandler->ignorableWhitespace ( sWhiteSpace );

                    }

                    xHandler->endElement(isODF13 ? ELEMENT_PGPDATA13 : ELEMENT_PGPDATA);

                    xHandler->ignorableWhitespace ( sWhiteSpace );

                    xHandler->endElement(isODF13 ? ELEMENT_MANIFEST13_KEYINFO : ELEMENT_MANIFEST_KEYINFO);

                    xHandler->ignorableWhitespace ( sWhiteSpace );

                    xHandler->startElement(isODF13 ? ELEMENT_CIPHERDATA13 : ELEMENT_CIPHERDATA, nullptr);

                    xHandler->ignorableWhitespace ( sWhiteSpace );

                    xHandler->startElement(isODF13 ? ELEMENT_CIPHERVALUE13 : ELEMENT_CIPHERVALUE, nullptr);

                    ::comphelper::Base64::encode(aBuffer, aCipherValue);

                    xHandler->characters( aBuffer.makeStringAndClear() );

                    xHandler->endElement(isODF13 ? ELEMENT_CIPHERVALUE13 : ELEMENT_CIPHERVALUE);

                    xHandler->ignorableWhitespace ( sWhiteSpace );

                    xHandler->endElement(isODF13 ? ELEMENT_CIPHERDATA13 : ELEMENT_CIPHERDATA);

                    xHandler->ignorableWhitespace ( sWhiteSpace );

                    xHandler->endElement(isODF13 ? ELEMENT_ENCRYPTEDKEY13 : ELEMENT_ENCRYPTEDKEY);

                    xHandler->ignorableWhitespace ( sWhiteSpace );

                }

            }

            if (!isODF13)

            {

                xHandler->endElement(ELEMENT_MANIFEST_KEYINFO);

            }

            xHandler->ignorableWhitespace ( sWhiteSpace );

        }

    }

    // now write individual file entries

    for (const uno::Sequence<beans::PropertyValue>& rSequence : rManList)

    {

        if (&rSequence == pRootFolderPropSeq && isWholesomeEncryption)

        {

            continue; // no root document, but embedded package => omit

        }

        rtl::Reference<::comphelper::AttributeList> pAttrList = new ::comphelper::AttributeList;

        OUString fullPath;

        OUString aString;

        const uno::Any *pVector = nullptr, *pSalt = nullptr, *pIterationCount = nullptr, *pDigest = nullptr, *pDigestAlg = nullptr, *pEncryptAlg = nullptr, *pStartKeyAlg = nullptr, *pDerivedKeySize = nullptr;

        uno::Any const* pKDF = nullptr;

        uno::Any const* pArgon2Args = nullptr;

        for (const beans::PropertyValue& rValue : rSequence)

        {

            if (rValue.Name == sMediaTypeProperty )

            {

                rValue.Value >>= aString;

                pAttrList->AddAttribute ( ATTRIBUTE_MEDIA_TYPE, aString );

            }

            else if (rValue.Name == sVersionProperty )

            {

                rValue.Value >>= aString;

                // the version is stored only if it is not empty

                if ( bAcceptNonemptyVersion && !aString.isEmpty() )

                    pAttrList->AddAttribute ( ATTRIBUTE_VERSION, aString );

            }

            else if (rValue.Name == sFullPathProperty )

            {

                rValue.Value >>= fullPath;

                pAttrList->AddAttribute(ATTRIBUTE_FULL_PATH, fullPath);

            }

            else if (rValue.Name == sSizeProperty )

            {

                sal_Int64 nSize = 0;

                rValue.Value >>= nSize;

                pAttrList->AddAttribute ( ATTRIBUTE_SIZE, OUString::number( nSize ) );

            }

            else if (rValue.Name == sInitialisationVectorProperty )

                pVector = &rValue.Value;

            else if (rValue.Name == sSaltProperty )

                pSalt = &rValue.Value;

            else if (rValue.Name == sIterationCountProperty )

                pIterationCount = &rValue.Value;

            else if (rValue.Name == sDigestProperty )

                pDigest = &rValue.Value;

            else if (rValue.Name == sDigestAlgProperty )

                pDigestAlg = &rValue.Value;

            else if (rValue.Name == sEncryptionAlgProperty )

                pEncryptAlg = &rValue.Value;

            else if (rValue.Name == sStartKeyAlgProperty )

                pStartKeyAlg = &rValue.Value;

            else if (rValue.Name == sDerivedKeySizeProperty )

                pDerivedKeySize = &rValue.Value;

            else if (rValue.Name == "KeyDerivationFunction") {

                pKDF = &rValue.Value;

            } else if (rValue.Name == "Argon2Args") {

                pArgon2Args = &rValue.Value;

            }

        }

        assert(!fullPath.isEmpty());

        if (isWholesomeEncryption)

        {   // there may be signatures in META-INF too

            assert(fullPath == "encrypted-package" || fullPath.startsWith("META-INF/"));

        }

        xHandler->ignorableWhitespace ( sWhiteSpace );

        xHandler->startElement( ELEMENT_FILE_ENTRY , pAttrList);

        if (pVector && pEncryptAlg && pDerivedKeySize && pKDF

            && ((pSalt && pStartKeyAlg && (pIterationCount || pArgon2Args))

                || pKeyInfoProperty))

        {

            // ==== Encryption Data

            rtl::Reference<::comphelper::AttributeList> pNewAttrList = new ::comphelper::AttributeList;

            OUStringBuffer aBuffer;

            uno::Sequence < sal_Int8 > aSequence;

            xHandler->ignorableWhitespace ( sWhiteSpace );

            // ==== Digest

            if (pDigest && pDigestAlg && pDigestAlg->hasValue())

            {

                OUString sChecksumType;

                sal_Int32 nDigestAlgID = 0;

                *pDigestAlg >>= nDigestAlgID;

                if ( nDigestAlgID == xml::crypto::DigestID::SHA256_1K )

                    sChecksumType = SHA256_1K_URL;

                else if ( nDigestAlgID == xml::crypto::DigestID::SHA1_1K )

                    sChecksumType = SHA1_1K_NAME;

                else

                    throw uno::RuntimeException( u"Unexpected digest algorithm is provided!"_ustr );

                pNewAttrList->AddAttribute(ATTRIBUTE_CHECKSUM_TYPE, sChecksumType);

                *pDigest >>= aSequence;

                ::comphelper::Base64::encode(aBuffer, aSequence);

                pNewAttrList->AddAttribute(ATTRIBUTE_CHECKSUM, aBuffer.makeStringAndClear());

            }

            xHandler->startElement( ELEMENT_ENCRYPTION_DATA , pNewAttrList);

            // ==== Algorithm

            pNewAttrList = new ::comphelper::AttributeList;

            sal_Int32 nEncAlgID = 0;

            sal_Int32 nDerivedKeySize = 0;

            *pEncryptAlg >>= nEncAlgID;

            *pDerivedKeySize >>= nDerivedKeySize;

            OUString sEncAlgName;

            if ( nEncAlgID == xml::crypto::CipherID::AES_CBC_W3C_PADDING )

            {

                OSL_ENSURE( nDerivedKeySize, "Unexpected key size is provided!" );

                if ( nDerivedKeySize != 32 )

                    throw uno::RuntimeException( u"Unexpected key size is provided!"_ustr );

                sEncAlgName = AES256_URL;

            }

            else if (nEncAlgID == xml::crypto::CipherID::AES_GCM_W3C)

            {

                assert(bStoreStartKeyGeneration || pKeyInfoProperty);

                SAL_WARN_IF(nDerivedKeySize != 32, "package.manifest", "Unexpected key size is provided!");

                if (nDerivedKeySize != 32)

                {

                    throw uno::RuntimeException(u"Unexpected key size is provided!"_ustr);

                }

                sEncAlgName = AESGCM256_URL;

            }

            else if ( nEncAlgID == xml::crypto::CipherID::BLOWFISH_CFB_8 )

            {

                sEncAlgName = BLOWFISH_NAME;

            }

            else

                throw uno::RuntimeException( u"Unexpected encryption algorithm is provided!"_ustr );

            pNewAttrList->AddAttribute ( ATTRIBUTE_ALGORITHM_NAME, sEncAlgName );

            *pVector >>= aSequence;

            ::comphelper::Base64::encode(aBuffer, aSequence);

            pNewAttrList->AddAttribute ( ATTRIBUTE_INITIALISATION_VECTOR, aBuffer.makeStringAndClear() );

            xHandler->ignorableWhitespace ( sWhiteSpace );

            xHandler->startElement( ELEMENT_ALGORITHM , pNewAttrList);

            xHandler->ignorableWhitespace ( sWhiteSpace );

            xHandler->endElement( ELEMENT_ALGORITHM );

            if ( bStoreStartKeyGeneration )

            {

                // ==== Start Key Generation

                pNewAttrList = new ::comphelper::AttributeList;

                OUString sStartKeyAlg;

                OUString sStartKeySize;

                sal_Int32 nStartKeyAlgID = 0;

                *pStartKeyAlg >>= nStartKeyAlgID;

                if ( nStartKeyAlgID == xml::crypto::DigestID::SHA256 )

                {

                    if (nEncAlgID == xml::crypto::CipherID::AES_GCM_W3C)

                    {   // new encryption is incompatible anyway, use W3C URL

                        sStartKeyAlg = SHA256_URL;

                    }

                    else // to interop with ODF <= 1.4 consumers use bad ODF URL

                    {

                        sStartKeyAlg = SHA256_URL_ODF12;

                    }

                    aBuffer.append( sal_Int32(32) );

                    sStartKeySize = aBuffer.makeStringAndClear();

                }

                else if ( nStartKeyAlgID == xml::crypto::DigestID::SHA1 )

                {

                    sStartKeyAlg = SHA1_NAME;

                    aBuffer.append( sal_Int32(20) );

                    sStartKeySize = aBuffer.makeStringAndClear();

                }

                else

                    throw uno::RuntimeException( u"Unexpected start key algorithm is provided!"_ustr );

                pNewAttrList->AddAttribute ( ATTRIBUTE_START_KEY_GENERATION_NAME, sStartKeyAlg );

                pNewAttrList->AddAttribute ( ATTRIBUTE_KEY_SIZE, sStartKeySize );

                xHandler->ignorableWhitespace ( sWhiteSpace );

                xHandler->startElement( ELEMENT_START_KEY_GENERATION , pNewAttrList);

                xHandler->ignorableWhitespace ( sWhiteSpace );

                xHandler->endElement( ELEMENT_START_KEY_GENERATION );

            }

            // ==== Key Derivation

            pNewAttrList = new ::comphelper::AttributeList;

            if (pKeyInfoProperty)

            {

                assert(pKDF->get<sal_Int32>() == xml::crypto::KDFID::PGP_RSA_OAEP_MGF1P);

                pNewAttrList->AddAttribute(ATTRIBUTE_KEY_DERIVATION_NAME,

                                           PGP_NAME);

            }

            else

            {

                if (pKDF->get<sal_Int32>() == xml::crypto::KDFID::Argon2id)

                {

                    pNewAttrList->AddAttribute(ATTRIBUTE_KEY_DERIVATION_NAME,

                                               ARGON2ID_URL_LO);

                    uno::Sequence<sal_Int32> args;

                    *pArgon2Args >>= args;

                    assert(args.getLength() == 3);

                    pNewAttrList->AddAttribute(ATTRIBUTE_ARGON2_T_LO, OUString::number(args[0]));

                    pNewAttrList->AddAttribute(ATTRIBUTE_ARGON2_M_LO, OUString::number(args[1]));

                    pNewAttrList->AddAttribute(ATTRIBUTE_ARGON2_P_LO, OUString::number(args[2]));

                }

                else

                {

                    assert(pKDF->get<sal_Int32>() == xml::crypto::KDFID::PBKDF2);

                    pNewAttrList->AddAttribute(ATTRIBUTE_KEY_DERIVATION_NAME,

                                               PBKDF2_NAME);

                    sal_Int32 nCount = 0;

                    *pIterationCount >>= nCount;

                    aBuffer.append(nCount);

                    pNewAttrList->AddAttribute(ATTRIBUTE_ITERATION_COUNT, aBuffer.makeStringAndClear());

                }

                *pSalt >>= aSequence;

                ::comphelper::Base64::encode(aBuffer, aSequence);

                pNewAttrList->AddAttribute ( ATTRIBUTE_SALT, aBuffer.makeStringAndClear() );

            }

            // ODF 1.3 specifies the default as 16 so have to write it for PGP

            if (bStoreStartKeyGeneration || pKeyInfoProperty)

            {

                aBuffer.append(nDerivedKeySize);

                pNewAttrList->AddAttribute(ATTRIBUTE_KEY_SIZE, aBuffer.makeStringAndClear());

            }

            xHandler->ignorableWhitespace(sWhiteSpace);

            xHandler->startElement(ELEMENT_KEY_DERIVATION, pNewAttrList);

            xHandler->ignorableWhitespace(sWhiteSpace);

            xHandler->endElement(ELEMENT_KEY_DERIVATION);

            xHandler->ignorableWhitespace ( sWhiteSpace );

            xHandler->endElement( ELEMENT_ENCRYPTION_DATA );

        }

        xHandler->ignorableWhitespace ( sWhiteSpace );

        xHandler->endElement( ELEMENT_FILE_ENTRY );

    }

    xHandler->ignorableWhitespace ( sWhiteSpace );

    xHandler->endElement( ELEMENT_MANIFEST );

    xHandler->endDocument();

}

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