Fix a bug : export key doesn't supports output in a target file

.gitignore

@@ -4,5 +4,5 @@ lib
 *.so
 *~
 utils/acsmdownloader
-utils/activate
+utils/adept_activate
 .adept

Makefile

@@ -2,8 +2,26 @@
 AR ?= $(CROSS)ar
 CXX ?= $(CROSS)g++
 
-CXXFLAGS=-Wall -fPIC -I./include -I./lib -I./lib/pugixml/src/
-LDFLAGS=
+UPDFPARSERLIB = ./lib/updfparser/libupdfparser.a
+
+CXXFLAGS=-Wall -fPIC -I./include -I./lib -I./lib/pugixml/src/ -I./lib/updfparser/include
+LDFLAGS = $(UPDFPARSERLIB)
+
+BUILD_STATIC ?= 0
+BUILD_SHARED ?= 1
+BUILD_UTILS  ?= 1
+
+TARGETS =
+ifneq ($(BUILD_STATIC), 0)
+  TARGETS += libgourou.a
+endif
+ifneq ($(BUILD_SHARED), 0)
+  TARGETS += libgourou.so
+endif
+ifneq ($(BUILD_UTILS), 0)
+  TARGETS += build_utils
+endif
+
 
 ifneq ($(DEBUG),)
 CXXFLAGS += -ggdb -O0
@@ -18,12 +36,10 @@ TARGETDIR   := bin
 SRCEXT      := cpp
 OBJEXT      := o
 
-SOURCES=src/libgourou.cpp src/user.cpp src/device.cpp src/fulfillment_item.cpp src/bytearray.cpp src/pugixml.cpp
+SOURCES      = src/libgourou.cpp src/user.cpp src/device.cpp src/fulfillment_item.cpp src/bytearray.cpp src/pugixml.cpp
 OBJECTS     := $(patsubst $(SRCDIR)/%,$(BUILDDIR)/%,$(SOURCES:.$(SRCEXT)=.$(OBJEXT)))
 
-.PHONY: utils
-
-all: lib obj libgourou utils
+all: lib obj $(TARGETS)
 
 lib:
 	mkdir lib
@@ -38,12 +54,12 @@ $(BUILDDIR)/%.$(OBJEXT): $(SRCDIR)/%.$(SRCEXT)
 libgourou: libgourou.a libgourou.so
 
 libgourou.a: $(OBJECTS)
-	$(AR) crs $@ obj/*.o
+	$(AR) crs $@ obj/*.o $(LDFLAGS)
 
-libgourou.so: libgourou.a
+libgourou.so: $(OBJECTS) $(UPDFPARSERLIB)
 	$(CXX) obj/*.o $(LDFLAGS) -o $@ -shared
 
-utils:
+build_utils:
 	make -C utils ROOT=$(PWD) CXX=$(CXX) AR=$(AR) DEBUG=$(DEBUG) STATIC_UTILS=$(STATIC_UTILS)
 
 clean:

README.md

@@ -1,7 +1,7 @@
 Introduction
 ------------
 
-libgourou is a free implementation of Adobe's ADEPT protocol used to add DRM on ePub files. It overcome the lacks of Adobe support for Linux platforms.
+libgourou is a free implementation of Adobe's ADEPT protocol used to add DRM on ePub/PDF files. It overcome the lacks of Adobe support for Linux platforms.
 
 
 Architecture
@@ -19,13 +19,15 @@ Main fucntions to use from gourou::DRMProcessor are :
 
 You can import configuration from (at least) :
 
-  * Kobo device : .adept/device.xml, .adept/devicesalt  and .adept/activation.xml
+  * Kobo device    : .adept/device.xml, .adept/devicesalt  and .adept/activation.xml
   * Bookeen device : .adobe-digital-editions/device.xml, root/devkey.bin and .adobe-digital-editions/activation.xml
   
 Or create a new one. Be careful : there is a limited number of devices that can be created bye one account.
 
 ePub are encrypted using a shared key : one account / multiple devices, so you can create and register a device into your computer and read downloaded (and encrypted) ePub file with your eReader configured using the same AdobeID account.
 
+For those who wants to remove DRM, you can export your private key and import it within [Calibre](https://calibre-ebook.com/) an its DeDRM plugin.
+
 
 Dependencies
 ------------
@@ -47,14 +49,21 @@ Compilation
 
 Use _make_ command
 
-    make [CROSS=XXX] [DEBUG=1] [STATIC_UTILS=1]
+    make [CROSS=XXX] [DEBUG=(0*|1)] [STATIC_UTILS=(0*|1)] [BUILD_UTILS=(0|1*)] [BUILD_STATIC=(0*|1)] [BUILD_SHARED=(0|1*)]
 
 CROSS can define a cross compiler prefix (ie arm-linux-gnueabihf-)
 
 DEBUG can be set to compile in DEBUG mode
 
+BUILD_UTILS to build utils or not
+
 STATIC_UTILS to build utils with static library (libgourou.a) instead of default dynamic one (libgourou.so)
 
+BUILD_STATIC build libgourou.a if 1, nothing if 0, can be combined with BUILD_SHARED
+
+BUILD_SHARED build libgourou.so if 1, nothing if 0, can be combined with BUILD_STATIC
+
+* Default value
 
 Utils
 -----
@@ -66,11 +75,16 @@ You can import configuration from your eReader or create a new one with utils/ac
 
 Then a _./.adept_ directory is created with all configuration file
 
-To download an ePub :
+To download an ePub/PDF :
 
     export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$PWD
     ./utils/acsmdownloader -f <ACSM_FILE>
 
+To export your private key :
+
+    export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$PWD
+    ./utils/acsmdownloader --export-private-key [-o adobekey_1.der]
+
 
 Copyright
 ---------

README_package.md

@@ -1,7 +1,7 @@
 Introduction
 ------------
 
-libgourou is a free implementation of Adobe's ADEPT protocol used to add DRM on ePub files. It overcome the lacks of Adobe support for Linux platforms.
+libgourou is a free implementation of Adobe's ADEPT protocol used to add DRM on ePub/PDF files. It overcome the lacks of Adobe support for Linux platforms.
 
 
 
@@ -24,18 +24,22 @@ For utils :
 Utils
 -----
 
-You can import configuration from your eReader or create a new one with activate :
+You can import configuration from your eReader or create a new one with utils/activate :
 
     export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$PWD
-    ./activate -u <AdobeID USERNAME>
+    ./utils/activate -u <AdobeID USERNAME>
 
 Then a _./.adept_ directory is created with all configuration file
 
-To download an ePub :
+To download an ePub/PDF :
 
     export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$PWD
-    ./acsmdownloader -f <ACSM_FILE>
+    ./utils/acsmdownloader -f <ACSM_FILE>
 
+To export your private key :
+
+    export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$PWD
+    ./utils/acsmdownloader --export-private-key [-o adobekey_1.der]
 
 
 Sources

include/drmprocessorclient.h

@@ -21,6 +21,7 @@
 #define _DRMPROCESSORCLIENT_H_
 
 #include <string>
+#include <bytearray.h>
 
 namespace gourou
 {
@@ -93,11 +94,14 @@ namespace gourou
 	/**
 	 * @brief Send HTTP (GET or POST) request
 	 *
-	 * @param URL            HTTP URL
-	 * @param POSTData       POST data if needed, if not set, a GET request is done
-	 * @param contentType    Optional content type of POST Data
+	 * @param URL             HTTP URL
+	 * @param POSTData        POST data if needed, if not set, a GET request is done
+	 * @param contentType     Optional content type of POST Data
+	 * @param responseHeaders Optional Response headers of HTTP request
+	 *
+	 * @return data of HTTP response
 	 */
