undo anything not wizard related in the previous merge-commit

7 files changed, 365 insertions, 155 deletions

diff --git a/package/source/manifest/Base64Codec.cxx b/package/source/manifest/Base64Codec.cxx
index cf539d0790c4..b4f5b6d32ffd 100644
--- a/package/source/manifest/Base64Codec.cxx
+++ b/package/source/manifest/Base64Codec.cxx
@@ -131,11 +131,11 @@ void ThreeByteToFourByte (const sal_uInt8* pBuffer, const sal_Int32 nStart, cons
     sBuffer.setCharAt(3, aBase64EncodeTable [nIndex]);
 }
 
-void Base64Codec::encodeBase64(rtl::OUStringBuffer& aStrBuffer, const uno::Sequence < sal_uInt8 >& aPass)
+void Base64Codec::encodeBase64(rtl::OUStringBuffer& aStrBuffer, const uno::Sequence < sal_Int8 >& aPass)
 {
     sal_Int32 i(0);
     sal_Int32 nBufferLength(aPass.getLength());
-    const sal_uInt8* pBuffer = aPass.getConstArray();
+    const sal_uInt8* pBuffer = reinterpret_cast< const sal_uInt8* >( aPass.getConstArray() );
     while (i < nBufferLength)
     {
         rtl::OUStringBuffer sBuffer;
@@ -185,7 +185,7 @@ void FourByteToThreeByte (sal_uInt8* pBuffer, sal_Int32& nLength, const sal_Int3
     pBuffer[nStart + 2] = OneByte;
 }
 
-void Base64Codec::decodeBase64(uno::Sequence< sal_uInt8 >& aBuffer, const rtl::OUString& sBuffer)
+void Base64Codec::decodeBase64(uno::Sequence< sal_Int8 >& aBuffer, const rtl::OUString& sBuffer)
 {
     sal_Int32 nFirstLength((sBuffer.getLength() / 4) * 3);
     sal_uInt8* pBuffer = new sal_uInt8[nFirstLength];
@@ -201,7 +201,7 @@ void Base64Codec::decodeBase64(uno::Sequence< sal_uInt8 >& aBuffer, const rtl::O
         i += 4;
         k += 3;
     }
-    aBuffer = uno::Sequence<sal_uInt8>(pBuffer, nSecondLength);
+    aBuffer = uno::Sequence<sal_Int8>( reinterpret_cast< sal_Int8* >( pBuffer ), nSecondLength );
     delete[] pBuffer;
 }
 
diff --git a/package/source/manifest/Base64Codec.hxx b/package/source/manifest/Base64Codec.hxx
index 8cae2a7037fd..60bd018c159b 100644
--- a/package/source/manifest/Base64Codec.hxx
+++ b/package/source/manifest/Base64Codec.hxx
@@ -40,8 +40,8 @@ class OUStringBuffer;
 class Base64Codec
 {
 public:
-    static void encodeBase64(rtl::OUStringBuffer& aStrBuffer, const com::sun::star::uno::Sequence<sal_uInt8>& aPass);
-    static void decodeBase64(com::sun::star::uno::Sequence<sal_uInt8>& aPass, const rtl::OUString& sBuffer);
+    static void encodeBase64(rtl::OUStringBuffer& aStrBuffer, const com::sun::star::uno::Sequence<sal_Int8>& aPass);
+    static void decodeBase64(com::sun::star::uno::Sequence<sal_Int8>& aPass, const rtl::OUString& sBuffer);
 };
 #endif
 
diff --git a/package/source/manifest/ManifestDefines.hxx b/package/source/manifest/ManifestDefines.hxx
index 65b9c6181727..969f4d834835 100644
--- a/package/source/manifest/ManifestDefines.hxx
+++ b/package/source/manifest/ManifestDefines.hxx
@@ -54,16 +54,29 @@
 
 #define ELEMENT_START_KEY_GENERATION "manifest:start-key-generation"
 #define ATTRIBUTE_START_KEY_GENERATION_NAME "manifest:start-key-generation-name"
-#define ALGORITHM_SHA1 "SHA1"
 #define ATTRIBUTE_KEY_SIZE "manifest:key-size"
-#define START_KEY_SIZE "20"
 
 #define ELEMENT_KEY_DERIVATION "manifest:key-derivation"
 #define ATTRIBUTE_KEY_DERIVATION_NAME "manifest:key-derivation-name"
 #define ATTRIBUTE_SALT "manifest:salt"
 #define ATTRIBUTE_ITERATION_COUNT "manifest:iteration-count"
-#define CHECKSUM_TYPE "SHA1/1K"
-#define DERIVED_KEY_SIZE "16"
+
+#define SHA256_URL "http://www.w3.org/2000/09/xmldsig#sha256"
+#define SHA1_NAME "SHA1"
+#define SHA1_URL "http://www.w3.org/2000/09/xmldsig#sha1"
+
+#define SHA1_1K_NAME "SHA1/1K"
+#define SHA1_1K_URL "urn:oasis:names:tc:opendocument:xmlns:manifest:1.0#sha1-1k"
+#define SHA256_1K_URL "urn:oasis:names:tc:opendocument:xmlns:manifest:1.0#sha256-1k"
+
+#define BLOWFISH_NAME "Blowfish CFB"
+#define BLOWFISH_URL "urn:oasis:names:tc:opendocument:xmlns:manifest:1.0#blowfish"
+#define AES128_URL "http://www.w3.org/2001/04/xmlenc#aes128-cbc"
+#define AES192_URL "http://www.w3.org/2001/04/xmlenc#aes192-cbc"
+#define AES256_URL "http://www.w3.org/2001/04/xmlenc#aes256-cbc"
+
+#define PBKDF2_NAME "PBKDF2"
+#define PBKDF2_URL "urn:oasis:names:tc:opendocument:xmlns:manifest:1.0#pbkdf2"
 
 #endif
 
diff --git a/package/source/manifest/ManifestExport.cxx b/package/source/manifest/ManifestExport.cxx
index e173e8da8d53..b5dc6c049440 100644
--- a/package/source/manifest/ManifestExport.cxx
+++ b/package/source/manifest/ManifestExport.cxx
@@ -28,80 +28,92 @@
 
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_package.hxx"
-#include <ManifestExport.hxx>
-#include <ManifestDefines.hxx>
-#include <com/sun/star/xml/sax/XAttributeList.hpp>
-#include <rtl/ustrbuf.hxx>
-#include <Base64Codec.hxx>
+
 #include <com/sun/star/xml/sax/XExtendedDocumentHandler.hpp>
 #include <com/sun/star/xml/sax/XDocumentHandler.hpp>
+#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 <com/sun/star/uno/RuntimeException.hpp>
 
+#include <ManifestDefines.hxx>
+#include <ManifestExport.hxx>
+#include <Base64Codec.hxx>
+
+#include <rtl/ustrbuf.hxx>
 #include <comphelper/documentconstants.hxx>
 #include <comphelper/attributelist.hxx>
 
-using namespace com::sun::star::beans;
-using namespace com::sun::star::uno;
-using namespace com::sun::star::xml::sax;
+using namespace ::com::sun::star;
 
 using ::rtl::OUString;
 using ::rtl::OUStringBuffer;
 
-ManifestExport::ManifestExport(Reference < XDocumentHandler > xHandler,  const Sequence < Sequence < PropertyValue > > &rManList )
+ManifestExport::ManifestExport( uno::Reference< xml::sax::XDocumentHandler > xHandler,  const uno::Sequence< uno::Sequence < beans::PropertyValue > >& rManList )
 {
-    const OUString sFileEntryElement    ( RTL_CONSTASCII_USTRINGPARAM ( ELEMENT_FILE_ENTRY ) );
-    const OUString sManifestElement     ( RTL_CONSTASCII_USTRINGPARAM ( ELEMENT_MANIFEST ) );
-    const OUString sEncryptionDataElement( RTL_CONSTASCII_USTRINGPARAM ( ELEMENT_ENCRYPTION_DATA ) );
-    const OUString sAlgorithmElement    ( RTL_CONSTASCII_USTRINGPARAM ( ELEMENT_ALGORITHM ) );
-    const OUString sStartKeyGenerationElement ( RTL_CONSTASCII_USTRINGPARAM ( ELEMENT_START_KEY_GENERATION ) );
-    const OUString sKeyDerivationElement( RTL_CONSTASCII_USTRINGPARAM ( ELEMENT_KEY_DERIVATION ) );
-
-    const OUString sCdataAttribute      ( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_CDATA ) );
-    const OUString sMediaTypeAttribute  ( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_MEDIA_TYPE ) );
-    const OUString sVersionAttribute    ( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_VERSION ) );
-    const OUString sFullPathAttribute   ( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_FULL_PATH ) );
-    const OUString sSizeAttribute       ( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_SIZE ) );
-    const OUString sKeySizeAttribute    ( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_KEY_SIZE ) );
-    const OUString sSaltAttribute       ( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_SALT ) );
-    const OUString sInitialisationVectorAttribute ( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_INITIALISATION_VECTOR ) );
-    const OUString sIterationCountAttribute ( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_ITERATION_COUNT ) );
-    const OUString sAlgorithmNameAttribute  ( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_ALGORITHM_NAME ) );
-    const OUString sStartKeyGenerationNameAttribute ( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_START_KEY_GENERATION_NAME ) );
-    const OUString sKeyDerivationNameAttribute  ( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_KEY_DERIVATION_NAME ) );
-    const OUString sChecksumTypeAttribute   ( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_CHECKSUM_TYPE ) );
-    const OUString sChecksumAttribute   ( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_CHECKSUM) );
-
-    const OUString sFullPathProperty    ( RTL_CONSTASCII_USTRINGPARAM ( "FullPath" ) );
-    const OUString sVersionProperty     ( RTL_CONSTASCII_USTRINGPARAM ( "Version" ) );
-    const OUString sMediaTypeProperty   ( RTL_CONSTASCII_USTRINGPARAM ( "MediaType" ) );
-    const OUString sIterationCountProperty  ( RTL_CONSTASCII_USTRINGPARAM ( "IterationCount" ) );
-    const OUString sSaltProperty        ( RTL_CONSTASCII_USTRINGPARAM ( "Salt" ) );
-    const OUString sInitialisationVectorProperty( RTL_CONSTASCII_USTRINGPARAM ( "InitialisationVector" ) );
-    const OUString sSizeProperty        ( RTL_CONSTASCII_USTRINGPARAM ( "Size" ) );
-    const OUString sDigestProperty      ( RTL_CONSTASCII_USTRINGPARAM ( "Digest" ) );
-
-    const OUString sWhiteSpace          ( RTL_CONSTASCII_USTRINGPARAM ( " " ) );
-    const OUString sBlowfish            ( RTL_CONSTASCII_USTRINGPARAM ( "Blowfish CFB" ) );
-    const OUString sPBKDF2              ( RTL_CONSTASCII_USTRINGPARAM ( "PBKDF2" ) );
-    const OUString sChecksumType        ( RTL_CONSTASCII_USTRINGPARAM ( CHECKSUM_TYPE ) );
-    const OUString sStartKeySize        ( RTL_CONSTASCII_USTRINGPARAM ( START_KEY_SIZE ) );
-    const OUString sDerivedKeySize      ( RTL_CONSTASCII_USTRINGPARAM ( DERIVED_KEY_SIZE ) );
-    const OUString sSHA1                ( RTL_CONSTASCII_USTRINGPARAM ( ALGORITHM_SHA1 ) );
+    const ::rtl::OUString sFileEntryElement     ( RTL_CONSTASCII_USTRINGPARAM ( ELEMENT_FILE_ENTRY ) );
+    const ::rtl::OUString sManifestElement      ( RTL_CONSTASCII_USTRINGPARAM ( ELEMENT_MANIFEST ) );
+    const ::rtl::OUString sEncryptionDataElement( RTL_CONSTASCII_USTRINGPARAM ( ELEMENT_ENCRYPTION_DATA ) );
+    const ::rtl::OUString sAlgorithmElement     ( RTL_CONSTASCII_USTRINGPARAM ( ELEMENT_ALGORITHM ) );
+    const ::rtl::OUString sStartKeyGenerationElement ( RTL_CONSTASCII_USTRINGPARAM ( ELEMENT_START_KEY_GENERATION ) );
+    const ::rtl::OUString sKeyDerivationElement ( RTL_CONSTASCII_USTRINGPARAM ( ELEMENT_KEY_DERIVATION ) );
+
+    const ::rtl::OUString sCdataAttribute       ( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_CDATA ) );
+    const ::rtl::OUString sMediaTypeAttribute   ( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_MEDIA_TYPE ) );
+    const ::rtl::OUString sVersionAttribute     ( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_VERSION ) );
+    const ::rtl::OUString sFullPathAttribute    ( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_FULL_PATH ) );
+    const ::rtl::OUString sSizeAttribute        ( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_SIZE ) );
+    const ::rtl::OUString sKeySizeAttribute     ( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_KEY_SIZE ) );
+    const ::rtl::OUString sSaltAttribute        ( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_SALT ) );
+    const ::rtl::OUString sInitialisationVectorAttribute ( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_INITIALISATION_VECTOR ) );
+    const ::rtl::OUString sIterationCountAttribute  ( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_ITERATION_COUNT ) );
+    const ::rtl::OUString sAlgorithmNameAttribute   ( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_ALGORITHM_NAME ) );
+    const ::rtl::OUString sStartKeyGenerationNameAttribute ( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_START_KEY_GENERATION_NAME ) );
+    const ::rtl::OUString sKeyDerivationNameAttribute   ( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_KEY_DERIVATION_NAME ) );
+    const ::rtl::OUString sChecksumTypeAttribute    ( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_CHECKSUM_TYPE ) );
+    const ::rtl::OUString sChecksumAttribute    ( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_CHECKSUM) );
+
+    const ::rtl::OUString sFullPathProperty     ( RTL_CONSTASCII_USTRINGPARAM ( "FullPath" ) );
+    const ::rtl::OUString sVersionProperty  ( RTL_CONSTASCII_USTRINGPARAM ( "Version" ) );
+    const ::rtl::OUString sMediaTypeProperty    ( RTL_CONSTASCII_USTRINGPARAM ( "MediaType" ) );
+    const ::rtl::OUString sIterationCountProperty   ( RTL_CONSTASCII_USTRINGPARAM ( "IterationCount" ) );
+    const ::rtl::OUString  sDerivedKeySizeProperty  ( RTL_CONSTASCII_USTRINGPARAM ( "DerivedKeySize" ) );
+    const ::rtl::OUString sSaltProperty         ( RTL_CONSTASCII_USTRINGPARAM ( "Salt" ) );
+    const ::rtl::OUString sInitialisationVectorProperty( RTL_CONSTASCII_USTRINGPARAM ( "InitialisationVector" ) );
+    const ::rtl::OUString sSizeProperty         ( RTL_CONSTASCII_USTRINGPARAM ( "Size" ) );
+    const ::rtl::OUString sDigestProperty       ( RTL_CONSTASCII_USTRINGPARAM ( "Digest" ) );
+    const ::rtl::OUString sEncryptionAlgProperty    ( RTL_CONSTASCII_USTRINGPARAM ( "EncryptionAlgorithm" ) );
+    const ::rtl::OUString sStartKeyAlgProperty  ( RTL_CONSTASCII_USTRINGPARAM ( "StartKeyAlgorithm" ) );
+    const ::rtl::OUString sDigestAlgProperty    ( RTL_CONSTASCII_USTRINGPARAM ( "DigestAlgorithm" ) );
+
+    const ::rtl::OUString sWhiteSpace           ( RTL_CONSTASCII_USTRINGPARAM ( " " ) );
+
+    const ::rtl::OUString sSHA256_URL           ( RTL_CONSTASCII_USTRINGPARAM ( SHA256_URL ) );
+    const ::rtl::OUString  sSHA1_Name           ( RTL_CONSTASCII_USTRINGPARAM ( SHA1_NAME ) );
+
+    const ::rtl::OUString  sSHA1_1k_Name        ( RTL_CONSTASCII_USTRINGPARAM ( SHA1_1K_NAME ) );
+    const ::rtl::OUString  sSHA256_1k_URL       ( RTL_CONSTASCII_USTRINGPARAM ( SHA256_1K_URL ) );
+
+    const ::rtl::OUString  sBlowfish_Name       ( RTL_CONSTASCII_USTRINGPARAM ( BLOWFISH_NAME ) );
+    const ::rtl::OUString  sAES256_URL          ( RTL_CONSTASCII_USTRINGPARAM ( AES256_URL ) );
+
+    const ::rtl::OUString  sPBKDF2_Name         ( RTL_CONSTASCII_USTRINGPARAM ( PBKDF2_NAME ) );
 
     ::comphelper::AttributeList * pRootAttrList = new ::comphelper::AttributeList;
