Option to open container offline mode

metsma · metsma · commit 0db7002d66dd · 2022-01-27T15:09:31.000+02:00
IB-7287

Signed-off-by: Raul Metsma &lt;raul@metsma.ee&gt;
diff --git a/libdigidocpp.dox b/libdigidocpp.dox
@@ -1400,6 +1400,8 @@ Signature Validation Policy
 Default POLv2
 
 http://open-eid.github.io/SiVa/siva/appendix/validation_policy/"</td></tr>
+<tr><td>\-\-offline	</td><td>Optional</td><td>
+open container offline (eg. Don't send to SiVa)</td></tr>
 <tr><td>\-\-warnings=
 
 (ignore, warning, error)	</td><td>Optional</td><td>
diff --git a/libdigidocpp.i b/libdigidocpp.i
@@ -241,7 +241,7 @@ namespace std {
 %include "crypto/Signer.h"
 %include "crypto/PKCS12Signer.h"
 %include "crypto/PKCS11Signer.h"
-#ifdef SWIGCSHARP
+#ifdef _WIN32
 %include "crypto/WinSigner.h"
 #endif
 %include "libdigidocpp.i.h"
@@ -277,16 +277,21 @@ namespace std {
     }
 }
 %extend digidoc::Container {
+    static digidoc::Container* open(const std::string &path, OpenFlags flags)
+    {
+        return digidoc::Container::openPtr(path, flags).release();
+    }
+
     Signature* prepareWebSignature(const std::vector<unsigned char> &cert, const std::string &profile = {},
                                    const std::vector<std::string> &roles = {},
                                    const std::string &city = {}, const std::string &state = {},
                                    const std::string &postalCode = {}, const std::string &country = {})
     {
-        class : public digidoc::Signer
+        class final: public digidoc::Signer
         {
         public:
-            digidoc::X509Cert cert() const override { return _cert; }
-            std::vector<unsigned char> sign(const std::string &, const std::vector<unsigned char> &) const override
+            digidoc::X509Cert cert() const final { return _cert; }
+            std::vector<unsigned char> sign(const std::string &, const std::vector<unsigned char> &) const final
             {
                 THROW("Not implemented");
             }
diff --git a/src/ASiC_E.cpp b/src/ASiC_E.cpp
@@ -113,7 +113,7 @@ void ASiC_E::save(const string &path)
     s.addFile("META-INF/manifest.xml", manifest, zproperty("META-INF/manifest.xml"));
 
     for(const DataFile *file: dataFiles())
-        s.addFile(file->fileName(), *(static_cast<const DataFilePrivate*>(file)->m_is.get()), zproperty(file->fileName()));
+        s.addFile(file->fileName(), *(static_cast<const DataFilePrivate*>(file)->m_is), zproperty(file->fileName()));
 
     unsigned int i = 0;
     for(Signature *iter: signatures())
@@ -158,9 +158,9 @@ void ASiC_E::addAdESSignature(istream &sigdata)
     }
 }
 
-unique_ptr<Container> ASiC_E::openInternal(const string &path)
+unique_ptr<Container> ASiC_E::openInternal(const string &path, OpenFlags flags)
 {
-    DEBUG("ASiC_E::openInternal(%s)", path.c_str());
+    DEBUG("ASiC_E::openInternal(%s, %d)", path.c_str(), flags);
     return unique_ptr<Container>(new ASiC_E(path));
 }
 
@@ -181,13 +181,13 @@ void ASiC_E::createManifest(ostream &os)
     try
     {
         Manifest manifest;
-        manifest.file_entry().push_back({"/", mediaType()});
+        manifest.file_entry().push_back(make_unique<File_entry>("/", mediaType()));
         for(const DataFile *file: dataFiles())
-            manifest.file_entry().push_back({file->fileName(), file->mediaType()});
+            manifest.file_entry().push_back(make_unique<File_entry>(file->fileName(), file->mediaType()));
 
         xml_schema::NamespaceInfomap map;
         map["manifest"].name = ASiC_E::MANIFEST_NAMESPACE;
-        manifest::manifest(os, manifest, map, {}, xml_schema::Flags::dont_initialize);
+        manifest::manifest(os, manifest, map, "UTF-8", xml_schema::Flags::dont_initialize);
         if(os.fail())
             THROW("Failed to create manifest XML");
     }
@@ -233,8 +233,8 @@ void ASiC_E::parseManifestAndLoadFiles(const ZipSerialize &z)
         z.extract("META-INF/manifest.xml", manifestdata);
         xml_schema::Properties p;
         p.schema_location(ASiC_E::MANIFEST_NAMESPACE,
-			File::fullPathUrl(Conf::instance()->xsdPath() + "/OpenDocument_manifest.xsd"));
-		unique_ptr<xercesc::DOMDocument> doc = SecureDOMParser(p.schema_location(), true).parseIStream(manifestdata);
+            File::fullPathUrl(Conf::instance()->xsdPath() + "/OpenDocument_manifest.xsd"));
+        unique_ptr<xercesc::DOMDocument> doc = SecureDOMParser(p.schema_location(), true).parseIStream(manifestdata);
         unique_ptr<Manifest> manifest = manifest::manifest(*doc, {}, p);
 
         set<string> manifestFiles;
diff --git a/src/ASiC_E.h b/src/ASiC_E.h
@@ -53,7 +53,7 @@ namespace digidoc
           Signature* sign(Signer* signer) final;
 
           static std::unique_ptr<Container> createInternal(const std::string &path);
-          static std::unique_ptr<Container> openInternal(const std::string &path);
+          static std::unique_ptr<Container> openInternal(const std::string &path, OpenFlags flags);
 
       private:
           ASiC_E();
diff --git a/src/ASiC_S.cpp b/src/ASiC_S.cpp
@@ -58,7 +58,7 @@ void ASiC_S::addDataFile(const string &path, const string &mediaType)
 {
     if(!dataFiles().empty())
         THROW("Can not add document to ASiC-S container which already contains a document.");
-        
+
     ASiContainer::addDataFile(path, mediaType);
 }
 
@@ -80,11 +80,11 @@ void ASiC_S::addAdESSignature(istream & /*signature*/)
     THROW("Not implemented.");
 }
 