-	virtual std::string sendHTTPRequest(const std::string& URL, const std::string& POSTData=std::string(""), const std::string& contentType=std::string("")) = 0;
+	virtual std::string sendHTTPRequest(const std::string& URL, const std::string& POSTData=std::string(""), const std::string& contentType=std::string(""), std::map<std::string, std::string>* responseHeaders=0) = 0;
     };
 
     class RSAInterface
@@ -355,6 +359,27 @@ namespace gourou
 	 * @param handler        ZIP file handler
 	 */
 	virtual void zipClose(void* handler) = 0;
+
+	/**
+	 * @brief Inflate algorithm
+	 *
+	 * @param data           Data to inflate
+	 * @param result         Zipped data
+	 * @param wbits          Window bits value for libz
+	 */
+	virtual void inflate(std::string data, gourou::ByteArray& result,
+			     int wbits=-15) = 0;
+	
+	/**
+	 * @brief Deflate algorithm
+	 *
+	 * @param data           Data to deflate
+	 * @param result         Unzipped data
+	 * @param wbits          Window bits value for libz
+	 * @param compressionLevel Compression level for libz
+	 */
+	virtual void deflate(std::string data, gourou::ByteArray& result,
+			     int wbits=-15, int compressionLevel=8) = 0;
     };
     
     class DRMProcessorClient: public DigestInterface, public RandomInterface, public HTTPInterface, \

include/fulfillment_item.h

@@ -53,10 +53,16 @@ namespace gourou
 	 */
 	std::string getDownloadURL();
 
+	/**
+	 * @brief Return resource value
+	 */
+	std::string getResource();
+
     private:
 	pugi::xml_node metadatas;
 	pugi::xml_document rights;
 	std::string downloadURL;
+	std::string resource;
 
 	void buildRights(const pugi::xml_node& licenseToken, User* user);
     };

include/libgourou.h

@@ -40,7 +40,7 @@
 #define ACS_SERVER              "http://adeactivate.adobe.com/adept"
 #endif
 
-#define LIBGOUROU_VERSION       "0.3.2"
+#define LIBGOUROU_VERSION       "0.4.1"
 
 namespace gourou
 {
@@ -53,6 +53,7 @@ namespace gourou
 
 	static const std::string VERSION;
 
+	enum ITEM_TYPE { EPUB=0, PDF };
 	/**
 	 * @brief Main constructor. To be used once all is configured (user has signedIn, device is activated)
 	 *
@@ -80,8 +81,10 @@ namespace gourou
 	 *
 	 * @param item            Item from fulfill() method
 	 * @param path            Output file path 
+	 *
+	 * @return Type of downloaded item
 	 */
-	void download(FulfillmentItem* item, std::string path);
+	ITEM_TYPE download(FulfillmentItem* item, std::string path);
 
 	/**
 	 * @brief SignIn into ACS Server (required to activate device)
@@ -130,8 +133,11 @@ namespace gourou
 	 * @param URL            HTTP URL
 	 * @param POSTData       POST data if needed, if not set, a GET request is done
 	 * @param contentType    Optional content type of POST Data
+	 * @param responseHeaders Optional Response headers of HTTP request
+	 *
+	 * @return data of HTTP response
 	 */
-	ByteArray sendRequest(const std::string& URL, const std::string& POSTData=std::string(), const char* contentType=0);
+	ByteArray sendRequest(const std::string& URL, const std::string& POSTData=std::string(), const char* contentType=0, std::map<std::string, std::string>* responseHeaders=0);
 
 	/**
 	 * @brief Send HTTP POST request to URL with document as POSTData
@@ -158,6 +164,8 @@ namespace gourou
 	 */
 	std::string serializeRSAPrivateKey(void* rsa);
 
+	void exportPrivateLicenseKey(std::string path);
+	
 	/**
 	 * @brief Get current user
 	 */
@@ -194,6 +202,8 @@ namespace gourou
 	void buildActivateReq(pugi::xml_document& activateReq);
 	ByteArray sendFulfillRequest(const pugi::xml_document& document, const std::string& url);
 	void buildSignInRequest(pugi::xml_document& signInRequest, const std::string& adobeID, const std::string& adobePassword, const std::string& authenticationCertificate);
+	void fetchLicenseServiceCertificate(const std::string& licenseURL,
+					    const std::string& operatorURL);
     };
 }
 