-    const Sequence < PropertyValue > *pSequence = rManList.getConstArray();
+    const uno::Sequence < beans::PropertyValue > *pSequence = rManList.getConstArray();
     const sal_uInt32 nManLength = rManList.getLength();
 
     // find the mediatype of the document if any
-    OUString aDocMediaType;
-    OUString aDocVersion;
+    ::rtl::OUString aDocMediaType;
+    ::rtl::OUString aDocVersion;
     for (sal_uInt32 nInd = 0; nInd < nManLength ; nInd++ )
     {
-        OUString aMediaType;
-        OUString aPath;
-        OUString aVersion;
+        ::rtl::OUString aMediaType;
+        ::rtl::OUString aPath;
+        ::rtl::OUString aVersion;
 
-        const PropertyValue *pValue = pSequence[nInd].getConstArray();
+        const beans::PropertyValue *pValue = pSequence[nInd].getConstArray();
         for (sal_uInt32 j = 0, nNum = pSequence[nInd].getLength(); j < nNum; j++, pValue++)
         {
             if (pValue->Name.equals (sMediaTypeProperty) )
@@ -121,7 +133,7 @@ ManifestExport::ManifestExport(Reference < XDocumentHandler > xHandler,  const S
                 break;
         }
 
-        if ( aPath.equals( OUString( RTL_CONSTASCII_USTRINGPARAM( "/" ) ) ) )
+        if ( aPath.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "/" ) ) ) )
         {
             aDocMediaType = aMediaType;
             aDocVersion = aVersion;
@@ -134,28 +146,28 @@ ManifestExport::ManifestExport(Reference < XDocumentHandler > xHandler,  const S
     sal_Bool bStoreStartKeyGeneration = sal_False;
     if ( aDocMediaType.getLength() )
     {
-        if ( aDocMediaType.equals( OUString( RTL_CONSTASCII_USTRINGPARAM( MIMETYPE_OASIS_OPENDOCUMENT_TEXT_ASCII ) ) )
-          || aDocMediaType.equals( OUString( RTL_CONSTASCII_USTRINGPARAM( MIMETYPE_OASIS_OPENDOCUMENT_TEXT_WEB_ASCII ) ) )
-          || aDocMediaType.equals( OUString( RTL_CONSTASCII_USTRINGPARAM( MIMETYPE_OASIS_OPENDOCUMENT_TEXT_GLOBAL_ASCII ) ) )
-          || aDocMediaType.equals( OUString( RTL_CONSTASCII_USTRINGPARAM( MIMETYPE_OASIS_OPENDOCUMENT_DRAWING_ASCII ) ) )
-          || aDocMediaType.equals( OUString( RTL_CONSTASCII_USTRINGPARAM( MIMETYPE_OASIS_OPENDOCUMENT_PRESENTATION_ASCII ) ) )
-          || aDocMediaType.equals( OUString( RTL_CONSTASCII_USTRINGPARAM( MIMETYPE_OASIS_OPENDOCUMENT_SPREADSHEET_ASCII ) ) )
-          || aDocMediaType.equals( OUString( RTL_CONSTASCII_USTRINGPARAM( MIMETYPE_OASIS_OPENDOCUMENT_CHART_ASCII ) ) )
-          || aDocMediaType.equals( OUString( RTL_CONSTASCII_USTRINGPARAM( MIMETYPE_OASIS_OPENDOCUMENT_DATABASE_ASCII ) ) )
-          || aDocMediaType.equals( OUString( RTL_CONSTASCII_USTRINGPARAM( MIMETYPE_OASIS_OPENDOCUMENT_FORMULA_ASCII ) ) )
-
-          || aDocMediaType.equals( OUString( RTL_CONSTASCII_USTRINGPARAM( MIMETYPE_OASIS_OPENDOCUMENT_TEXT_TEMPLATE_ASCII ) ) )
-          || aDocMediaType.equals( OUString( RTL_CONSTASCII_USTRINGPARAM( MIMETYPE_OASIS_OPENDOCUMENT_DRAWING_TEMPLATE_ASCII ) ) )
-          || aDocMediaType.equals( OUString( RTL_CONSTASCII_USTRINGPARAM( MIMETYPE_OASIS_OPENDOCUMENT_PRESENTATION_TEMPLATE_ASCII ) ) )
-          || aDocMediaType.equals( OUString( RTL_CONSTASCII_USTRINGPARAM( MIMETYPE_OASIS_OPENDOCUMENT_SPREADSHEET_TEMPLATE_ASCII ) ) )
-          || aDocMediaType.equals( OUString( RTL_CONSTASCII_USTRINGPARAM( MIMETYPE_OASIS_OPENDOCUMENT_CHART_TEMPLATE_ASCII ) ) )
-          || aDocMediaType.equals( OUString( RTL_CONSTASCII_USTRINGPARAM( MIMETYPE_OASIS_OPENDOCUMENT_FORMULA_TEMPLATE_ASCII ) ) ) )
+        if ( aDocMediaType.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( MIMETYPE_OASIS_OPENDOCUMENT_TEXT_ASCII ) ) )
+          || aDocMediaType.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( MIMETYPE_OASIS_OPENDOCUMENT_TEXT_WEB_ASCII ) ) )
+          || aDocMediaType.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( MIMETYPE_OASIS_OPENDOCUMENT_TEXT_GLOBAL_ASCII ) ) )
+          || aDocMediaType.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( MIMETYPE_OASIS_OPENDOCUMENT_DRAWING_ASCII ) ) )
+          || aDocMediaType.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( MIMETYPE_OASIS_OPENDOCUMENT_PRESENTATION_ASCII ) ) )
+          || aDocMediaType.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( MIMETYPE_OASIS_OPENDOCUMENT_SPREADSHEET_ASCII ) ) )
+          || aDocMediaType.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( MIMETYPE_OASIS_OPENDOCUMENT_CHART_ASCII ) ) )
+          || aDocMediaType.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( MIMETYPE_OASIS_OPENDOCUMENT_DATABASE_ASCII ) ) )
+          || aDocMediaType.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( MIMETYPE_OASIS_OPENDOCUMENT_FORMULA_ASCII ) ) )
+
+          || aDocMediaType.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( MIMETYPE_OASIS_OPENDOCUMENT_TEXT_TEMPLATE_ASCII ) ) )
+          || aDocMediaType.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( MIMETYPE_OASIS_OPENDOCUMENT_DRAWING_TEMPLATE_ASCII ) ) )
+          || aDocMediaType.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( MIMETYPE_OASIS_OPENDOCUMENT_PRESENTATION_TEMPLATE_ASCII ) ) )
+          || aDocMediaType.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( MIMETYPE_OASIS_OPENDOCUMENT_SPREADSHEET_TEMPLATE_ASCII ) ) )
+          || aDocMediaType.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( MIMETYPE_OASIS_OPENDOCUMENT_CHART_TEMPLATE_ASCII ) ) )
+          || aDocMediaType.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( MIMETYPE_OASIS_OPENDOCUMENT_FORMULA_TEMPLATE_ASCII ) ) ) )
 
         {
             // oasis format
-            pRootAttrList->AddAttribute ( OUString( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_XMLNS ) ),
+            pRootAttrList->AddAttribute ( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_XMLNS ) ),
                                         sCdataAttribute,