-unique_ptr<Container> ASiC_S::openInternal(const string &path)
+unique_ptr<Container> ASiC_S::openInternal(const string &path, OpenFlags flags)
 {
     if (!isContainerSimpleFormat(path))
         return nullptr;
-    DEBUG("ASiC_S::openInternal(%s)", path.c_str());
+    DEBUG("ASiC_S::openInternal(%s, %d)", path.c_str(), flags);
     return unique_ptr<Container>(new ASiC_S(path));
 }
 
@@ -149,10 +149,10 @@ bool ASiC_S::isTimestampedASiC_S(const vector<string> &list)
 {
     DEBUG("isTimestampedASiC_S()");
     bool isASiCS = false;
-    
+
     auto dataFiles = 0;
     auto hasTimestamp = false;
-    
+
     // container has only one file in root folder and has a timestamp
     for(const string &file: list)
     {
@@ -191,7 +191,7 @@ bool ASiC_S::isContainerSimpleFormat(const string &path)
     {
         ZipSerialize z(path, false);
         vector<string> list = z.list();
-        if(find(list.begin(), list.end(), "mimetype") != list.end())
+        if(find(list.cbegin(), list.cend(), "mimetype") != list.cend())
         {
             stringstream iss;
             z.extract("mimetype", iss);
diff --git a/src/ASiC_S.h b/src/ASiC_S.h
@@ -44,7 +44,7 @@ namespace digidoc
         Signature* sign(Signer* signer) override;
 
         static std::unique_ptr<Container> createInternal(const std::string &path);
-        static std::unique_ptr<Container> openInternal(const std::string &path);
+        static std::unique_ptr<Container> openInternal(const std::string &path, OpenFlags flags);
 
     private:
         ASiC_S();
diff --git a/src/Container.cpp b/src/Container.cpp
@@ -63,14 +63,15 @@ using namespace digidoc;
 using namespace std;
 using namespace xercesc;
 
-using plugin = unique_ptr<Container> (*)(const std::string &);
+using pluginCreate = unique_ptr<Container> (*)(const std::string &);
+using pluginOpen = unique_ptr<Container> (*)(const std::string &, Container::OpenFlags);
 
 namespace digidoc
 {
 static string m_appName = "libdigidocpp";
 static string m_userAgent = "libdigidocpp";
-static vector<plugin> m_createList = {};
-static vector<plugin> m_openList = {};
+static vector<pluginCreate> m_createList = {};
+static vector<pluginOpen> m_openList = {};
 }
 
 /**
@@ -349,13 +350,25 @@ Container* Container::open(const string &path)
  * @throws Exception
  */
 unique_ptr<Container> Container::openPtr(const string &path)
+{
+    return openPtr(path, OpenDefault);
+}
+
+/**
+ * Opens container from a file
+ *
+ * @param path
+ * @param flags
+ * @throws Exception
+ */
+unique_ptr<Container> Container::openPtr(const string &path, OpenFlags flags)
 {
     for(auto open: m_openList)
     {
-        if(unique_ptr<Container> container = open(path))
+        if(unique_ptr<Container> container = open(path, flags))
             return container;
     }
-    return ASiC_E::openInternal(path);
+    return ASiC_E::openInternal(path, flags);
 }
 
 /**
@@ -418,7 +431,7 @@ unique_ptr<Container> Container::openPtr(const string &path)
  *
  * It must contain static members:
  * * static Container* createInternal(const std::string &path);
- * * static Container* openInternal(const std::string &path);
+ * * static Container* openInternal(const std::string &path, OpenFlags flags);
  *
  * @see Container::create, Container::open
  */
diff --git a/src/Container.h b/src/Container.h
@@ -43,6 +43,10 @@ DIGIDOCPP_EXPORT std::string version();
 class DIGIDOCPP_EXPORT Container
 {
 public:
+    enum OpenFlags {
+        OpenDefault = 0,
+        OpenOffline = 1,
+    };
     virtual ~Container();
 
     virtual void save(const std::string &path = "") = 0;
@@ -66,6 +70,7 @@ class DIGIDOCPP_EXPORT Container
     static std::unique_ptr<Container> createPtr(const std::string &path);
     DIGIDOCPP_DEPRECATED static Container* open(const std::string &path);
     static std::unique_ptr<Container> openPtr(const std::string &path);
+    static std::unique_ptr<Container> openPtr(const std::string &path, OpenFlags flags);
     template<class T>
     static void addContainerImplementation();
 
diff --git a/src/SiVaContainer.cpp b/src/SiVaContainer.cpp
@@ -140,7 +140,7 @@ void SignatureSiVa::validate(const string &policy) const
 }
 
 
-SiVaContainer::SiVaContainer(const string &path, const string &ext, bool useHashCode)
+SiVaContainer::SiVaContainer(const string &path, const string &ext, bool useHashCode, bool offline)
     : d(new Private)
 {
     DEBUG("SiVaContainer::SiVaContainer(%s, %s, %d)", path.c_str(), ext.c_str(), useHashCode);
@@ -159,6 +159,10 @@ SiVaContainer::SiVaContainer(const string &path, const string &ext, bool useHash
         d->dataFiles.push_back(new DataFilePrivate(move(ifs), File::fileName(path), "application/pdf", File::fileName(path)));
     }
 
+    if(offline) {
+        return;
+    }
+
     XMLByte buf[48*100];
     string b64;
     is->clear();
@@ -185,6 +189,7 @@ SiVaContainer::SiVaContainer(const string &path, const string &ext, bool useHash
     Connect::Result r = Connect(url, "POST", 0, {}, CONF(verifyServiceCerts)).exec({
         {"Content-Type", "application/json;charset=UTF-8"}
     }, (const unsigned char*)req.c_str(), req.size());
+    req.clear();
 
     if(!r.isOK() && !r.isStatusCode("400"))
         THROW("Failed to send request to SiVa");
@@ -254,7 +259,7 @@ SiVaContainer::SiVaContainer(const string &path, const string &ext, bool useHash
         for(const json &error: signature.value<json>("errors", {}))
         {
             string message = error["content"];
-            if(message.find("Bad digest for DataFile") == 0 && useHashCode)
+            if(message.find("Bad digest for DataFile") != string::npos && useHashCode)
                 THROW(message.c_str());
             s->_exceptions.emplace_back(EXCEPTION_PARAMS(message.c_str()));
         }
@@ -265,7 +270,7 @@ SiVaContainer::SiVaContainer(const string &path, const string &ext, bool useHash
             if(message == "X509IssuerName has none or invalid namespace: null" ||
                 message == "X509SerialNumber has none or invalid namespace: null")
                 ex.setCode(Exception::IssuerNameSpaceWarning);
-            else if(message.find("Bad digest for DataFile") == 0)
+            else if(message.find("Bad digest for DataFile") != string::npos)
                 ex.setCode(Exception::DataFileNameSpaceWarning);
             else if(message == "Old and unsupported format: SK-XML version: 1.0")
                 continue;
@@ -277,10 +282,8 @@ SiVaContainer::SiVaContainer(const string &path, const string &ext, bool useHash
 
 SiVaContainer::~SiVaContainer()
 {
-    for(const Signature *s: d->signatures)
-        delete s;
-    for(const DataFile *f: d->dataFiles)
-        delete f;
+    for_each(d->signatures.cbegin(), d->signatures.cend(), default_delete<Signature>());
+    for_each(d->dataFiles.cbegin(), d->dataFiles.cend(), default_delete<DataFile>());
     delete d;
 }
 
@@ -314,30 +317,28 @@ vector<DataFile *> SiVaContainer::dataFiles() const
     return d->dataFiles;
 }
 
-unique_ptr<Container> SiVaContainer::openInternal(const string &path)
+unique_ptr<Container> SiVaContainer::openInternal(const string &path, OpenFlags flags)
 {
     static const set<string> supported = {"PDF", "DDOC"};
     string ext = File::fileExtension(path);
     transform(ext.begin(), ext.end(), ext.begin(), ::toupper);
     if(!supported.count(ext))
         return {};
     try {
-        return unique_ptr<Container>(new SiVaContainer(path, ext, true));
+        return unique_ptr<Container>(new SiVaContainer(path, ext, true, flags & OpenOffline));
     } catch(const Exception &e) {
-        if(e.msg().find("Bad digest for DataFile") == 0)
-            return unique_ptr<Container>(new SiVaContainer(path, ext, false));
+        if(e.msg().find("Bad digest for DataFile") != string::npos)
+            return unique_ptr<Container>(new SiVaContainer(path, ext, false, flags & OpenOffline));
         throw;
     }
 }
 
 stringstream* SiVaContainer::parseDDoc(istream &is, bool useHashCode)
 {
-    auto transcode = [](const XMLCh *chr) {
-        return xsd::cxx::xml::transcode<char>(chr);
-    };
+    using xsd::cxx::xml::transcode;
+    using cpXMLCh = const XMLCh*;
     try
     {
-        using cpXMLCh = const XMLCh*;
         unique_ptr<DOMDocument> dom(SecureDOMParser().parseIStream(is));
         DOMNodeList *nodeList = dom->getElementsByTagName(cpXMLCh(u"DataFile"));
         for(XMLSize_t i = 0; i < nodeList->getLength(); ++i)
@@ -354,7 +355,9 @@ stringstream* SiVaContainer::parseDDoc(istream &is, bool useHashCode)
             if(const XMLCh *b64 = item->getTextContent())
             {
                 d->dataFiles.push_back(new DataFilePrivate(unique_ptr<istream>(new stringstream(base64_decode(b64))),
-                    transcode(item->getAttribute(cpXMLCh(u"Filename"))), transcode(item->getAttribute(cpXMLCh(u"MimeType"))), transcode(item->getAttribute(cpXMLCh(u"Id")))));
+                    transcode<char>(item->getAttribute(cpXMLCh(u"Filename"))),
+                    transcode<char>(item->getAttribute(cpXMLCh(u"MimeType"))),
+                    transcode<char>(item->getAttribute(cpXMLCh(u"Id")))));
             }
 
             if(!useHashCode)
@@ -387,7 +390,7 @@ stringstream* SiVaContainer::parseDDoc(istream &is, bool useHashCode)
     catch(const XMLException& e)
     {
         try {
-            string result = transcode(e.getMessage());
+            string result = transcode<char>(e.getMessage());
             THROW("Failed to parse DDoc XML: %s", result.c_str());
         } catch(const xsd::cxx::xml::invalid_utf16_string & /* ex */) {
             THROW("Failed to parse DDoc XML.");
@@ -396,7 +399,7 @@ stringstream* SiVaContainer::parseDDoc(istream &is, bool useHashCode)
     catch(const DOMException& e)
     {
         try {
-            string result = transcode(e.getMessage());
+            string result = transcode<char>(e.getMessage());
             THROW("Failed to parse DDoc XML: %s", result.c_str());
         } catch(const xsd::cxx::xml::invalid_utf16_string & /* ex */) {
             THROW("Failed to parse DDoc XML.");
diff --git a/src/SiVaContainer.h b/src/SiVaContainer.h
@@ -99,10 +99,10 @@ class SiVaContainer final: public Container
     Signature* sign(Signer* signer) final;
 
     static std::unique_ptr<Container> createInternal(const std::string &path);
-    static std::unique_ptr<Container> openInternal(const std::string &path);
+    static std::unique_ptr<Container> openInternal(const std::string &path, OpenFlags flags);
 
 private:
-    SiVaContainer(const std::string &path, const std::string &ext, bool useHashCode);
+    SiVaContainer(const std::string &path, const std::string &ext, bool useHashCode = true, bool offline = true);
     DISABLE_COPY(SiVaContainer);
 
     std::stringstream* parseDDoc(std::istream &is, bool useHashCode);
diff --git a/src/digidoc-tool.1.cmake b/src/digidoc-tool.1.cmake
@@ -24,7 +24,8 @@ Command open:
     --warnings=(ignore,warning,error) - warning handling
     --policy=(POLv1,POLv2) - Signature Validation Policy (default POLv2)
                              http://open-eid.github.io/SiVa/siva/appendix/validation_policy/
-    --extractAll[=path] - extracts documents (to path when provided)
+    --extractAll[=path]    - extracts documents (to path when provided)
+    --offline              - open container offline (eg. Don't send to SiVa)
 
 Command add:
   Example: digidoc-tool add --file=file1.txt container-file.asice
diff --git a/src/digidoc-tool.cpp b/src/digidoc-tool.cpp

Original file line number	Diff line number	Diff line change
`@@ -241,7 +241,7 @@ namespace std {`
`241`	`241`	`%include "crypto/Signer.h"`
`242`	`242`	`%include "crypto/PKCS12Signer.h"`
`243`	`243`	`%include "crypto/PKCS11Signer.h"`
`244`		`-#ifdef SWIGCSHARP`
	`244`	`+#ifdef _WIN32`
`245`	`245`	`%include "crypto/WinSigner.h"`
`246`	`246`	`#endif`
`247`	`247`	`%include "libdigidocpp.i.h"`
`@@ -277,16 +277,21 @@ namespace std {`
`277`	`277`	`}`
`278`	`278`	`}`
`279`	`279`	`%extend digidoc::Container {`
	`280`	`+ static digidoc::Container* open(const std::string &path, OpenFlags flags)`
	`281`	`+ {`
	`282`	`+ return digidoc::Container::openPtr(path, flags).release();`
	`283`	`+ }`
	`284`	`+`
`280`	`285`	`Signature* prepareWebSignature(const std::vector<unsigned char> &cert, const std::string &profile = {},`
`281`	`286`	`const std::vector<std::string> &roles = {},`
`282`	`287`	`const std::string &city = {}, const std::string &state = {},`
`283`	`288`	`const std::string &postalCode = {}, const std::string &country = {})`
`284`	`289`	`{`
`285`		`- class : public digidoc::Signer`
	`290`	`+ class final: public digidoc::Signer`
`286`	`291`	`{`
`287`	`292`	`public:`
`288`		`- digidoc::X509Cert cert() const override { return _cert; }`
`289`		`- std::vector<unsigned char> sign(const std::string &, const std::vector<unsigned char> &) const override`
	`293`	`+ digidoc::X509Cert cert() const final { return _cert; }`
	`294`	`+ std::vector<unsigned char> sign(const std::string &, const std::vector<unsigned char> &) const final`
`290`	`295`	`{`
`291`	`296`	`THROW("Not implemented");`
`292`	`297`	`}`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ void ASiC_S::addDataFile(const string &path, const string &mediaType)`
`58`	`58`	`{`
`59`	`59`	`if(!dataFiles().empty())`
`60`	`60`	`THROW("Can not add document to ASiC-S container which already contains a document.");`
`61`		`-`
	`61`	`+`
`62`	`62`	`ASiContainer::addDataFile(path, mediaType);`
`63`	`63`	`}`
`64`	`64`
`@@ -80,11 +80,11 @@ void ASiC_S::addAdESSignature(istream & /signature/)`
`80`	`80`	`THROW("Not implemented.");`
`81`	`81`	`}`
`82`	`82`
`83`		`-unique_ptr<Container> ASiC_S::openInternal(const string &path)`
	`83`	`+unique_ptr<Container> ASiC_S::openInternal(const string &path, OpenFlags flags)`
`84`	`84`	`{`
`85`	`85`	`if (!isContainerSimpleFormat(path))`
`86`	`86`	`return nullptr;`
`87`		`- DEBUG("ASiC_S::openInternal(%s)", path.c_str());`
	`87`	`+ DEBUG("ASiC_S::openInternal(%s, %d)", path.c_str(), flags);`
`88`	`88`	`return unique_ptr<Container>(new ASiC_S(path));`
`89`	`89`	`}`
`90`	`90`
`@@ -149,10 +149,10 @@ bool ASiC_S::isTimestampedASiC_S(const vector<string> &list)`
`149`	`149`	`{`
`150`	`150`	`DEBUG("isTimestampedASiC_S()");`
`151`	`151`	`bool isASiCS = false;`
`152`		`-`
	`152`	`+`
`153`	`153`	`auto dataFiles = 0;`
`154`	`154`	`auto hasTimestamp = false;`
`155`		`-`
	`155`	`+`
`156`	`156`	`// container has only one file in root folder and has a timestamp`
`157`	`157`	`for(const string &file: list)`
`158`	`158`	`{`
`@@ -191,7 +191,7 @@ bool ASiC_S::isContainerSimpleFormat(const string &path)`
`191`	`191`	`{`
`192`	`192`	`ZipSerialize z(path, false);`
`193`	`193`	`vector<string> list = z.list();`
`194`		`- if(find(list.begin(), list.end(), "mimetype") != list.end())`
	`194`	`+ if(find(list.cbegin(), list.cend(), "mimetype") != list.cend())`
`195`	`195`	`{`
`196`	`196`	`stringstream iss;`
`197`	`197`	`z.extract("mimetype", iss);`