include/libgourou_common.h

@@ -68,6 +68,7 @@ namespace gourou
 
     enum DOWNLOAD_ERROR {
 	DW_NO_ITEM = 0x1200,
+	DW_NO_EBX_HANDLER,
     };
 
     enum SIGNIN_ERROR {
@@ -233,6 +234,32 @@ namespace gourou
         return trim(res);
     }
 
+    static inline std::string extractTextElem(const pugi::xml_node& doc, const char* tagName, bool throwOnNull=true)
+    {
+        pugi::xpath_node xpath_node = doc.select_node(tagName);
+
+        if (!xpath_node)
+	{
+	    if (throwOnNull)
+		EXCEPTION(GOUROU_TAG_NOT_FOUND, "Tag " << tagName << " not found");
+	    
+            return "";
+	}
+
+	pugi::xml_node node = xpath_node.node().first_child();
+
+	if (!node)
+	{
+	    if (throwOnNull)
+		EXCEPTION(GOUROU_TAG_NOT_FOUND, "Text element for tag " << tagName << " not found");
+	    
+            return "";
+	}
+
+	std::string res = node.value();
+        return trim(res);
+    }
+
     /**
      * @brief Append an element to root with a sub text element
      *

include/user.h

@@ -14,13 +14,15 @@
   GNU Lesser General Public License for more details.
 
   You should have received a copy of the GNU Lesser General Public License
-  along with libgourou.  If not, see <http://www.gnu.org/licenses/>.
+  along with libgourou. If not, see <http://www.gnu.org/licenses/>.
 */
 
 #ifndef _USER_H_
 #define _USER_H_
 
 #include <string>
+#include <map>
+
 #include "bytearray.h"
 
 #include <pugixml.hpp>
@@ -46,7 +48,7 @@ namespace gourou
 	std::string& getDeviceFingerprint();
 	std::string& getUsername();
 	std::string& getLoginMethod();
-	std::string& getCertificate();
+	std::string  getLicenseServiceCertificate(std::string url);
 	std::string& getAuthenticationCertificate();
 	std::string& getPrivateLicenseKey();
 
@@ -95,7 +97,7 @@ namespace gourou
 	std::string deviceFingerprint;
 	std::string username;
 	std::string loginMethod;
-	std::string certificate;
+	std::map<std::string,std::string> licenseServiceCertificates;
 	std::string authenticationCertificate;
 	std::string privateLicenseKey;
 

scripts/setup.sh

@@ -12,3 +12,11 @@ fi
 if [ ! -d lib/base64 ] ; then
     git clone https://gist.github.com/f0fd86b6c73063283afe550bc5d77594.git lib/base64
 fi
+
+# uPDFParser
+if [ ! -d lib/updfparser ] ; then
+    git clone git://soutade.fr/updfparser.git lib/updfparser
+    pushd lib/updfparser
+    make BUILD_STATIC=1 BUILD_SHARED=0
+    popd
+fi

src/bytearray.cpp

@@ -37,14 +37,14 @@ namespace gourou
     ByteArray::ByteArray(const char* data, int length)
     {
 	if (length == -1)
-	    length = strlen(data) + 1;
+	    length = strlen(data);
 
 	initData((const unsigned char*)data, (unsigned int) length);
     }
     
     ByteArray::ByteArray(const std::string& str)
     {
-	initData((unsigned char*)str.c_str(), (unsigned int)str.length() + 1);
+	initData((unsigned char*)str.c_str(), (unsigned int)str.length());
     }
 
     void ByteArray::initData(const unsigned char* data, unsigned int length)

src/fulfillment_item.cpp

@@ -36,6 +36,12 @@ namespace gourou
 	if (downloadURL == "")
 	    EXCEPTION(FFI_INVALID_FULFILLMENT_DATA, "No download URL in document");
 	
+	node = doc.select_node("/envelope/fulfillmentResult/resourceItemInfo/resource").node();
+	resource = node.first_child().value();
+
+	if (resource == "")
+	    EXCEPTION(FFI_INVALID_FULFILLMENT_DATA, "No resource in document");
+
 	pugi::xml_node licenseToken = doc.select_node("/envelope/fulfillmentResult/resourceItemInfo/licenseToken").node();
 
 	if (!licenseToken)
@@ -56,11 +62,13 @@ namespace gourou
 	if (!newLicenseToken.attribute("xmlns"))
 	    newLicenseToken.append_attribute("xmlns") = ADOBE_ADEPT_NS;
 