-                                        OUString( RTL_CONSTASCII_USTRINGPARAM ( MANIFEST_OASIS_NAMESPACE ) ) );
+                                        ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( MANIFEST_OASIS_NAMESPACE ) ) );
             bAcceptNonemptyVersion = sal_True;
             if ( aDocVersion.compareTo( ODFVER_012_TEXT ) >= 0 )
             {
@@ -168,21 +180,21 @@ ManifestExport::ManifestExport(Reference < XDocumentHandler > xHandler,  const S
         {
             // even if it is no SO6 format the namespace must be specified
             // thus SO6 format is used as default one
-            pRootAttrList->AddAttribute ( OUString( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_XMLNS ) ),
+            pRootAttrList->AddAttribute ( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_XMLNS ) ),
                                         sCdataAttribute,
-                                        OUString( RTL_CONSTASCII_USTRINGPARAM ( MANIFEST_NAMESPACE ) ) );
+                                        ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( MANIFEST_NAMESPACE ) ) );
 
             bProvideDTD = sal_True;
         }
     }
 
-    Reference < XAttributeList > xRootAttrList (pRootAttrList);
+    uno::Reference < xml::sax::XAttributeList > xRootAttrList (pRootAttrList);
 
     xHandler->startDocument();
-    Reference < XExtendedDocumentHandler > xExtHandler ( xHandler, UNO_QUERY );
+    uno::Reference < xml::sax::XExtendedDocumentHandler > xExtHandler ( xHandler, uno::UNO_QUERY );
     if ( xExtHandler.is() && bProvideDTD )
     {
-        OUString aDocType ( RTL_CONSTASCII_USTRINGPARAM ( MANIFEST_DOCTYPE ) );
+        ::rtl::OUString aDocType ( RTL_CONSTASCII_USTRINGPARAM ( MANIFEST_DOCTYPE ) );
         xExtHandler->unknown ( aDocType );
         xHandler->ignorableWhitespace ( sWhiteSpace );
     }