-	pugi::xml_node licenseServiceInfo = root.append_child("licenseServiceInfo");
-	licenseServiceInfo.append_attribute("xmlns") = ADOBE_ADEPT_NS;
-	licenseServiceInfo.append_copy(licenseToken.select_node("licenseURL").node());
-	pugi::xml_node certificate = licenseServiceInfo.append_child("certificate");
-	certificate.append_child(pugi::node_pcdata).set_value(user->getCertificate().c_str());
+	pugi::xml_node licenseServiceInfo = root.append_child("adept:licenseServiceInfo");
+	pugi::xml_node licenseURL = licenseToken.select_node("licenseURL").node();
+	licenseURL.set_name("adept:licenseURL");
+	licenseServiceInfo.append_copy(licenseURL);
+	pugi::xml_node certificate = licenseServiceInfo.append_child("adept:certificate");
+	std::string certificateValue = user->getLicenseServiceCertificate(licenseURL.first_child().value());
+	certificate.append_child(pugi::node_pcdata).set_value(certificateValue.c_str());
     }
     
     std::string FulfillmentItem::getMetadata(std::string name)
@@ -88,4 +96,9 @@ namespace gourou
     {
 	return downloadURL;
     }
+
+    std::string FulfillmentItem::getResource()
+    {
+	return resource;
+    }
 }

src/libgourou.cpp

@@ -22,6 +22,8 @@
 #include <time.h>
 #include <vector>
 
+#include <uPDFParser.h>
+
 #include <libgourou.h>
 #include <libgourou_common.h>
 #include <libgourou_log.h>
@@ -33,6 +35,7 @@
 #define ASN_TEXT        0x04
 #define ASN_ATTRIBUTE   0x05
 
+
 namespace gourou
 {
     GOUROU_LOG_LEVEL logLevel = WARN;
@@ -298,11 +301,11 @@ namespace gourou
 	appendTextElem(root, "adept:expiration", buffer);
     }
     
-    ByteArray DRMProcessor::sendRequest(const std::string& URL, const std::string& POSTdata, const char* contentType)
+    ByteArray DRMProcessor::sendRequest(const std::string& URL, const std::string& POSTdata, const char* contentType, std::map<std::string, std::string>* responseHeaders)
     {
 	if (contentType == 0)
 	    contentType = "";
-	std::string reply = client->sendHTTPRequest(URL, POSTdata, contentType);
+	std::string reply = client->sendHTTPRequest(URL, POSTdata, contentType, responseHeaders);
 
 	pugi::xml_document replyDoc;
 	replyDoc.load_buffer(reply.c_str(), reply.length());
@@ -453,6 +456,49 @@ namespace gourou
 	appendTextElem(activationToken, "adept:device", user->getDeviceUUID());
     }
 
+    void DRMProcessor::fetchLicenseServiceCertificate(const std::string& licenseURL,
+						      const std::string& operatorURL)
+    {
+	if (user->getLicenseServiceCertificate(licenseURL) != "")
+	    return;
+
+	std::string licenseServiceInfoReq = operatorURL + "/LicenseServiceInfo?licenseURL=" + licenseURL;
+	
+	ByteArray replyData;
+	replyData = sendRequest(licenseServiceInfoReq);
+
+	pugi::xml_document licenseServicesDoc;
+	licenseServicesDoc.load_buffer(replyData.data(), replyData.length());
+
+	// Add new license certificate
+	pugi::xml_document activationDoc;
+	user->readActivation(activationDoc);
+
+	pugi::xml_node root;
+	pugi::xpath_node xpathRes = activationDoc.select_node("//adept:licenseServices");
+
+	// Create adept:licenseServices if it doesn't exists
+	if (!xpathRes)
+	{
+	    xpathRes = activationDoc.select_node("/activationInfo");
+	    root = xpathRes.node();
+	    root = root.append_child("adept:licenseServices");
+	    root.append_attribute("xmlns:adept") = ADOBE_ADEPT_NS;
+	}
+	else
+	    root = xpathRes.node();
+
+	root = root.append_child("adept:licenseServiceInfo");
+
+	std::string certificate = extractTextElem(licenseServicesDoc,
+						  "/licenseServiceInfo/certificate");
+
+	appendTextElem(root, "adept:licenseURL", licenseURL);
+	appendTextElem(root, "adept:certificate", certificate);
+
+	user->updateActivationFile(activationDoc);
+    }
+    
     FulfillmentItem* DRMProcessor::fulfill(const std::string& ACSMFile)
     {
 	if (!user->getPKCS12().length())
@@ -495,15 +541,16 @@ namespace gourou
 	    EXCEPTION(FF_NO_OPERATOR_URL, "OperatorURL not found in ACSM document");
 	
 	std::string operatorURL = node.node().first_child().value();
-	operatorURL = trim(operatorURL) + "/Fulfill";
+	operatorURL = trim(operatorURL);
+	std::string fulfillURL = operatorURL + "/Fulfill";
 
-	operatorAuth(operatorURL);
+	operatorAuth(fulfillURL);
 	
 	ByteArray replyData;
 
 	try
 	{
-	    replyData = sendRequest(fulfillReq, operatorURL);
+	    replyData = sendRequest(fulfillReq, fulfillURL);
 	}
 	catch (gourou::Exception& e)
 	{
@@ -515,8 +562,8 @@ namespace gourou
 	    if (e.getErrorCode() == GOUROU_ADEPT_ERROR &&
 		errorMsg.find("E_ADEPT_DISTRIBUTOR_AUTH") != std::string::npos)
 	    {
-		doOperatorAuth(operatorURL);
-		replyData = sendRequest(fulfillReq, operatorURL);
+		doOperatorAuth(fulfillURL);
+		replyData = sendRequest(fulfillReq, fulfillURL);
 	    }
 	    else
 	    {
@@ -528,15 +575,23 @@ namespace gourou
 
 	fulfillReply.load_string((const char*)replyData.data());
 
+	std::string licenseURL = extractTextElem(fulfillReply, "//licenseToken/licenseURL");
+	
+	fetchLicenseServiceCertificate(licenseURL, operatorURL);
+
 	return new FulfillmentItem(fulfillReply, user);
     }
 
-    void DRMProcessor::download(FulfillmentItem* item, std::string path)
+    DRMProcessor::ITEM_TYPE DRMProcessor::download(FulfillmentItem* item, std::string path)
     {
+	ITEM_TYPE res = EPUB;
+	
 	if (!item)
 	    EXCEPTION(DW_NO_ITEM, "No item");
 
-	ByteArray replyData = sendRequest(item->getDownloadURL());
+	std::map<std::string, std::string> headers;
+	
+	ByteArray replyData = sendRequest(item->getDownloadURL(), "", 0, &headers);
 
 	writeFile(path, replyData);
 
@@ -544,9 +599,60 @@ namespace gourou
 
 	std::string rightsStr = item->getRights();
 
-	void* handler = client->zipOpen(path);
-	client->zipWriteFile(handler, "META-INF/rights.xml", rightsStr);
-	client->zipClose(handler);
+	if (headers.count("Content-Type") && headers["Content-Type"] == "application/pdf")
+	    res = PDF;
+
+	if (res == EPUB)
+	{
+	    void* handler = client->zipOpen(path);
+	    client->zipWriteFile(handler, "META-INF/rights.xml", rightsStr);
+	    client->zipClose(handler);
+	}
+	else if (res == PDF)
+	{
+	    uPDFParser::Parser parser;
+	    bool EBXHandlerFound = false;
+	    
+	    try
+	    {
+		GOUROU_LOG(DEBUG, "Parse PDF");
+		parser.parse(path);
+	    }
+	    catch(std::invalid_argument& e)
+	    {
+		GOUROU_LOG(ERROR, "Invalid PDF");
+		return res;
+	    }
+
+	    std::vector<uPDFParser::Object*> objects = parser.objects();
+	    std::vector<uPDFParser::Object*>::reverse_iterator it;
+
+	    for(it = objects.rbegin(); it != objects.rend(); it++)
+	    {
+		// Update EBX_HANDLER with rights
+		if ((*it)->hasKey("Filter") && (**it)["Filter"]->str() == "/EBX_HANDLER")
+		{
+		    EBXHandlerFound = true;
+		    uPDFParser::Object* ebx = (*it)->clone();
+		    (*ebx)["ADEPT_ID"] = new uPDFParser::String(item->getResource());
+		    (*ebx)["EBX_BOOKID"] = new uPDFParser::String(item->getResource());
+		    ByteArray zipped;
+		    client->deflate(rightsStr, zipped);
+		    (*ebx)["ADEPT_LICENSE"] = new uPDFParser::String(zipped.toBase64());
+		    parser.addObject(ebx);
+		    break;
+		}
+	    }
+
+	    if (EBXHandlerFound)
+		parser.write(path, true);
+	    else
+	    {
+		EXCEPTION(DW_NO_EBX_HANDLER, "EBX_HANDLER not found");
+	    }
+	}
+
+	return res;
     }
 
     void DRMProcessor::buildSignInRequest(pugi::xml_document& signInRequest,
@@ -800,6 +906,19 @@ namespace gourou
 	return res.toBase64();
     }
 
+    void DRMProcessor::exportPrivateLicenseKey(std::string path)
+    {
+	int fd = open(path.c_str(), O_CREAT|O_TRUNC|O_WRONLY, S_IRWXU);
+	if (fd <= 0)
+	    EXCEPTION(GOUROU_FILE_ERROR, "Unable to open " << path);
+
+	ByteArray privateLicenseKey = ByteArray::fromBase64(user->getPrivateLicenseKey());
+	/* In adobekey.py, we get base64 decoded data [26:] */
+	write(fd, privateLicenseKey.data()+26, privateLicenseKey.length()-26);
+	
+	close(fd);
+    }
+
     int DRMProcessor::getLogLevel() {return (int)gourou::logLevel;}
     void DRMProcessor::setLogLevel(int logLevel) {gourou::logLevel = (GOUROU_LOG_LEVEL)logLevel;}
 }

src/user.cpp

@@ -48,7 +48,6 @@ namespace gourou {
 	    uuid        = gourou::extractTextElem(activationDoc, "//adept:user", throwOnNull);
 	    deviceUUID  = gourou::extractTextElem(activationDoc, "//device", throwOnNull);
 	    deviceFingerprint = gourou::extractTextElem(activationDoc, "//fingerprint", throwOnNull);
-	    certificate = gourou::extractTextElem(activationDoc, "//adept:certificate", throwOnNull);
 	    authenticationCertificate = gourou::extractTextElem(activationDoc, "//adept:authenticationCertificate", throwOnNull);
 	    privateLicenseKey = gourou::extractTextElem(activationDoc, "//adept:privateLicenseKey", throwOnNull);
 	    username    = gourou::extractTextElem(activationDoc, "//adept:username", throwOnNull);
@@ -61,6 +60,15 @@ namespace gourou {
 		if (throwOnNull)
 		    EXCEPTION(USER_INVALID_ACTIVATION_FILE, "Invalid activation file");
 	    }
+
+	    pugi::xpath_node_set nodeSet = activationDoc.select_nodes("//adept:licenseServices/adept:licenseServiceInfo");
+	    for (pugi::xpath_node_set::const_iterator it = nodeSet.begin();
+		 it != nodeSet.end(); ++it)
+	    {
+		std::string url = gourou::extractTextElem(it->node(), "adept:licenseURL");
+		std::string certificate = gourou::extractTextElem(it->node(), "adept:certificate");
+		licenseServiceCertificates[url] = certificate;
+	    }
 	}
 	catch(gourou::Exception& e)
 	{
@@ -74,7 +82,6 @@ namespace gourou {
     std::string& User::getDeviceFingerprint() { return deviceFingerprint; }
     std::string& User::getUsername()          { return username; }
     std::string& User::getLoginMethod()       { return loginMethod; }
-    std::string& User::getCertificate()       { return certificate; }
     std::string& User::getAuthenticationCertificate() { return authenticationCertificate; }
     std::string& User::getPrivateLicenseKey() { return privateLicenseKey; }
     
@@ -200,4 +207,13 @@ namespace gourou {
 	
 	return user;
     }
+
+    std::string User::getLicenseServiceCertificate(std::string url)
+    {
+	if (licenseServiceCertificates.count(trim(url)))
+	    return licenseServiceCertificates[trim(url)];
+
+	return "";
+    }
+
 }

utils/Makefile

@@ -2,10 +2,11 @@
 TARGETS=acsmdownloader adept_activate
 
 CXXFLAGS=-Wall `pkg-config --cflags Qt5Core Qt5Network` -fPIC -I$(ROOT)/include -I$(ROOT)/lib/pugixml/src/
+LDFLAGS=`pkg-config --libs Qt5Core Qt5Network` -L$(ROOT) -lcrypto -lzip -lz
 ifneq ($(STATIC_UTILS),)
-LDFLAGS=`pkg-config --libs Qt5Core Qt5Network` -L$(ROOT) $(ROOT)/libgourou.a -lcrypto -lzip
+LDFLAGS += $(ROOT)/libgourou.a
 else
-LDFLAGS=`pkg-config --libs Qt5Core Qt5Network` -L$(ROOT) -lgourou -lcrypto -lzip
+LDFLAGS += -lgourou
 endif
 
 ifneq ($(DEBUG),)

utils/acsmdownloader.cpp

@@ -46,6 +46,7 @@ static const char* deviceFile     = "device.xml";
 static const char* activationFile = "activation.xml";
 static const char* devicekeyFile  = "devicesalt";
 static const char* acsmFile       = 0;
+static       bool  exportPrivateKey = false;
 static const char* outputFile     = 0;
 static const char* outputDir      = 0;
 static const char* defaultDirs[]  = {
@@ -71,32 +72,67 @@ public:
 	{
 	    DRMProcessorClientImpl client;
 	    gourou::DRMProcessor processor(&client, deviceFile, activationFile, devicekeyFile);
+	    gourou::User* user = processor.getUser();
 	    
-	    gourou::FulfillmentItem* item = processor.fulfill(acsmFile);
-
-	    std::string filename;
-	    if (!outputFile)
+	    if (exportPrivateKey)
 	    {
-		filename = item->getMetadata("title");
-		if (filename == "")
-		    filename = "output.epub";
+		std::string filename;
+		if (!outputFile)
+		    filename = std::string("Adobe_PrivateLicenseKey--") + user->getUsername() + ".der";
 		else
-		    filename += ".epub";
+		    filename = outputFile;
+	    
+		if (outputDir)
+		{
+		    QDir dir(outputDir);
+		    if (!dir.exists(outputDir))
+			dir.mkpath(outputDir);
+		    
+		    filename = std::string(outputDir) + "/" + filename;
+		}
+
+		processor.exportPrivateLicenseKey(filename);
+
+		std::cout << "Private license key exported to " << filename << std::endl;
 	    }
 	    else
-		filename = outputFile;
-	    
-	    if (outputDir)
 	    {
-		QDir dir(outputDir);
-		if (!dir.exists(outputDir))
-		    dir.mkpath(outputDir);
+		gourou::FulfillmentItem* item = processor.fulfill(acsmFile);
 
-		filename = std::string(outputDir) + "/" + filename;
+		std::string filename;
+		if (!outputFile)
+		{
+		    filename = item->getMetadata("title");
+		    if (filename == "")
+			filename = "output";
+		}
+		else
+		    filename = outputFile;
+	    
+		if (outputDir)
+		{
+		    QDir dir(outputDir);
+		    if (!dir.exists(outputDir))
+			dir.mkpath(outputDir);
+
+		    filename = std::string(outputDir) + "/" + filename;
+		}
+	    
+		gourou::DRMProcessor::ITEM_TYPE type = processor.download(item, filename);
+
+		if (!outputFile)
+		{
+		    std::string finalName = filename;
+		    if (type == gourou::DRMProcessor::ITEM_TYPE::PDF)
+			finalName += ".pdf";
+		    else
+			finalName += ".epub";
+		    QDir dir;
+		    dir.rename(filename.c_str(), finalName.c_str());
+		    filename = finalName;
+		}
+		std::cout << "Created " << filename << std::endl;
 	    }
-	    
-	    processor.download(item, filename);
-	    std::cout << "Created " << filename << std::endl;
 	} catch(std::exception& e)
 	{
 	    std::cout << e.what() << std::endl;
@@ -139,14 +175,15 @@ static void usage(const char* cmd)
 {
     std::cout << "Download EPUB file from ACSM request file" << std::endl;
     
-    std::cout << "Usage: " << cmd << " [(-d|--device-file) device.xml] [(-a|--activation-file) activation.xml] [(-s|--device-key-file) devicesalt] [(-O|--output-dir) dir] [(-o|--output-file) output.epub] [(-v|--verbose)] [(-h|--help)] (-f|--acsm-file) file.acsm" << std::endl << std::endl;
+    std::cout << "Usage: " << cmd << " [(-d|--device-file) device.xml] [(-a|--activation-file) activation.xml] [(-k|--device-key-file) devicesalt] [(-O|--output-dir) dir] [(-o|--output-file) output(.epub|.pdf|.der)] [(-v|--verbose)] [(-h|--help)] (-f|--acsm-file) file.acsm|(-e|--export-private-key)" << std::endl << std::endl;
     
     std::cout << "  " << "-d|--device-file"     << "\t"   << "device.xml file from eReader" << std::endl;
     std::cout << "  " << "-a|--activation-file" << "\t"   << "activation.xml file from eReader" << std::endl;
     std::cout << "  " << "-k|--device-key-file" << "\t"   << "private device key file (eg devicesalt/devkey.bin) from eReader" << std::endl;
     std::cout << "  " << "-O|--output-dir"      << "\t"   << "Optional output directory were to put result (default ./)" << std::endl;
-    std::cout << "  " << "-o|--output-file"     << "\t"   << "Optional output epub filename (default <title.epub>)" << std::endl;
+    std::cout << "  " << "-o|--output-file"     << "\t"   << "Optional output filename (default <title.(epub|pdf|der)>)" << std::endl;
     std::cout << "  " << "-f|--acsm-file"       << "\t"   << "ACSM request file for epub download" << std::endl;
+    std::cout << "  " << "-e|--export-private-key"<< "\t" << "Export private key in DER format" << std::endl;
     std::cout << "  " << "-v|--verbose"         << "\t\t" << "Increase verbosity, can be set multiple times" << std::endl;
     std::cout << "  " << "-V|--version"         << "\t\t" << "Display libgourou version" << std::endl;
     std::cout << "  " << "-h|--help"            << "\t\t" << "This help" << std::endl;
@@ -175,13 +212,14 @@ int main(int argc, char** argv)
 	    {"output-dir",       required_argument, 0,  'O' },
 	    {"output-file",      required_argument, 0,  'o' },
 	    {"acsm-file",        required_argument, 0,  'f' },
+	    {"export-private-key",no_argument,      0,  'e' },
 	    {"verbose",          no_argument,       0,  'v' },
 	    {"version",          no_argument,       0,  'V' },
 	    {"help",             no_argument,       0,  'h' },
 	    {0,                  0,                 0,  0 }
 	};
 
-	c = getopt_long(argc, argv, "d:a:k:O:o:f:vVh",
+	c = getopt_long(argc, argv, "d:a:k:O:o:f:evVh",
                         long_options, &option_index);
 	if (c == -1)
 	    break;
@@ -205,6 +243,9 @@ int main(int argc, char** argv)
 	case 'o':
 	    outputFile = optarg;
 	    break;
+	case 'e':
+	    exportPrivateKey = true;
+	    break;
 	case 'v':
 	    verbose++;
 	    break;
@@ -222,7 +263,7 @@ int main(int argc, char** argv)
    
     gourou::DRMProcessor::setLogLevel(verbose);
 
-    if (!acsmFile || (outputDir && !outputDir[0]) ||
+    if ((!acsmFile && !exportPrivateKey) || (outputDir && !outputDir[0]) ||
 	(outputFile && !outputFile[0]))
     {
 	usage(argv[0]);
@@ -233,23 +274,40 @@ int main(int argc, char** argv)
     ACSMDownloader downloader(&app);
 
     int i;
+    bool hasErrors = false;
+    const char* orig;
     for (i=0; i<(int)ARRAY_SIZE(files); i++)
     {
+	orig = *files[i];
 	*files[i] = findFile(*files[i]);
 	if (!*files[i])
 	{
-	    std::cout << "Error : " << *files[i] << " doesn't exists" << std::endl;
+	    std::cout << "Error : " << orig << " doesn't exists, did you activate your device ?" << std::endl;
 	    ret = -1;
-	    goto end;
+	    hasErrors = true;
 	}
     }
 
-    QFile file(acsmFile);
-    if (!file.exists())
-    {
-	std::cout << "Error : " << acsmFile << " doesn't exists" << std::endl;
-	ret = -1;
+    if (hasErrors)
 	goto end;
+    
+    if (exportPrivateKey)
+    {
+	if (acsmFile)
+	{
+	    usage(argv[0]);
+	    return -1;
+	}
+    }
+    else
+    {
+	QFile file(acsmFile);
+	if (!file.exists())
+	{
+	    std::cout << "Error : " << acsmFile << " doesn't exists" << std::endl;
+	    ret = -1;
+	    goto end;
+	}
     }
     
     QThreadPool::globalInstance()->start(&downloader);

utils/drmprocessorclientimpl.cpp

@@ -38,6 +38,7 @@
 #include <QFile>
 
 #include <zip.h>
+#include <zlib.h>
 
 #include <libgourou_common.h>
 #include <libgourou_log.h>
@@ -82,7 +83,7 @@ void DRMProcessorClientImpl::randBytes(unsigned char* bytesOut, unsigned int len
 }
 
 /* HTTP interface */
-std::string DRMProcessorClientImpl::sendHTTPRequest(const std::string& URL, const std::string& POSTData, const std::string& contentType)
+std::string DRMProcessorClientImpl::sendHTTPRequest(const std::string& URL, const std::string& POSTData, const std::string& contentType, std::map<std::string, std::string>* responseHeaders)
 {
     QNetworkRequest request(QUrl(URL.c_str()));
     QNetworkAccessManager networkManager;
@@ -121,12 +122,12 @@ std::string DRMProcessorClientImpl::sendHTTPRequest(const std::string& URL, cons
     if (reply->error() != QNetworkReply::NoError)
 	EXCEPTION(gourou::CLIENT_NETWORK_ERROR, "Error " << reply->errorString().toStdString());
 
-    if (gourou::logLevel >= gourou::DEBUG)
-    {
-	QList<QByteArray> headers = reply->rawHeaderList();
-	for (int i = 0; i < headers.size(); ++i) {
+    QList<QByteArray> headers = reply->rawHeaderList();
+    for (int i = 0; i < headers.size(); ++i) {
+	if (gourou::logLevel >= gourou::DEBUG)
 	    std::cout << headers[i].constData() << " : "  << reply->rawHeader(headers[i]).constData() << std::endl;
-	}
+	if (responseHeaders)
+	    (*responseHeaders)[headers[i].constData()] = reply->rawHeader(headers[i]).constData();
     }
     
     replyData = reply->readAll();
@@ -420,3 +421,78 @@ void DRMProcessorClientImpl::zipClose(void* handler)
 {
     zip_close((zip_t*)handler);
 }
+
+void DRMProcessorClientImpl::inflate(std::string data, gourou::ByteArray& result,
+				     int wbits)
+{
+    unsigned int dataSize = data.size()*2;
+    unsigned char* buffer = new unsigned char[dataSize];
+    
+    z_stream infstream;
+
+    infstream.zalloc = Z_NULL;
+    infstream.zfree  = Z_NULL;
+    infstream.opaque = Z_NULL;
+
+    infstream.avail_in  = (uInt)data.size();
+    infstream.next_in   = (Bytef *)data.c_str(); // input char array
+    infstream.avail_out = (uInt)dataSize; // size of output
+    infstream.next_out  = (Bytef *)buffer; // output char array
+
+    int ret = inflateInit2(&infstream, wbits);
+
+    ret = ::inflate(&infstream, Z_SYNC_FLUSH);
+    while (ret == Z_OK || ret == Z_STREAM_END)
+    {
+	result.append(buffer, dataSize-infstream.avail_out);
+	if (ret == Z_STREAM_END) break;
+	infstream.avail_out = (uInt)dataSize; // size of output
+	infstream.next_out = (Bytef *)buffer; // output char array
+	ret = ::inflate(&infstream, Z_SYNC_FLUSH);
+    }
+
+    inflateEnd(&infstream);
+
+    delete[] buffer;
+
+    if (ret != Z_OK && ret != Z_STREAM_END && ret != Z_BUF_ERROR)
+	EXCEPTION(gourou::CLIENT_ZIP_ERROR, zError(ret));
+}
+	
+void DRMProcessorClientImpl::deflate(std::string data, gourou::ByteArray& result,
+			     int wbits, int compressionLevel)
+{
+    unsigned int dataSize = data.size();
+    unsigned char* buffer = new unsigned char[dataSize];
+    
+    z_stream defstream;
+
+    defstream.zalloc = Z_NULL;
+    defstream.zfree  = Z_NULL;
+    defstream.opaque = Z_NULL;
+
+    defstream.avail_in  = (uInt)data.size();
+    defstream.next_in   = (Bytef *)data.c_str(); // input char array
+    defstream.avail_out = (uInt)dataSize; // size of output
+    defstream.next_out  = (Bytef *)buffer; // output char array
+
+    int ret = deflateInit2(&defstream, Z_DEFAULT_COMPRESSION, Z_DEFLATED, wbits,
+			   compressionLevel, Z_DEFAULT_STRATEGY);
+
+    ret = ::deflate(&defstream, Z_SYNC_FLUSH);
+    while (ret == Z_OK || ret == Z_STREAM_END)
+    {
+	result.append(buffer, dataSize-defstream.avail_out);
+	if (ret == Z_STREAM_END) break;
+	defstream.avail_out = (uInt)dataSize; // size of output
+	defstream.next_out = (Bytef *)buffer; // output char array
+	ret = ::deflate(&defstream, Z_SYNC_FLUSH);
+    }
+   
+    deflateEnd(&defstream);
+
+    delete[] buffer;
+
+    if (ret != Z_OK && ret != Z_STREAM_END && ret != Z_BUF_ERROR)
+	EXCEPTION(gourou::CLIENT_ZIP_ERROR, zError(ret));
+}

utils/drmprocessorclientimpl.h

@@ -46,7 +46,7 @@ class DRMProcessorClientImpl : public gourou::DRMProcessorClient
     virtual void randBytes(unsigned char* bytesOut, unsigned int length);
 
     /* HTTP interface */
-    virtual std::string sendHTTPRequest(const std::string& URL, const std::string& POSTData=std::string(""), const std::string& contentType=std::string(""));
+    virtual std::string sendHTTPRequest(const std::string& URL, const std::string& POSTData=std::string(""), const std::string& contentType=std::string(""), std::map<std::string, std::string>* responseHeaders=0);
 
     virtual void RSAPrivateEncrypt(const unsigned char* RSAKey, unsigned int RSAKeyLength,
 				   const RSA_KEY_TYPE keyType, const std::string& password,
@@ -108,6 +108,10 @@ class DRMProcessorClientImpl : public gourou::DRMProcessorClient
     
     virtual void zipClose(void* handler);
     
+    virtual void inflate(std::string data, gourou::ByteArray& result, int wbits=-15);
+	
+    virtual void deflate(std::string data, gourou::ByteArray& result,
+			 int wbits=-15, int compressionLevel=8);
 };
 
 #endif