@@ -191,9 +203,9 @@ ManifestExport::ManifestExport(Reference < XDocumentHandler > xHandler,  const S
     for (sal_uInt32 i = 0 ; i < nManLength ; i++)
     {
         ::comphelper::AttributeList *pAttrList = new ::comphelper::AttributeList;
-        const PropertyValue *pValue = pSequence[i].getConstArray();
-        OUString aString;
-        const PropertyValue *pVector = NULL, *pSalt = NULL, *pIterationCount = NULL, *pDigest = NULL;
+        const beans::PropertyValue *pValue = pSequence[i].getConstArray();
+        ::rtl::OUString aString;
+        const uno::Any *pVector = NULL, *pSalt = NULL, *pIterationCount = NULL, *pDigest = NULL, *pDigestAlg = NULL, *pEncryptAlg = NULL, *pStartKeyAlg = NULL, *pDerivedKeySize = NULL;
         for (sal_uInt32 j = 0, nNum = pSequence[i].getLength(); j < nNum; j++, pValue++)
         {
             if (pValue->Name.equals (sMediaTypeProperty) )
@@ -217,47 +229,87 @@ ManifestExport::ManifestExport(Reference < XDocumentHandler > xHandler,  const S
             {
                 sal_Int32 nSize = 0;
                 pValue->Value >>= nSize;
-                OUStringBuffer aBuffer;
+                ::rtl::OUStringBuffer aBuffer;
                 aBuffer.append ( nSize );
                 pAttrList->AddAttribute ( sSizeAttribute, sCdataAttribute, aBuffer.makeStringAndClear() );
             }
             else if (pValue->Name.equals (sInitialisationVectorProperty) )
-                pVector = pValue;
+                pVector = &pValue->Value;
             else if (pValue->Name.equals (sSaltProperty) )
-                pSalt = pValue;
+                pSalt = &pValue->Value;
             else if (pValue->Name.equals (sIterationCountProperty) )
-                pIterationCount = pValue;
+                pIterationCount = &pValue->Value;
             else if (pValue->Name.equals ( sDigestProperty ) )
-                pDigest = pValue;
+                pDigest = &pValue->Value;
+            else if (pValue->Name.equals ( sDigestAlgProperty ) )
+                pDigestAlg = &pValue->Value;
+            else if (pValue->Name.equals ( sEncryptionAlgProperty ) )
+                pEncryptAlg = &pValue->Value;
+            else if (pValue->Name.equals ( sStartKeyAlgProperty ) )
+                pStartKeyAlg = &pValue->Value;
+            else if (pValue->Name.equals ( sDerivedKeySizeProperty ) )
+                pDerivedKeySize = &pValue->Value;
         }
+
         xHandler->ignorableWhitespace ( sWhiteSpace );
-        Reference < XAttributeList > xAttrList ( pAttrList );
+        uno::Reference < xml::sax::XAttributeList > xAttrList ( pAttrList );
         xHandler->startElement( sFileEntryElement , xAttrList);
-        if ( pVector && pSalt && pIterationCount )
+        if ( pVector && pSalt && pIterationCount && pDigest && pDigestAlg && pEncryptAlg && pStartKeyAlg && pDerivedKeySize )
         {
             // ==== Encryption Data
             ::comphelper::AttributeList * pNewAttrList = new ::comphelper::AttributeList;
-            Reference < XAttributeList > xNewAttrList (pNewAttrList);
-            OUStringBuffer aBuffer;
-            Sequence < sal_uInt8 > aSequence;
+            uno::Reference < xml::sax::XAttributeList > xNewAttrList (pNewAttrList);
+            ::rtl::OUStringBuffer aBuffer;
+            uno::Sequence < sal_Int8 > aSequence;
 
             xHandler->ignorableWhitespace ( sWhiteSpace );
-            if ( pDigest )
-            {
-                pNewAttrList->AddAttribute ( sChecksumTypeAttribute, sCdataAttribute, sChecksumType );
-                pDigest->Value >>= aSequence;
-                Base64Codec::encodeBase64 ( aBuffer, aSequence );
-                pNewAttrList->AddAttribute ( sChecksumAttribute, sCdataAttribute, aBuffer.makeStringAndClear() );
-            }
+
+            // ==== Digest
+            ::rtl::OUString sChecksumType;
+            sal_Int32 nDigestAlgID = 0;
+            *pDigestAlg >>= nDigestAlgID;
+            if ( nDigestAlgID == xml::crypto::DigestID::SHA256_1K )
+                sChecksumType = sSHA256_1k_URL;
+            else if ( nDigestAlgID == xml::crypto::DigestID::SHA1_1K )
+                sChecksumType = sSHA1_1k_Name;
+            else
+                throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Unexpected digest algorithm is provided!" ) ), uno::Reference< uno::XInterface >() );
+
+            pNewAttrList->AddAttribute ( sChecksumTypeAttribute, sCdataAttribute, sChecksumType );
+            *pDigest >>= aSequence;
+            Base64Codec::encodeBase64( aBuffer, aSequence );
+            pNewAttrList->AddAttribute ( sChecksumAttribute, sCdataAttribute, aBuffer.makeStringAndClear() );
+
             xHandler->startElement( sEncryptionDataElement , xNewAttrList);
 
             // ==== Algorithm
             pNewAttrList = new ::comphelper::AttributeList;
             xNewAttrList = pNewAttrList;
 
-            pNewAttrList->AddAttribute ( sAlgorithmNameAttribute, sCdataAttribute, sBlowfish );
+            sal_Int32 nEncAlgID = 0;
+            sal_Int32 nDerivedKeySize = 0;
+            *pEncryptAlg >>= nEncAlgID;
+            *pDerivedKeySize >>= nDerivedKeySize;
 
-            pVector->Value >>= aSequence;
+            ::rtl::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( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Unexpected key size is provided!" ) ), uno::Reference< uno::XInterface >() );
+
+                sEncAlgName = sAES256_URL;
+            }
+            else if ( nEncAlgID == xml::crypto::CipherID::BLOWFISH_CFB_8 )
+            {
+                sEncAlgName = sBlowfish_Name;
+            }
+            else
+                throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Unexpecte encryption algorithm is provided!" ) ), uno::Reference< uno::XInterface >() );
+
+            pNewAttrList->AddAttribute ( sAlgorithmNameAttribute, sCdataAttribute, sEncAlgName );
+
+            *pVector >>= aSequence;
             Base64Codec::encodeBase64 ( aBuffer, aSequence );
             pNewAttrList->AddAttribute ( sInitialisationVectorAttribute, sCdataAttribute, aBuffer.makeStringAndClear() );
 
@@ -270,17 +322,20 @@ ManifestExport::ManifestExport(Reference < XDocumentHandler > xHandler,  const S
             pNewAttrList = new ::comphelper::AttributeList;
             xNewAttrList = pNewAttrList;
 
-            pNewAttrList->AddAttribute ( sKeyDerivationNameAttribute, sCdataAttribute, sPBKDF2 );
+            pNewAttrList->AddAttribute ( sKeyDerivationNameAttribute, sCdataAttribute, sPBKDF2_Name );
 
             if ( bStoreStartKeyGeneration )
-                pNewAttrList->AddAttribute ( sKeySizeAttribute, sCdataAttribute, sDerivedKeySize );
+            {
+                aBuffer.append( nDerivedKeySize );
+                pNewAttrList->AddAttribute ( sKeySizeAttribute, sCdataAttribute, aBuffer.makeStringAndClear() );
+            }
 
             sal_Int32 nCount = 0;
-            pIterationCount->Value >>= nCount;
+            *pIterationCount >>= nCount;
             aBuffer.append (nCount);
             pNewAttrList->AddAttribute ( sIterationCountAttribute, sCdataAttribute, aBuffer.makeStringAndClear() );
 
-            pSalt->Value >>= aSequence;
+            *pSalt >>= aSequence;
             Base64Codec::encodeBase64 ( aBuffer, aSequence );
             pNewAttrList->AddAttribute ( sSaltAttribute, sCdataAttribute, aBuffer.makeStringAndClear() );
 
@@ -297,8 +352,26 @@ ManifestExport::ManifestExport(Reference < XDocumentHandler > xHandler,  const S
                 pNewAttrList = new ::comphelper::AttributeList;
                 xNewAttrList = pNewAttrList;
 
-                // currently SHA1 is used to generate 20-bytes start key
-                pNewAttrList->AddAttribute ( sStartKeyGenerationNameAttribute, sCdataAttribute, sSHA1 );
+                ::rtl::OUString sStartKeyAlg;
+                ::rtl::OUString sStartKeySize;
+                sal_Int32 nStartKeyAlgID = 0;
+                *pStartKeyAlg >>= nStartKeyAlgID;
+                if ( nStartKeyAlgID == xml::crypto::DigestID::SHA256 )
+                {
+                    sStartKeyAlg = sSHA256_URL;
+                    aBuffer.append( (sal_Int32)32 );
+                    sStartKeySize = aBuffer.makeStringAndClear();
+                }
+                else if ( nStartKeyAlgID == xml::crypto::DigestID::SHA1 )
+                {
+                    sStartKeyAlg = sSHA1_Name;
+                    aBuffer.append( (sal_Int32)20 );
+                    sStartKeySize = aBuffer.makeStringAndClear();
+                }
+                else
+                    throw uno::RuntimeException( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX "Unexpected start key algorithm is provided!" ) ), uno::Reference< uno::XInterface >() );
+
+                pNewAttrList->AddAttribute ( sStartKeyGenerationNameAttribute, sCdataAttribute, sStartKeyAlg );
                 pNewAttrList->AddAttribute ( sKeySizeAttribute, sCdataAttribute, sStartKeySize );
 
                 xHandler->ignorableWhitespace ( sWhiteSpace );
diff --git a/package/source/manifest/ManifestImport.cxx b/package/source/manifest/ManifestImport.cxx
index 58310e5ed116..f685f7ea87fb 100644
--- a/package/source/manifest/ManifestImport.cxx
+++ b/package/source/manifest/ManifestImport.cxx
@@ -32,6 +32,8 @@
 #include <ManifestDefines.hxx>
 #include <Base64Codec.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>
 #include <com/sun/star/beans/PropertyValue.hpp>
 
 using namespace com::sun::star::uno;
@@ -45,12 +47,14 @@ using ::rtl::OUString;
 ManifestImport::ManifestImport( vector < Sequence < PropertyValue > > & rNewManVector )
 : nNumProperty ( 0 )
 , bIgnoreEncryptData    ( sal_False )
+, nDerivedKeySize( 0 )
 , rManVector ( rNewManVector )
 
 , sFileEntryElement     ( RTL_CONSTASCII_USTRINGPARAM ( ELEMENT_FILE_ENTRY ) )
 , sManifestElement      ( RTL_CONSTASCII_USTRINGPARAM ( ELEMENT_MANIFEST ) )
 , sEncryptionDataElement( RTL_CONSTASCII_USTRINGPARAM ( ELEMENT_ENCRYPTION_DATA ) )
 , sAlgorithmElement ( RTL_CONSTASCII_USTRINGPARAM ( ELEMENT_ALGORITHM ) )
+, sStartKeyAlgElement   ( RTL_CONSTASCII_USTRINGPARAM ( ELEMENT_START_KEY_GENERATION ) )
 , sKeyDerivationElement( RTL_CONSTASCII_USTRINGPARAM ( ELEMENT_KEY_DERIVATION ) )
 
 , sCdataAttribute               ( RTL_CONSTASCII_USTRINGPARAM ( ATTRIBUTE_CDATA ) )
@@ -61,7 +65,9 @@ ManifestImport::ManifestImport( vector < Sequence < PropertyValue > > & rNewManV
 , 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 ) )
@@ -70,15 +76,33 @@ ManifestImport::ManifestImport( vector < Sequence < PropertyValue > > & rNewManV
 , sMediaTypeProperty            ( RTL_CONSTASCII_USTRINGPARAM ( "MediaType" ) )
 , sVersionProperty              ( RTL_CONSTASCII_USTRINGPARAM ( "Version" ) )
 , sIterationCountProperty       ( RTL_CONSTASCII_USTRINGPARAM ( "IterationCount" ) )
+, sDerivedKeySizeProperty       ( RTL_CONSTASCII_USTRINGPARAM ( "DerivedKeySize" ) )
 , sSaltProperty                 ( RTL_CONSTASCII_USTRINGPARAM ( "Salt" ) )
 , sInitialisationVectorProperty ( RTL_CONSTASCII_USTRINGPARAM ( "InitialisationVector" ) )
 , sSizeProperty                 ( RTL_CONSTASCII_USTRINGPARAM ( "Size" ) )
 , sDigestProperty               ( RTL_CONSTASCII_USTRINGPARAM ( "Digest" ) )
+, sEncryptionAlgProperty        ( RTL_CONSTASCII_USTRINGPARAM ( "EncryptionAlgorithm" ) )
+, sStartKeyAlgProperty          ( RTL_CONSTASCII_USTRINGPARAM ( "StartKeyAlgorithm" ) )
+, sDigestAlgProperty            ( RTL_CONSTASCII_USTRINGPARAM ( "DigestAlgorithm" ) )
 
 , sWhiteSpace                   ( RTL_CONSTASCII_USTRINGPARAM ( " " ) )
-, sBlowfish                     ( RTL_CONSTASCII_USTRINGPARAM ( "Blowfish CFB" ) )
-, sPBKDF2                       ( RTL_CONSTASCII_USTRINGPARAM ( "PBKDF2" ) )
-, sChecksumType                 ( RTL_CONSTASCII_USTRINGPARAM ( CHECKSUM_TYPE ) )
+
+, sSHA256_URL                   ( RTL_CONSTASCII_USTRINGPARAM ( SHA256_URL ) )
+, sSHA1_Name                    ( RTL_CONSTASCII_USTRINGPARAM ( SHA1_NAME ) )
+, sSHA1_URL                     ( RTL_CONSTASCII_USTRINGPARAM ( SHA1_URL ) )
+
+, sSHA256_1k_URL                ( RTL_CONSTASCII_USTRINGPARAM ( SHA256_1K_URL ) )
+, sSHA1_1k_Name                 ( RTL_CONSTASCII_USTRINGPARAM ( SHA1_1K_NAME ) )
+, sSHA1_1k_URL                  ( RTL_CONSTASCII_USTRINGPARAM ( SHA1_1K_URL ) )
+
+, sBlowfish_Name                ( RTL_CONSTASCII_USTRINGPARAM ( BLOWFISH_NAME ) )
+, sBlowfish_URL                 ( RTL_CONSTASCII_USTRINGPARAM ( BLOWFISH_URL ) )
+, sAES128_URL                   ( RTL_CONSTASCII_USTRINGPARAM ( AES128_URL ) )
+, sAES192_URL                   ( RTL_CONSTASCII_USTRINGPARAM ( AES192_URL ) )
+, sAES256_URL                   ( RTL_CONSTASCII_USTRINGPARAM ( AES256_URL ) )
+
+, sPBKDF2_Name                  ( RTL_CONSTASCII_USTRINGPARAM ( PBKDF2_NAME ) )
+, sPBKDF2_URL                   ( RTL_CONSTASCII_USTRINGPARAM ( PBKDF2_URL ) )
 {
     aStack.reserve( 10 );
 }
@@ -143,15 +167,32 @@ void SAL_CALL ManifestImport::startElement( const OUString& aName, const uno::Re
             if ( aConvertedName.equals( sEncryptionDataElement ) )
             {
                 // If this element exists, then this stream is encrypted and we need
-                // to store the initialisation vector, salt and iteration count used
+                // to import the initialisation vector, salt and iteration count used
+                nDerivedKeySize = 0;
                 OUString aString = aConvertedAttribs[sChecksumTypeAttribute];
-                if ( aString == sChecksumType && !bIgnoreEncryptData )
+                if ( !bIgnoreEncryptData )
                 {
-                    aString = aConvertedAttribs[sChecksumAttribute];
-                    Sequence < sal_uInt8 > aDecodeBuffer;
-                    Base64Codec::decodeBase64 ( aDecodeBuffer, aString );
-                    aSequence[nNumProperty].Name = sDigestProperty;
-                    aSequence[nNumProperty++].Value <<= aDecodeBuffer;
+                    if ( aString.equals( sSHA1_1k_Name ) || aString.equals( sSHA1_1k_URL ) )
+                    {
+                        aSequence[nNumProperty].Name = sDigestAlgProperty;
+                        aSequence[nNumProperty++].Value <<= xml::crypto::DigestID::SHA1_1K;
+                    }
+                    else if ( aString.equals( sSHA256_1k_URL ) )
+                    {
+                        aSequence[nNumProperty].Name = sDigestAlgProperty;
+                        aSequence[nNumProperty++].Value <<= xml::crypto::DigestID::SHA256_1K;
+                    }
+                    else
+                        bIgnoreEncryptData = sal_True;
+
+                    if ( !bIgnoreEncryptData )
+                    {
+                        aString = aConvertedAttribs[sChecksumAttribute];
+                        uno::Sequence < sal_Int8 > aDecodeBuffer;
+                        Base64Codec::decodeBase64( aDecodeBuffer, aString );
+                        aSequence[nNumProperty].Name = sDigestProperty;
+                        aSequence[nNumProperty++].Value <<= aDecodeBuffer;
+                    }
                 }
             }
         }
@@ -159,38 +200,98 @@ void SAL_CALL ManifestImport::startElement( const OUString& aName, const uno::Re
         {
             if ( aConvertedName == sAlgorithmElement )
             {
-                OUString aString = aConvertedAttribs[sAlgorithmNameAttribute];
-                if ( aString == sBlowfish && !bIgnoreEncryptData )
+                if ( !bIgnoreEncryptData )
                 {
-                    aString = aConvertedAttribs[sInitialisationVectorAttribute];
-                    Sequence < sal_uInt8 > aDecodeBuffer;
-                    Base64Codec::decodeBase64 ( aDecodeBuffer, aString );
-                    aSequence[nNumProperty].Name = sInitialisationVectorProperty;
-                    aSequence[nNumProperty++].Value <<= aDecodeBuffer;
+                    OUString aString = aConvertedAttribs[sAlgorithmNameAttribute];
+                    if ( aString.equals( sBlowfish_Name ) || aString.equals( sBlowfish_URL ) )
+                    {
+                        aSequence[nNumProperty].Name = sEncryptionAlgProperty;
+                        aSequence[nNumProperty++].Value <<= xml::crypto::CipherID::BLOWFISH_CFB_8;
+                    }
+                    else if ( aString.equals( sAES256_URL ) )
+                    {
+                        aSequence[nNumProperty].Name = sEncryptionAlgProperty;
+                        aSequence[nNumProperty++].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[nNumProperty].Name = sEncryptionAlgProperty;
+                        aSequence[nNumProperty++].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[nNumProperty].Name = sEncryptionAlgProperty;
+                        aSequence[nNumProperty++].Value <<= xml::crypto::CipherID::AES_CBC_W3C_PADDING;
+                        OSL_ENSURE( !nDerivedKeySize || nDerivedKeySize == 16, "Unexpected derived key length!" );
+                        nDerivedKeySize = 16;
+                    }
+                    else
+                        bIgnoreEncryptData = sal_True;
+
+                    if ( !bIgnoreEncryptData )
+                    {
+                        aString = aConvertedAttribs[sInitialisationVectorAttribute];
+                        uno::Sequence < sal_Int8 > aDecodeBuffer;
+                        Base64Codec::decodeBase64 ( aDecodeBuffer, aString );
+                        aSequence[nNumProperty].Name = sInitialisationVectorProperty;
+                        aSequence[nNumProperty++].Value <<= aDecodeBuffer;
+                    }
                 }
-                else
-                    // If we don't recognise the algorithm, then the key derivation info
-                    // is useless to us
-                    bIgnoreEncryptData = sal_True;
             }
             else if ( aConvertedName == sKeyDerivationElement )
             {
-                OUString aString = aConvertedAttribs[sKeyDerivationNameAttribute];
-                if ( aString == sPBKDF2 && !bIgnoreEncryptData )
+                if ( !bIgnoreEncryptData )
+                {
+                    OUString aString = aConvertedAttribs[sKeyDerivationNameAttribute];
+                    if ( aString.equals( sPBKDF2_Name ) || aString.equals( sPBKDF2_URL ) )
+                    {
+                        aString = aConvertedAttribs[sSaltAttribute];
+                        uno::Sequence < sal_Int8 > aDecodeBuffer;
+                        Base64Codec::decodeBase64 ( aDecodeBuffer, aString );
+                        aSequence[nNumProperty].Name = sSaltProperty;
+                        aSequence[nNumProperty++].Value <<= aDecodeBuffer;
+
+                        aString = aConvertedAttribs[sIterationCountAttribute];
+                        aSequence[nNumProperty].Name = sIterationCountProperty;
+                        aSequence[nNumProperty++].Value <<= aString.toInt32();
+
+                        aString = aConvertedAttribs[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( sal_False, "Default derived key length differs from the expected one!" );
+
+                        aSequence[nNumProperty].Name = sDerivedKeySizeProperty;
+                        aSequence[nNumProperty++].Value <<= nDerivedKeySize;
+                    }
+                    else
+                        bIgnoreEncryptData = sal_True;
+                }
+            }
+            else if ( aConvertedName == sStartKeyAlgElement )
+            {
+                OUString aString = aConvertedAttribs[sStartKeyAlgNameAttribute];
+                if ( aString.equals( sSHA256_URL ) )
+                {
+                    aSequence[nNumProperty].Name = sStartKeyAlgProperty;
+                    aSequence[nNumProperty++].Value <<= xml::crypto::DigestID::SHA256;
+                }
+                else if ( aString.equals( sSHA1_Name ) || aString.equals( sSHA1_URL ) )
                 {
-                    aString = aConvertedAttribs[sSaltAttribute];
-                    Sequence < sal_uInt8 > aDecodeBuffer;
-                    Base64Codec::decodeBase64 ( aDecodeBuffer, aString );
-                    aSequence[nNumProperty].Name = sSaltProperty;
-                    aSequence[nNumProperty++].Value <<= aDecodeBuffer;
-
-                    aString = aConvertedAttribs[sIterationCountAttribute];
-                    aSequence[nNumProperty].Name = sIterationCountProperty;
-                    aSequence[nNumProperty++].Value <<= aString.toInt32();
+                    aSequence[nNumProperty].Name = sStartKeyAlgProperty;
+                    aSequence[nNumProperty++].Value <<= xml::crypto::DigestID::SHA1;
                 }
                 else
-                    // If we don't recognise the key derivation technique, then the
-                    // algorithm info is useless to us
                     bIgnoreEncryptData = sal_True;
             }
         }
diff --git a/package/source/manifest/ManifestImport.hxx b/package/source/manifest/ManifestImport.hxx
index 4b74d903ee76..1c646a7952a6 100644
--- a/package/source/manifest/ManifestImport.hxx
+++ b/package/source/manifest/ManifestImport.hxx
@@ -65,12 +65,14 @@ protected:
     sal_Int16       nNumProperty;
     ManifestStack aStack;
     sal_Bool bIgnoreEncryptData;
+    sal_Int32 nDerivedKeySize;
     ::std::vector < ::com::sun::star::uno::Sequence < ::com::sun::star::beans::PropertyValue > > & rManVector;
 
     const ::rtl::OUString sFileEntryElement;
     const ::rtl::OUString sManifestElement;
     const ::rtl::OUString sEncryptionDataElement;
     const ::rtl::OUString sAlgorithmElement;
+    const ::rtl::OUString sStartKeyAlgElement;
     const ::rtl::OUString sKeyDerivationElement;
 
     const ::rtl::OUString sCdataAttribute;
@@ -81,7 +83,9 @@ protected:
     const ::rtl::OUString sSaltAttribute;
     const ::rtl::OUString sInitialisationVectorAttribute;
     const ::rtl::OUString sIterationCountAttribute;
+    const ::rtl::OUString sKeySizeAttribute;
     const ::rtl::OUString sAlgorithmNameAttribute;
+    const ::rtl::OUString sStartKeyAlgNameAttribute;
     const ::rtl::OUString sKeyDerivationNameAttribute;
     const ::rtl::OUString sChecksumAttribute;
     const ::rtl::OUString sChecksumTypeAttribute;
@@ -90,15 +94,33 @@ protected:
     const ::rtl::OUString sMediaTypeProperty;
     const ::rtl::OUString sVersionProperty;
     const ::rtl::OUString sIterationCountProperty;
+    const ::rtl::OUString sDerivedKeySizeProperty;
     const ::rtl::OUString sSaltProperty;
     const ::rtl::OUString sInitialisationVectorProperty;
     const ::rtl::OUString sSizeProperty;
     const ::rtl::OUString sDigestProperty;
+    const ::rtl::OUString sEncryptionAlgProperty;
+    const ::rtl::OUString sStartKeyAlgProperty;
+    const ::rtl::OUString sDigestAlgProperty;
 
     const ::rtl::OUString sWhiteSpace;
-    const ::rtl::OUString sBlowfish;
-    const ::rtl::OUString sPBKDF2;
-    const ::rtl::OUString sChecksumType;
+
+    const ::rtl::OUString sSHA256_URL;
+    const ::rtl::OUString sSHA1_Name;
+    const ::rtl::OUString sSHA1_URL;
+
+    const ::rtl::OUString sSHA256_1k_URL;
+    const ::rtl::OUString sSHA1_1k_Name;
+    const ::rtl::OUString sSHA1_1k_URL;
+
+    const ::rtl::OUString sBlowfish_Name;
+    const ::rtl::OUString sBlowfish_URL;
+    const ::rtl::OUString sAES128_URL;
+    const ::rtl::OUString sAES192_URL;
+    const ::rtl::OUString sAES256_URL;
+
+    const ::rtl::OUString sPBKDF2_Name;
+    const ::rtl::OUString sPBKDF2_URL;
 
 
     ::rtl::OUString PushNameAndNamespaces( const ::rtl::OUString& aName,
diff --git a/package/source/manifest/UnoRegister.cxx b/package/source/manifest/UnoRegister.cxx
index fc0781c11088..c5734977de46 100644
--- a/package/source/manifest/UnoRegister.cxx
+++ b/package/source/manifest/UnoRegister.cxx
@@ -37,6 +37,7 @@
 
 #include <zipfileaccess.hxx>
 
+using namespace ::com::sun::star;
 using namespace ::com::sun::star::uno;
 using namespace ::com::sun::star::beans;
 using namespace ::com::sun::star::lang;
@@ -57,9 +58,9 @@ extern "C" SAL_DLLPUBLIC_EXPORT void * SAL_CALL component_getFactory(
     const sal_Char * pImplName, void * pServiceManager, void * /*pRegistryKey*/ )
 {
     void * pRet = 0;
-    Reference< XMultiServiceFactory > xSMgr(
+    uno::Reference< XMultiServiceFactory > xSMgr(
             reinterpret_cast< XMultiServiceFactory * >( pServiceManager ) );
-    Reference< XSingleServiceFactory > xFactory;
+    uno::Reference< XSingleServiceFactory > xFactory;
 
     if (ManifestReader::static_getImplementationName().compareToAscii( pImplName ) == 0)
         xFactory = ManifestReader::createServiceFactory ( xSMgr );