Compute over encrypted key also for PDF files

Patch from Nguyễn Gia Phong

.gitignore

@@ -1,9 +1,11 @@
 obj
 lib
+*.o
 *.a
 *.so
 *~
 utils/acsmdownloader
 utils/adept_activate
 utils/adept_remove
-.adept
+utils/adept_loan_mgt
+.adept*

Makefile

@@ -1,10 +1,9 @@
-
 AR ?= $(CROSS)ar
 CXX ?= $(CROSS)g++
 
 UPDFPARSERLIB = ./lib/updfparser/libupdfparser.a
 
-CXXFLAGS=-Wall -fPIC -I./include -I./lib -I./lib/pugixml/src/ -I./lib/updfparser/include
+CXXFLAGS=-Wall -fPIC -I./include -I./lib/pugixml/src/ -I./lib/updfparser/include
 LDFLAGS = $(UPDFPARSERLIB)
 
 BUILD_STATIC ?= 0
@@ -24,11 +23,15 @@ endif
 
 
 ifneq ($(DEBUG),)
-CXXFLAGS += -ggdb -O0
+CXXFLAGS += -ggdb -O0 -DDEBUG
 else
 CXXFLAGS += -O2
 endif
 
+ifneq ($(STATIC_NONCE),)
+CXXFLAGS += -DSTATIC_NONCE=1
+endif
+
 SRCDIR      := src
 INCDIR      := inc
 BUILDDIR    := obj
@@ -36,7 +39,7 @@ 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/loan_token.cpp src/bytearray.cpp src/pugixml.cpp
 OBJECTS     := $(patsubst $(SRCDIR)/%,$(BUILDDIR)/%,$(SOURCES:.$(SRCEXT)=.$(OBJEXT)))
 
 all: lib obj $(TARGETS)
@@ -45,6 +48,9 @@ lib:
 	mkdir lib
 	./scripts/setup.sh
 
+update_lib:
+	./scripts/update_lib.sh
+
 obj:
 	mkdir obj
 

README.md

@@ -16,7 +16,7 @@ Main fucntions to use from gourou::DRMProcessor are :
   * Create a new device : _createDRMProcessor()_
   * Register a new device : _signIn()_ and _activateDevice()_
   * Remove DRM : _removeDRM()_
-
+  * Return loaned book : _returnLoan()_
 
 You can import configuration from (at least) :
 
@@ -35,22 +35,35 @@ Dependencies
 
 For libgourou :
 
+_externals_ :
+
   * None
 
+_internals_ :
+
+  * PugiXML
+  * Base64
+  * uPDFParser
+
 For utils :
 
-  * QT5Core
-  * QT5Network
+  * libcurl
   * OpenSSL
   * libzip
 
 
+Internal libraries are automatically fetched and statically compiled during the first run.
+When you update libgourou's repository, **don't forget to update internal libraries** with :
+
+    make update_lib
+
+
 Compilation
 -----------
 
 Use _make_ command
 
-    make [CROSS=XXX] [DEBUG=(0*|1)] [STATIC_UTILS=(0*|1)] [BUILD_UTILS=(0|1*)] [BUILD_STATIC=(0*|1)] [BUILD_SHARED=(0|1*)]
+    make [CROSS=XXX] [DEBUG=(0*|1)] [STATIC_UTILS=(0*|1)] [BUILD_UTILS=(0|1*)] [BUILD_STATIC=(0*|1)] [BUILD_SHARED=(0|1*)] [all*|clean|ultraclean|build_utils]
 
 CROSS can define a cross compiler prefix (ie arm-linux-gnueabihf-)
 
@@ -92,9 +105,24 @@ To remove ADEPT DRM :
     export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$PWD
     ./utils/adept_remove -f <encryptedFile>
 
+To list loaned books :
+
+    export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$PWD
+    ./utils/adept_loan_mgt [-l]
+
+To return a loaned book :
+
+    export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$PWD
+    ./utils/adept_loan_mgt -r <id>
+
 You can get utils full options description with -h or --help switch
 
 
+Docker
+------
+
+A docker image (by bcliang) is available at [https://github.com/bcliang/docker-libgourou/](https://github.com/bcliang/docker-libgourou/)
+
 
 Copyright
 ---------
@@ -102,7 +130,6 @@ Copyright
 Grégory Soutadé
 
 
-
 License
 -------
 
@@ -111,7 +138,6 @@ libgourou : LGPL v3 or later
 utils     : BSD
 
 
-
 Special thanks
 --------------
 

include/Base64.h

@@ -0,0 +1,124 @@
+#ifndef _MACARON_BASE64_H_
+#define _MACARON_BASE64_H_
+
+/**
+ * The MIT License (MIT)
+ * Copyright (c) 2016 tomykaira
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <string>
+
+namespace macaron {
+
+class Base64 {
+ public:
+
+  static std::string Encode(const std::string data) {
+    static constexpr char sEncodingTable[] = {
+      'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
+      'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
+      'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
+      'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
+      'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
+      'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
+      'w', 'x', 'y', 'z', '0', '1', '2', '3',
+      '4', '5', '6', '7', '8', '9', '+', '/'
+    };
+
+    size_t in_len = data.size();
+    size_t out_len = 4 * ((in_len + 2) / 3);
+    std::string ret(out_len, '\0');
+    size_t i;
+    char *p = const_cast<char*>(ret.c_str());
+
+    for (i = 0; i < in_len - 2; i += 3) {
+      *p++ = sEncodingTable[(data[i] >> 2) & 0x3F];
+      *p++ = sEncodingTable[((data[i] & 0x3) << 4) | ((int) (data[i + 1] & 0xF0) >> 4)];
+      *p++ = sEncodingTable[((data[i + 1] & 0xF) << 2) | ((int) (data[i + 2] & 0xC0) >> 6)];
+      *p++ = sEncodingTable[data[i + 2] & 0x3F];
+    }
+    if (i < in_len) {
+      *p++ = sEncodingTable[(data[i] >> 2) & 0x3F];
+      if (i == (in_len - 1)) {
+        *p++ = sEncodingTable[((data[i] & 0x3) << 4)];
+        *p++ = '=';
+      }
+      else {
+        *p++ = sEncodingTable[((data[i] & 0x3) << 4) | ((int) (data[i + 1] & 0xF0) >> 4)];
+        *p++ = sEncodingTable[((data[i + 1] & 0xF) << 2)];
+      }
+      *p++ = '=';
+    }
+
+    return ret;
+  }
+
+  static std::string Decode(const std::string& input, std::string& out) {
+    static constexpr unsigned char kDecodingTable[] = {
+      64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+      64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+      64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 62, 64, 64, 64, 63,
+      52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 64, 64, 64, 64, 64, 64,
+      64,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
+      15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 64, 64, 64, 64, 64,
+      64, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+      41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 64, 64, 64, 64, 64,
+      64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+      64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+      64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+      64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+      64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+      64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+      64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
+      64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64
+    };
+
+    size_t in_len = input.size();
+    if (in_len % 4 != 0) return "Input data size is not a multiple of 4";
+
+    size_t out_len = in_len / 4 * 3;
+    if (input[in_len - 1] == '=') out_len--;
+    if (input[in_len - 2] == '=') out_len--;
+
+    out.resize(out_len);
+
+    for (size_t i = 0, j = 0; i < in_len;) {
+      uint32_t a = input[i] == '=' ? 0 & i++ : kDecodingTable[static_cast<int>(input[i++])];
+      uint32_t b = input[i] == '=' ? 0 & i++ : kDecodingTable[static_cast<int>(input[i++])];
+      uint32_t c = input[i] == '=' ? 0 & i++ : kDecodingTable[static_cast<int>(input[i++])];
+      uint32_t d = input[i] == '=' ? 0 & i++ : kDecodingTable[static_cast<int>(input[i++])];
+
+      uint32_t triple = (a << 3 * 6) + (b << 2 * 6) + (c << 1 * 6) + (d << 0 * 6);
+
+      if (j < out_len) out[j++] = (triple >> 2 * 8) & 0xFF;
+      if (j < out_len) out[j++] = (triple >> 1 * 8) & 0xFF;
+      if (j < out_len) out[j++] = (triple >> 0 * 8) & 0xFF;
+    }
+
+    return "";
+  }
+
+};
+
+}
+
+#endif /* _MACARON_BASE64_H_ */

include/bytearray.h

@@ -104,6 +104,13 @@ namespace gourou
 	 */
 	std::string toBase64();
 
+	/**
+	 * @brief Convert hex string into bytes
+	 *
+	 * @param str     Hex string
+	 */
+	static ByteArray fromHex(const std::string& str);
+
 	/**
 	 * @brief Return a string with human readable hex encoded internal data
 	 */
@@ -130,7 +137,7 @@ namespace gourou
 	void append(const std::string& str);
 
 	/**
-	 * @brief Get internal data. Must bot be freed
+	 * @brief Get internal data. Must not be freed
 	 */
 	unsigned char* data() {return _data;}
 

include/drmprocessorclient.h

@@ -47,20 +47,16 @@ namespace gourou
 	 * @param handler         Digest handler
 	 * @param data            Data to digest
 	 * @param length          Length of data
-	 *
-	 * @return OK/KO
 	 */
-	virtual int digestUpdate(void* handler, unsigned char* data, unsigned int length) = 0;
+	virtual void digestUpdate(void* handler, unsigned char* data, unsigned int length) = 0;
 
 	/**
 	 * @brief Finalize digest with remained buffered data and destroy handler
 	 *
 	 * @param handler         Digest handler
 	 * @param digestOut       Digest result (buffer must be pre allocated with right size)
-	 *
-	 * @return OK/KO
 	 */
-	virtual int digestFinalize(void* handler, unsigned char* digestOut) = 0;
+	virtual void digestFinalize(void* handler, unsigned char* digestOut) = 0;
 
 	/**
 	 * @brief Global digest function
@@ -69,10 +65,8 @@ namespace gourou
 	 * @param data            Data to digest
 	 * @param length          Length of data
 	 * @param digestOut       Digest result (buffer must be pre allocated with right size)
-	 *
-	 * @return OK/KO
 	 */
-	virtual int digest(const std::string& digestName, unsigned char* data, unsigned int length, unsigned char* digestOut) = 0;
+	virtual void digest(const std::string& digestName, unsigned char* data, unsigned int length, unsigned char* digestOut) = 0;
     };
 
     class RandomInterface
@@ -98,10 +92,12 @@ namespace gourou
 	 * @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
+	 * @param fd              Optional file descriptor to write request result
+	 * @param resume          false if target file should be truncated, true to try resume download (works only in combination with a valid fd)
 	 *
 	 * @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(""), std::map<std::string, std::string>* responseHeaders=0) = 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, int fd=0, bool resume=false) = 0;
     };
 
     class RSAInterface
@@ -109,6 +105,7 @@ namespace gourou
     public:
 	enum RSA_KEY_TYPE {
 	    RSA_KEY_PKCS12 = 0,
+	    RSA_KEY_PKCS8,
 	    RSA_KEY_X509
 	};
 
@@ -236,7 +233,7 @@ namespace gourou
 	 * @param dataOut        Encrypted data
 	 * @param dataOutLength  Length of encrypted data
 	 */
-	virtual void Encrypt(CRYPTO_ALGO algo, CHAINING_MODE chaining,
+	virtual void encrypt(CRYPTO_ALGO algo, CHAINING_MODE chaining,
 			     const unsigned char* key, unsigned int keyLength,
 			     const unsigned char* iv, unsigned int ivLength,
 			     const unsigned char* dataIn, unsigned int dataInLength,
@@ -253,7 +250,7 @@ namespace gourou
 	 *
 	 * @return AES handler
 	 */
-	virtual void* EncryptInit(CRYPTO_ALGO algo, CHAINING_MODE chaining,
+	virtual void* encryptInit(CRYPTO_ALGO algo, CHAINING_MODE chaining,
 				  const unsigned char* key, unsigned int keyLength,
 				  const unsigned char* iv=0, unsigned int ivLength=0) = 0;
 
@@ -266,7 +263,7 @@ namespace gourou
 	 * @param dataOut        Encrypted data
 	 * @param dataOutLength  Length of encrypted data
 	 */
-	virtual void EncryptUpdate(void* handler, const unsigned char* dataIn, unsigned int dataInLength,
+	virtual void encryptUpdate(void* handler, const unsigned char* dataIn, unsigned int dataInLength,
 				   unsigned char* dataOut, unsigned int* dataOutLength) = 0;
 
 	/**
@@ -277,7 +274,7 @@ namespace gourou
 	 * @param dataOut        Last block of encrypted data
 	 * @param dataOutLength  Length of encrypted data
 	 */
-	virtual void EncryptFinalize(void* handler, unsigned char* dataOut, unsigned int* dataOutLength) = 0;
+	virtual void encryptFinalize(void* handler, unsigned char* dataOut, unsigned int* dataOutLength) = 0;
 
 	/**
 	 * @brief Do decryption. If length of data is not multiple of block size, PKCS#5 padding is done
@@ -293,7 +290,7 @@ namespace gourou
 	 * @param dataOut        Encrypted data
 	 * @param dataOutLength  Length of encrypted data
 	 */
-	virtual void Decrypt(CRYPTO_ALGO algo, CHAINING_MODE chaining,
+	virtual void decrypt(CRYPTO_ALGO algo, CHAINING_MODE chaining,
 			     const unsigned char* key, unsigned int keyLength,
 			     const unsigned char* iv, unsigned int ivLength,
 			     const unsigned char* dataIn, unsigned int dataInLength,
@@ -310,7 +307,7 @@ namespace gourou
 	 *
 	 * @return AES handler
 	 */
-	virtual void* DecryptInit(CRYPTO_ALGO algo, CHAINING_MODE chaining,
+	virtual void* decryptInit(CRYPTO_ALGO algo, CHAINING_MODE chaining,
 				  const unsigned char* key, unsigned int keyLength,
 				  const unsigned char* iv=0, unsigned int ivLength=0) = 0;
 
@@ -323,7 +320,7 @@ namespace gourou
 	 * @param dataOut        Decrypted data
 	 * @param dataOutLength  Length of decrypted data
 	 */
-	virtual void DecryptUpdate(void* handler, const unsigned char* dataIn, unsigned int dataInLength,
+	virtual void decryptUpdate(void* handler, const unsigned char* dataIn, unsigned int dataInLength,
 				   unsigned char* dataOut, unsigned int* dataOutLength) = 0;
 	/**
 	 * @brief Finalize decryption (decrypt last block and remove padding if it is set).
@@ -333,7 +330,7 @@ namespace gourou
 	 * @param dataOut        Last block decrypted data
 	 * @param dataOutLength  Length of decrypted data
 	 */
-	virtual void DecryptFinalize(void* handler, unsigned char* dataOut, unsigned int* dataOutLength) = 0;
+	virtual void decryptFinalize(void* handler, unsigned char* dataOut, unsigned int* dataOutLength) = 0;
     };
 
 

include/fulfillment_item.h

@@ -20,7 +20,7 @@
 #ifndef _FULFILLMENT_ITEM_H_
 #define _FULFILLMENT_ITEM_H_
 
-#include "bytearray.h"
+#include "loan_token.h"
 
 #include <pugixml.hpp>
 
@@ -42,6 +42,8 @@ namespace gourou
 	 */
 	FulfillmentItem(pugi::xml_document& doc, User* user);
 
+	~FulfillmentItem();
+
 	/**
 	 * @brief Return metadata value from ACSM metadata section
 	 *
@@ -64,12 +66,18 @@ namespace gourou
 	 */
 	std::string getResource();
 
+	/**
+	 * @brief Return loan token if there is one
+	 */
+	LoanToken* getLoanToken();
+
     private:
 	pugi::xml_document fulfillDoc;
 	pugi::xml_node metadatas;
 	pugi::xml_document rights;
 	std::string downloadURL;
 	std::string resource;
+	LoanToken* loanToken;
 	
 	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.5.3"
+#define LIBGOUROU_VERSION       "0.8"
 
 namespace gourou
 {
@@ -81,10 +81,11 @@ namespace gourou
 	 *
 	 * @param item            Item from fulfill() method
 	 * @param path            Output file path 
+	 * @param resume          false if target file should be truncated, true to try resume download
 	 *
 	 * @return Type of downloaded item
 	 */
-	ITEM_TYPE download(FulfillmentItem* item, std::string path);
+	ITEM_TYPE download(FulfillmentItem* item, std::string path, bool resume=false);
 
 	/**
 	 * @brief SignIn into ACS Server (required to activate device)
@@ -99,6 +100,14 @@ namespace gourou
 	 */
 	void activateDevice();
 
+	/**
+	 * @brief Return loaned book to server
+	 *
+	 * @param loanID          Loan ID received during fulfill
+	 * @param operatorURL     URL of operator that loans this book
+	 */
+	void returnLoan(const std::string& loanID, const std::string& operatorURL);
+	
 	/**
 	 * @brief Create a new ADEPT environment (device.xml, devicesalt and activation.xml).
 	 *
@@ -134,10 +143,12 @@ namespace gourou
 	 * @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
+	 * @param fd              Optional File descriptor to write received data
+	 * @param resume          false if target file should be truncated, true to try resume download (works only in combination of a valid fd)
 	 *
 	 * @return data of HTTP response
 	 */
-	ByteArray sendRequest(const std::string& URL, const std::string& POSTData=std::string(), const char* contentType=0, std::map<std::string, std::string>* responseHeaders=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, int fd=0, bool resume=false);
 
 	/**
 	 * @brief Send HTTP POST request to URL with document as POSTData
@@ -207,7 +218,7 @@ namespace gourou
 	void pushTag(void* sha_ctx, uint8_t tag);
 	void hashNode(const pugi::xml_node& root, void *sha_ctx, std::map<std::string,std::string> nsHash);
 	void hashNode(const pugi::xml_node& root, unsigned char* sha_out);
-	std::string signNode(const pugi::xml_node& rootNode);
+	void signNode(pugi::xml_node& rootNode);
 	void addNonce(pugi::xml_node& root);
 	void buildAuthRequest(pugi::xml_document& authReq);
 	void buildInitLicenseServiceRequest(pugi::xml_document& initLicReq, std::string operatorURL);
@@ -215,10 +226,12 @@ namespace gourou
 	void operatorAuth(std::string operatorURL);
 	void buildFulfillRequest(pugi::xml_document& acsmDoc, pugi::xml_document& fulfillReq);
 	void buildActivateReq(pugi::xml_document& activateReq);
+	void buildReturnReq(pugi::xml_document& returnReq, const std::string& loanID, const std::string& operatorURL);
 	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);
+	std::string encryptedKeyFirstPass(pugi::xml_document& rightsDoc, const std::string& encryptedKey, const std::string& keyType, ITEM_TYPE type);
 	void decryptADEPTKey(const std::string& encryptedKey, unsigned char* decryptedKey);
 	void removeEPubDRM(const std::string& filenameIn, const std::string& filenameOut, const unsigned char* encryptionKey, unsigned encryptionKeySize);
 	void generatePDFObjectKey(int version,

include/libgourou_common.h

@@ -55,7 +55,8 @@ namespace gourou
 	GOUROU_INVALID_CLIENT,
 	GOUROU_TAG_NOT_FOUND,
 	GOUROU_ADEPT_ERROR,
-	GOUROU_FILE_ERROR
+	GOUROU_FILE_ERROR,
+	GOUROU_INVALID_PROPERTY
     };
 
     enum FULFILL_ERROR {
@@ -96,7 +97,8 @@ namespace gourou
     };
 
     enum FULFILL_ITEM_ERROR {
-	FFI_INVALID_FULFILLMENT_DATA = 0x4000
+	FFI_INVALID_FULFILLMENT_DATA = 0x4000,
+	FFI_INVALID_LOAN_TOKEN
     };
     
     enum CLIENT_ERROR {
@@ -104,6 +106,7 @@ namespace gourou
 	CLIENT_INVALID_PKCS12,
 	CLIENT_INVALID_CERTIFICATE,
 	CLIENT_NO_PRIV_KEY,
+	CLIENT_NO_PUB_KEY,
 	CLIENT_RSA_ERROR,
 	CLIENT_BAD_CHAINING,
 	CLIENT_BAD_KEY_SIZE,
@@ -111,7 +114,11 @@ namespace gourou
 	CLIENT_ZIP_ERROR,
 	CLIENT_GENERIC_EXCEPTION,
 	CLIENT_NETWORK_ERROR,
-	CLIENT_INVALID_PKCS8
+	CLIENT_INVALID_PKCS8,
+	CLIENT_FILE_ERROR,
+	CLIENT_OSSL_ERROR,
+	CLIENT_CRYPT_ERROR,
+	CLIENT_DIGEST_ERROR,
     };
 
     enum DRM_REMOVAL_ERROR {
@@ -121,7 +128,8 @@ namespace gourou
 	DRM_FORMAT_NOT_SUPPORTED,
 	DRM_IN_OUT_EQUALS,
 	DRM_MISSING_PARAMETER,
-	DRM_INVALID_KEY_SIZE
+	DRM_INVALID_KEY_SIZE,
+	DRM_ERR_ENCRYPTION_KEY_FP
     };
 
     /**
@@ -136,7 +144,7 @@ namespace gourou
 	    std::stringstream msg;
 	    msg << "Exception code : 0x" << std::setbase(16) << code << std::endl;
 	    msg << "Message        : " << message << std::endl;
-	    if (logLevel >= DEBUG)
+	    if (logLevel >= LG_LOG_DEBUG)
 		msg << "File           : " << file << ":" << std::setbase(10) << line << std::endl;
 	    fullmessage = strdup(msg.str().c_str());
 	}
@@ -220,9 +228,9 @@ namespace gourou
      * It can throw an exception if tag does not exists
      * or just return an empty value
      */
-    static inline std::string extractTextElem(const pugi::xml_document& doc, const char* tagName, bool throwOnNull=true)
+    static inline std::string extractTextElem(const pugi::xml_node& root, const char* tagName, bool throwOnNull=true)
     {
-        pugi::xpath_node xpath_node = doc.select_node(tagName);
+        pugi::xpath_node xpath_node = root.select_node(tagName);
 
         if (!xpath_node)
 	{
@@ -246,9 +254,14 @@ namespace gourou
         return trim(res);
     }
 
-    static inline std::string extractTextElem(const pugi::xml_node& doc, const char* tagName, bool throwOnNull=true)
+    /**
+     * @brief Extract text attribute from tag in document
+     * It can throw an exception if attribute does not exists
+     * or just return an empty value
+     */
+    static inline std::string extractTextAttribute(const pugi::xml_node& root, const char* tagName, const char* attributeName, bool throwOnNull=true)
     {
-        pugi::xpath_node xpath_node = doc.select_node(tagName);
+        pugi::xpath_node xpath_node = root.select_node(tagName);
 
         if (!xpath_node)
 	{
@@ -258,17 +271,17 @@ namespace gourou
             return "";
 	}
 
-	pugi::xml_node node = xpath_node.node().first_child();
+	pugi::xml_attribute attr = xpath_node.node().attribute(attributeName);
 
-	if (!node)
+	if (!attr)
 	{
 	    if (throwOnNull)
-		EXCEPTION(GOUROU_TAG_NOT_FOUND, "Text element for tag " << tagName << " not found");
+		EXCEPTION(GOUROU_TAG_NOT_FOUND, "Attribute element " << attributeName << " for tag " << tagName << " not found");
 	    
             return "";
 	}
 
-	std::string res = node.value();
+	std::string res = attr.value();
 	return trim(res);
     }
 
@@ -285,15 +298,56 @@ namespace gourou
 	node.append_child(pugi::node_pcdata).set_value(value.c_str());
     }
 
+    /**
+     * Remove "urn:uuid:" prefix and all '-' from uuid
+     * urn:uuid:9cb786e8-586a-4950-8901-fff8d2ee6025
+     * ->
+     * 9cb786e8586a49508901fff8d2ee6025
+     */
+    static inline std::string extractIdFromUUID(const std::string& uuid)
+    {
+	unsigned int i = 0;
+	std::string res;
+	
+	if (uuid.find("urn:uuid:") == 0)
+	    i = 9;
+
+	for(; i<uuid.size(); i++)
+	{
+	    if (uuid[i] != '-')
+		res += uuid[i];
+	}
+
+	return res;
+    }
+    
+    /**
+     * @brief Open a file descriptor on path. If it already exists and truncate == true, it's truncated
+     *
+     * @return Created fd, must be closed
+     */
+    static inline int createNewFile(std::string path, bool truncate=true)
+    {
+	int options = O_CREAT|O_WRONLY;
+	if (truncate)
+	    options |= O_TRUNC;
+	else
+	    options |= O_APPEND;
+
+	int fd = open(path.c_str(), options, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH);
+
+	if (fd <= 0)
+	    EXCEPTION(GOUROU_FILE_ERROR, "Unable to create " << path);
+
+	return fd;
+    }
+    
     /**
      * @brief Write data in a file. If it already exists, it's truncated
      */
     static inline void writeFile(std::string path, const unsigned char* data, unsigned int length)
     {
-	int fd = open(path.c_str(), O_CREAT|O_WRONLY|O_TRUNC, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH);
-
-	if (fd <= 0)
-	    EXCEPTION(GOUROU_FILE_ERROR, "Unable to create " << path);
+	int fd = createNewFile(path);
 	
 	if (write(fd, data, length) != length)
 	    EXCEPTION(GOUROU_FILE_ERROR, "Write error for file " << path);
@@ -392,6 +446,20 @@ namespace gourou
 	}
 	return 0;
     }
+
+    static inline void dumpBuffer(GOUROU_LOG_LEVEL level, const char* title, const unsigned char* data, unsigned int len)
+    {
+	if (gourou::logLevel < level)
+	    return;
+	
+	printf("%s", title);
+	for(unsigned int i=0; i<len; i++)
+	{
+	    if (i && !(i%16)) printf("\n");
+	    printf("%02x ", data[i]);
+	}
+	printf("\n");	
+    }
 }
 
 #endif

include/libgourou_log.h

@@ -24,16 +24,16 @@
 
 namespace gourou {
     enum GOUROU_LOG_LEVEL {
-	ERROR,
-	WARN,
-	INFO,
-	DEBUG,
-	TRACE
+	LG_LOG_ERROR,
+	LG_LOG_WARN,
+	LG_LOG_INFO,
+	LG_LOG_DEBUG,
+	LG_LOG_TRACE
     };
 
     extern GOUROU_LOG_LEVEL logLevel;
 
-#define GOUROU_LOG(__lvl, __msg) if (__lvl <= gourou::logLevel) {std::cout << __msg << std::endl << std::flush;}
+#define GOUROU_LOG(__lvl, __msg) if (gourou::LG_LOG_##__lvl <= gourou::logLevel) {std::cout << __msg << std::endl << std::flush;}
 #define GOUROU_LOG_FUNC() GOUROU_LOG(TRACE, __FUNCTION__ << "() @ " << __FILE__ << ":" << __LINE__)
 
     /**

include/loan_token.h

@@ -0,0 +1,54 @@
+/*
+  Copyright 2022 Grégory Soutadé
+
+  This file is part of libgourou.
+
+  libgourou is free software: you can redistribute it and/or modify
+  it under the terms of the GNU Lesser General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  libgourou is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  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/>.
+*/
+
+#ifndef _LOAN_TOKEN_H_
+#define _LOAN_TOKEN_H_
+
+#include <map>
+
+#include <pugixml.hpp>
+
+namespace gourou
+{
+    /**
+     * @brief This class is a container for a fulfillment object
+     */
+    class LoanToken
+    {
+    public:
+	/**
+	 * @brief Main constructor. Not to be called by user
+	 *
+	 * @param doc   Fulfill reply
+	 */
+	LoanToken(pugi::xml_document& doc);
+
+	/**
+	 * @brief Get a property (id, operatorURL, validity)
+	 */
+	std::string getProperty(const std::string& property, const std::string& _default=std::string(""));
+	std::string operator[](const std::string& property);
+
+    private:
+	std::map<std::string, std::string> properties;
+    };
+}
+
+
+#endif

scripts/setup.sh

@@ -8,11 +8,6 @@ if [ ! -d lib/pugixml ] ; then
     popd
 fi
 
-# Base64
-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

scripts/update_lib.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+
+if [ ! -d lib/pugixml -o ! -d lib/updfparser ] ; then
+    echo "Some libraries are missing"
+    echo "You must run this script at the top of libgourou working direcotry."
+    echo "./lib/setup.sh must be called first (make all)"
+    exit 1
+fi
+
+# Pugixml
+pushd lib/pugixml
+git pull origin latest
+popd
+
+# uPDFParser
+pushd lib/updfparser
+git pull origin master
+make clean all BUILD_STATIC=1 BUILD_SHARED=0

src/bytearray.cpp

@@ -17,8 +17,9 @@
   along with libgourou. If not, see <http://www.gnu.org/licenses/>.
 */
 #include <string.h>
+#include <stdexcept>
 
-#include <base64/Base64.h>
+#include <Base64.h>
 
 #include <bytearray.h>
 
@@ -155,6 +156,47 @@ namespace gourou
 	return macaron::Base64::Encode(std::string((char*)_data, _length));
     }
 
+    ByteArray ByteArray::fromHex(const std::string& str)
+    {
+	if (str.size() % 2)
+	    throw std::invalid_argument("Size of hex string not multiple of 2");
+
+	ByteArray res((unsigned int)(str.size()/2));
+	unsigned int i;
+
+	unsigned char* data = res.data();
+	unsigned char cur, tmp;
+	
+	for (i=0; i<str.size(); i+=2)
+	{
+	    cur = 0;
+
+	    tmp = str[i];
+	    if (tmp >= 'a' && tmp <= 'f')
+		cur = (tmp - 'a' + 10) << 4;
+	    else if (tmp >= 'A' && tmp <= 'F')
+		cur = (tmp - 'A' + 10) << 4;
+	    else if (tmp >= '0' && tmp <= '9')
+		cur = (tmp - '0') << 4;
+	    else
+		throw std::invalid_argument("Invalid character in hex string");
+
+	    tmp = str[i+1];
+	    if (tmp >= 'a' && tmp <= 'f')
+		cur += tmp - 'a' + 10;
+	    else if (tmp >= 'A' && tmp <= 'F')
+		cur += tmp - 'A' + 10;
+	    else if (tmp >= '0' && tmp <= '9')
+		cur += tmp - '0';
+	    else
+		throw std::invalid_argument("Invalid character in hex string");
+
+	    data[i/2] = cur;
+	}
+	
+	return res;
+    }
+    
     std::string ByteArray::toHex()
     {
 	char* tmp = new char[_length*2+1];

src/fulfillment_item.cpp

@@ -24,7 +24,7 @@
 namespace gourou
 {
     FulfillmentItem::FulfillmentItem(pugi::xml_document& doc, User* user)
-	: fulfillDoc()
+	: fulfillDoc(), loanToken(0)
     {
 	fulfillDoc.reset(doc); /* We must keep a copy */
 	metadatas = fulfillDoc.select_node("//metadata").node();
@@ -50,6 +50,23 @@ namespace gourou
 	    EXCEPTION(FFI_INVALID_FULFILLMENT_DATA, "Any license token in document");
 	
 	buildRights(licenseToken, user);
+
+	node = doc.select_node("/envelope/fulfillmentResult/returnable").node();
+	try
+	{
+	    if (node && node.first_child().value() == std::string("true"))
+		loanToken = new LoanToken(doc);
+	}
+	catch(std::exception& e)
+	{
+	    GOUROU_LOG(ERROR, "Book is returnable, but contains invalid loan token");
+	    GOUROU_LOG(ERROR, e.what());
+	}
+    }
+
+    FulfillmentItem::~FulfillmentItem()
+    {
+	if (loanToken) delete loanToken;
     }
     
     void FulfillmentItem::buildRights(const pugi::xml_node& licenseToken, User* user)
@@ -103,4 +120,9 @@ namespace gourou
     {
 	return resource;
     }
+
+    LoanToken* FulfillmentItem::getLoanToken()
+    {
+	return loanToken;
+    }
 }

src/libgourou.cpp

@@ -37,7 +37,7 @@
 
 namespace gourou
 {
-    GOUROU_LOG_LEVEL logLevel = WARN;
+    GOUROU_LOG_LEVEL logLevel = LG_LOG_WARN;
     const std::string DRMProcessor::VERSION = LIBGOUROU_VERSION;
     
     DRMProcessor::DRMProcessor(DRMProcessorClient* client):client(client), device(0), user(0)
@@ -89,7 +89,7 @@ namespace gourou
 	uint16_t nlength = htons(length);
 	char c;
 
-	if (logLevel >= TRACE)
+	if (logLevel >= LG_LOG_TRACE)
 	    printf("%02x %02x ", ((uint8_t*)&nlength)[0], ((uint8_t*)&nlength)[1]);
 	
 	client->digestUpdate(sha_ctx, (unsigned char*)&nlength, sizeof(nlength));
@@ -98,17 +98,17 @@ namespace gourou
 	{
 	    c = string[i];
 	    client->digestUpdate(sha_ctx, (unsigned char*)&c, 1);
-	    if (logLevel >= TRACE)
+	    if (logLevel >= LG_LOG_TRACE)
 		printf("%c", c);
 	}
-	if (logLevel >= TRACE)
+	if (logLevel >= LG_LOG_TRACE)
 	    printf("\n");
     }
 
     void DRMProcessor::pushTag(void* sha_ctx, uint8_t tag)
     {
 	client->digestUpdate(sha_ctx, &tag, sizeof(tag));
-	if (logLevel >= TRACE)
+	if (logLevel >= LG_LOG_TRACE)
 	    printf("%02x ", tag);
     }
 
@@ -226,17 +226,10 @@ namespace gourou
 
 	client->digestFinalize(sha_ctx, sha_out);
 	
-	if (logLevel >= DEBUG)
-	{
-	    printf("\nSHA OUT : ");
-	    for(int i=0; i<(int)SHA1_LEN; i++)
-		printf("%02x ", sha_out[i]);
-	    printf("\n");
-
-	}
+	dumpBuffer(gourou::LG_LOG_DEBUG, "\nSHA OUT : ", sha_out, SHA1_LEN);
     }
 
-    std::string DRMProcessor::signNode(const pugi::xml_node& rootNode)
+    void DRMProcessor::signNode(pugi::xml_node& rootNode)
     {
 	// Compute hash
 	unsigned char sha_out[SHA1_LEN];
@@ -252,17 +245,11 @@ namespace gourou
 	client->RSAPrivateEncrypt(privateRSAKey.data(), privateRSAKey.length(),
 				  RSAInterface::RSA_KEY_PKCS12, deviceKey.toBase64().data(),
 				  sha_out, sizeof(sha_out), res);
-	if (logLevel >= DEBUG)
-	{
-	    printf("Sig : ");
-	    for(int i=0; i<(int)sizeof(res); i++)
-		printf("%02x ", res[i]);
-	    printf("\n");
-	}
 	
-	ByteArray signature(res, sizeof(res));
+	dumpBuffer(gourou::LG_LOG_DEBUG, "Sig : ", res, sizeof(res));
 
-	return signature.toBase64();
+	std::string signature = ByteArray(res, sizeof(res)).toBase64();
+	appendTextElem(rootNode, "adept:signature", signature);
     }
 
     void DRMProcessor::addNonce(pugi::xml_node& root)
@@ -283,7 +270,11 @@ namespace gourou
 	struct timeval tv;
 	gettimeofday(&tv, 0);
 	uint32_t nonce32[2] = {0x6f046000, 0x388a};
+#ifdef STATIC_NONCE
+	uint64_t bigtime = 0xAA001122BBCCAAULL;
+#else
 	uint64_t bigtime = tv.tv_sec*1000;
+#endif
 	nonce32[0] += (bigtime & 0xFFFFFFFF) + (tv.tv_usec/1000);
 	nonce32[1] += ((bigtime >> 32) & 0xFFFFFFFF);
 	
@@ -300,11 +291,13 @@ namespace gourou
 	appendTextElem(root, "adept:expiration", buffer);
     }
     
-    ByteArray DRMProcessor::sendRequest(const std::string& URL, const std::string& POSTdata, const char* contentType, std::map<std::string, std::string>* responseHeaders)
+    ByteArray DRMProcessor::sendRequest(const std::string& URL, const std::string& POSTdata, const char* contentType, std::map<std::string, std::string>* responseHeaders, int fd, bool resume)
     {
 	if (contentType == 0)
 	    contentType = "";
-	std::string reply = client->sendHTTPRequest(URL, POSTdata, contentType, responseHeaders);
+	std::string reply = client->sendHTTPRequest(URL, POSTdata, contentType, responseHeaders, fd, resume);
+
+	if (fd) return ByteArray();
 	
 	pugi::xml_document replyDoc;
 	replyDoc.load_buffer(reply.c_str(), reply.length());
@@ -366,8 +359,7 @@ namespace gourou
 	addNonce(root);
 	appendTextElem(root, "adept:user",        user->getUUID());
 
-	std::string signature = signNode(root);
-	appendTextElem(root, "adept:signature",   signature);
+	signNode(root);
     }
     
     void DRMProcessor::doOperatorAuth(std::string operatorURL)
@@ -528,13 +520,11 @@ namespace gourou
 	
 	hmacParentNode.remove_child(hmacNode);
 
-	std::string signature = signNode(rootNode);
+	signNode(rootNode);
 	
 	// Add removed HMAC
 	appendTextElem(hmacParentNode, hmacNode.name(), hmacNode.first_child().value());
 
-	appendTextElem(rootNode, "adept:signature", signature);
-
 	pugi::xpath_node node = acsmDoc.select_node("//operatorURL");
 	if (!node)
 	    EXCEPTION(FF_NO_OPERATOR_URL, "OperatorURL not found in ACSM document");
@@ -581,7 +571,7 @@ namespace gourou
 	return new FulfillmentItem(fulfillReply, user);
     }
 
-    DRMProcessor::ITEM_TYPE DRMProcessor::download(FulfillmentItem* item, std::string path)
+    DRMProcessor::ITEM_TYPE DRMProcessor::download(FulfillmentItem* item, std::string path, bool resume)
     {
 	ITEM_TYPE res = EPUB;
 	
@@ -590,9 +580,11 @@ namespace gourou
 
 	std::map<std::string, std::string> headers;
 
-	ByteArray replyData = sendRequest(item->getDownloadURL(), "", 0, &headers);
+	int fd = createNewFile(path, !resume);
 	
-	writeFile(path, replyData);
+	sendRequest(item->getDownloadURL(), "", 0, &headers, fd, resume);
+
+	close(fd);
 
 	GOUROU_LOG(INFO, "Download into " << path);
 
@@ -667,7 +659,10 @@ namespace gourou
 	pugi::xml_node signIn = signInRequest.append_child("adept:signIn");
 	signIn.append_attribute("xmlns:adept") = ADOBE_ADEPT_NS;
 	std::string loginMethod = user->getLoginMethod();
-	if (loginMethod.size())
+
+	if (adobeID == "anonymous")
+	    signIn.append_attribute("method") = "anonymous";
+	else if (loginMethod.size())
 	    signIn.append_attribute("method") = loginMethod.c_str();
 	else
 	    signIn.append_attribute("method") = "AdobeID";
@@ -816,10 +811,7 @@ namespace gourou
 
 	pugi::xml_node root = activateReq.select_node("adept:activate").node();
 
-	std::string signature = signNode(root);
-
-	root = activateReq.select_node("adept:activate").node();
-	appendTextElem(root, "adept:signature", signature);
+	signNode(root);
 
 	pugi::xml_document activationDoc;
 	user->readActivation(activationDoc);
@@ -837,6 +829,33 @@ namespace gourou
 	user->updateActivationFile(activationDoc);
     }
     
+    void DRMProcessor::buildReturnReq(pugi::xml_document& returnReq, const std::string& loanID, const std::string& operatorURL)
+    {
+	pugi::xml_node decl = returnReq.append_child(pugi::node_declaration);
+	decl.append_attribute("version") = "1.0";
+	
+	pugi::xml_node root = returnReq.append_child("adept:loanReturn");
+	root.append_attribute("xmlns:adept") = ADOBE_ADEPT_NS;
+
+	appendTextElem(root, "adept:user",      user->getUUID());
+	appendTextElem(root, "adept:device",    user->getDeviceUUID());
+	appendTextElem(root, "adept:loan",      loanID);
+
+	addNonce(root);
+	signNode(root);
+    }
+    
+    void DRMProcessor::returnLoan(const std::string& loanID, const std::string& operatorURL)
+    {
+	pugi::xml_document returnReq;
+
+	GOUROU_LOG(INFO, "Return loan " << loanID);
+
+	buildReturnReq(returnReq, loanID, operatorURL);
+
+	sendRequest(returnReq, operatorURL + "/LoanReturn");
+    }
+
     ByteArray DRMProcessor::encryptWithDeviceKey(const unsigned char* data, unsigned int len)
     {
 	const unsigned char* deviceKey = device->getDeviceKey();
@@ -850,7 +869,7 @@ namespace gourou
 	// Generate IV in front
 	client->randBytes(encrypted_data, 16);
 	    
-	client->Encrypt(CryptoInterface::ALGO_AES, CryptoInterface::CHAIN_CBC,
+	client->encrypt(CryptoInterface::ALGO_AES, CryptoInterface::CHAIN_CBC,
 			deviceKey, 16, encrypted_data, 16,
 			data, len,
 			encrypted_data+16, &outLen);
@@ -869,7 +888,7 @@ namespace gourou
 	const unsigned char* deviceKey = device->getDeviceKey();
 	unsigned char* decrypted_data = new unsigned char[len-16];
 
-	client->Decrypt(CryptoInterface::ALGO_AES, CryptoInterface::CHAIN_CBC,
+	client->decrypt(CryptoInterface::ALGO_AES, CryptoInterface::CHAIN_CBC,
 			deviceKey, 16, data, 16,
 			data+16, len-16,
 			decrypted_data, &outLen);
@@ -932,22 +951,102 @@ namespace gourou
 
 	ByteArray arrayEncryptedKey = ByteArray::fromBase64(encryptedKey);
 
-	
 	std::string privateKeyData = user->getPrivateLicenseKey();
 	ByteArray privateRSAKey = ByteArray::fromBase64(privateKeyData);
 	
-	ByteArray deviceKey(device->getDeviceKey(), Device::DEVICE_KEY_SIZE);
-	std::string pkcs12 = user->getPKCS12();
+	dumpBuffer(gourou::LG_LOG_DEBUG, "To decrypt : ", arrayEncryptedKey.data(), arrayEncryptedKey.length());
 
 	client->RSAPrivateDecrypt(privateRSAKey.data(), privateRSAKey.length(),
-				  RSAInterface::RSA_KEY_PKCS12, deviceKey.toBase64().data(),
+				  RSAInterface::RSA_KEY_PKCS8, "",
 				  arrayEncryptedKey.data(), arrayEncryptedKey.length(), decryptedKey);
-
-	if (decryptedKey[0] != 0x00 || decryptedKey[1] != 0x02 ||
-	    decryptedKey[RSA_KEY_SIZE-16-1] != 0x00)
-	    EXCEPTION(DRM_ERR_ENCRYPTION_KEY, "Unable to retrieve encryption key");
     }
 
+    /**
+     * RSA Key can be over encrypted with AES128-CBC if keyType attribute is set
+     * For EPUB, Key = SHA256(keyType)[14:22] || SHA256(keyType)[7:13]
+     * For PDF,  Key = SHA256(keyType)[6:19]  || SHA256(keyType)[3:6]
+     * IV = DeviceID ^ FulfillmentId ^ VoucherId
+     *
+     * @return Base64 encoded decrypted key
+     */
+    std::string DRMProcessor::encryptedKeyFirstPass(pugi::xml_document& rightsDoc, const std::string& encryptedKey, const std::string& keyType, ITEM_TYPE type)
+    {
+	unsigned char digest[32], key[16], iv[16];
+	unsigned int dataOutLength;
+	std::string id;
+		
+	client->digest("SHA256", (unsigned char*)keyType.c_str(), keyType.size(), digest);
+
+	dumpBuffer(gourou::LG_LOG_DEBUG, "SHA of KeyType : ", digest, sizeof(digest));
+
+	switch(type)
+	{
+	case EPUB:
+	    memcpy(key, &digest[14], 9);
+	    memcpy(&key[9], &digest[7], 7);
+	    break;
+	case PDF:
+	    memcpy(key, &digest[6], 13);
+	    memcpy(&key[13], &digest[3], 3);
+	    break;
+	}
+
+	id = extractTextElem(rightsDoc, "/adept:rights/licenseToken/device");
+	if (id == "")
+	    EXCEPTION(DRM_ERR_ENCRYPTION_KEY_FP, "Device id not found in rights.xml");
+	ByteArray deviceId = ByteArray::fromHex(extractIdFromUUID(id));
+	unsigned char* _deviceId = deviceId.data();
+		
+	id = extractTextElem(rightsDoc, "/adept:rights/licenseToken/fulfillment");
+	if (id == "")
+	    EXCEPTION(DRM_ERR_ENCRYPTION_KEY_FP, "Fulfillment id not found in rights.xml");
+	ByteArray fulfillmentId = ByteArray::fromHex(extractIdFromUUID(id));
+	unsigned char* _fulfillmentId = fulfillmentId.data();
+		
+	id = extractTextElem(rightsDoc, "/adept:rights/licenseToken/voucher");
+	if (id == "")
+	    EXCEPTION(DRM_ERR_ENCRYPTION_KEY_FP, "Voucher id not found in rights.xml");
+	ByteArray voucherId = ByteArray::fromHex(extractIdFromUUID(id));
+	unsigned char* _voucherId = voucherId.data();
+		
+	if (deviceId.size() < sizeof(iv) || fulfillmentId.size() < sizeof(iv) || voucherId.size() < sizeof(iv))
+	    EXCEPTION(DRM_ERR_ENCRYPTION_KEY_FP, "One id has a bad length");
+
+	for(unsigned int i=0; i<sizeof(iv); i++)
+	    iv[i] = _deviceId[i] ^ _fulfillmentId[i] ^ _voucherId[i];
+
+	ByteArray arrayEncryptedKey = ByteArray::fromBase64(encryptedKey);
+		
+	dumpBuffer(gourou::LG_LOG_DEBUG, "First pass key : ", key, sizeof(key));
+	dumpBuffer(gourou::LG_LOG_DEBUG, "First pass IV  : ", iv, sizeof(iv));
+
+	unsigned char* clearRSAKey = new unsigned char[arrayEncryptedKey.size()];
+	
+	client->decrypt(CryptoInterface::ALGO_AES, CryptoInterface::CHAIN_CBC,
+			(const unsigned char*)key, (unsigned int)sizeof(key),
+			(const unsigned char*)iv, (unsigned int)sizeof(iv),
+			(const unsigned char*)arrayEncryptedKey.data(), arrayEncryptedKey.size(),
+			(unsigned char*)clearRSAKey, &dataOutLength);
+
+	dumpBuffer(gourou::LG_LOG_DEBUG, "\nDecrypted key : ", clearRSAKey, dataOutLength);
+
+	/* Last block could be 0x10*16 which is OpenSSL padding, remove it if it's the case */
+	bool skipLastLine = true;
+	for(unsigned int i=dataOutLength-16; i<dataOutLength; i++)
+	{
+	    if (clearRSAKey[i] != 0x10)
+	    {
+		skipLastLine = false;
+		break;
+	    }
+	}
+
+	ByteArray res(clearRSAKey, (skipLastLine)?dataOutLength-16:dataOutLength);
+
+	delete[] clearRSAKey;
+
+	return res.toBase64();
+    }
     
     void DRMProcessor::removeEPubDRM(const std::string& filenameIn, const std::string& filenameOut,
 				     const unsigned char* encryptionKey, unsigned encryptionKeySize)
@@ -964,7 +1063,20 @@ namespace gourou
 	unsigned char decryptedKey[RSA_KEY_SIZE];
 
 	if (!encryptionKey)
+	{
+	    std::string keyType = extractTextAttribute(rightsDoc, "/adept:rights/licenseToken/encryptedKey", "keyType", false);
+
+	    if (keyType != "")
+		encryptedKey = encryptedKeyFirstPass(rightsDoc, encryptedKey, keyType, EPUB);
+	    
 	    decryptADEPTKey(encryptedKey, decryptedKey);
+
+	    dumpBuffer(gourou::LG_LOG_DEBUG, "Decrypted : ", decryptedKey, RSA_KEY_SIZE);
+
+	    if (decryptedKey[0] != 0x00 || decryptedKey[1] != 0x02 ||
+		decryptedKey[RSA_KEY_SIZE-16-1] != 0x00)
+		EXCEPTION(DRM_ERR_ENCRYPTION_KEY, "Unable to retrieve encryption key");
+	}
 	else
 	{
 	    GOUROU_LOG(DEBUG, "Use provided encryption key");
@@ -1010,7 +1122,7 @@ namespace gourou
 		gourou::ByteArray inflateData(true);
 		unsigned int dataOutLength;
 
-		client->Decrypt(CryptoInterface::ALGO_AES, CryptoInterface::CHAIN_CBC,
+		client->decrypt(CryptoInterface::ALGO_AES, CryptoInterface::CHAIN_CBC,
 				decryptedKey+sizeof(decryptedKey)-16, 16, /* Key */
 				_data, 16, /* IV */
 				&_data[16], zipData.length()-16,
@@ -1146,7 +1258,20 @@ namespace gourou
 		std::string encryptedKey = extractTextElem(rightsDoc, "/adept:rights/licenseToken/encryptedKey");
 
 		if (!encryptionKey)
+		{
+		    std::string keyType = extractTextAttribute(rightsDoc, "/adept:rights/licenseToken/encryptedKey", "keyType", false);
+
+		    if (keyType != "")
+			encryptedKey = encryptedKeyFirstPass(rightsDoc, encryptedKey, keyType, PDF);
+		    
 		    decryptADEPTKey(encryptedKey, decryptedKey);
+
+		    dumpBuffer(gourou::LG_LOG_DEBUG, "Decrypted : ", decryptedKey, RSA_KEY_SIZE);
+
+		    if (decryptedKey[0] != 0x00 || decryptedKey[1] != 0x02 ||
+			decryptedKey[RSA_KEY_SIZE-16-1] != 0x00)
+			EXCEPTION(DRM_ERR_ENCRYPTION_KEY, "Unable to retrieve encryption key");
+		}
 		else
 		{
 		    GOUROU_LOG(DEBUG, "Use provided encryption key");
@@ -1214,8 +1339,8 @@ namespace gourou
 
 		    GOUROU_LOG(DEBUG, "Decrypt string " << dictIt->first << " " << dataLength);
 
-		    client->Decrypt(CryptoInterface::ALGO_RC4, CryptoInterface::CHAIN_ECB,
-				    tmpKey, 16, /* Key */
+		    client->decrypt(CryptoInterface::ALGO_RC4, CryptoInterface::CHAIN_ECB,
+				    tmpKey, sizeof(tmpKey), /* Key */
 				    NULL, 0, /* IV */
 				    encryptedData, dataLength,
 				    clearData, &dataOutLength);
@@ -1247,8 +1372,8 @@ namespace gourou
 		
 		GOUROU_LOG(DEBUG, "Decrypt stream id " << object->objectId() << ", size " << stream->dataLength());
 
-		client->Decrypt(CryptoInterface::ALGO_RC4, CryptoInterface::CHAIN_ECB,
-				tmpKey, 16, /* Key */
+		client->decrypt(CryptoInterface::ALGO_RC4, CryptoInterface::CHAIN_ECB,
+				tmpKey, sizeof(tmpKey), /* Key */
 				NULL, 0, /* IV */
 				encryptedData, dataLength,
 				clearData, &dataOutLength);

src/loan_token.cpp

@@ -0,0 +1,91 @@
+/*
+  Copyright 2022 Grégory Soutadé
+
+  This file is part of libgourou.
+
+  libgourou is free software: you can redistribute it and/or modify
+  it under the terms of the GNU Lesser General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  libgourou is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  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/>.
+*/
+
+#include "libgourou_common.h"
+#include "loan_token.h"
+
+namespace gourou
+{
+    LoanToken::LoanToken(pugi::xml_document& doc)
+    {
+	pugi::xml_node node = doc.select_node("/envelope/loanToken").node();
+
+	if (!node)
+	    EXCEPTION(FFI_INVALID_LOAN_TOKEN, "No loanToken element in document");
+
+	node = doc.select_node("/envelope/loanToken/loan").node();
+
+	if (node)
+	    properties["id"] = node.first_child().value();
+	else
+	{
+	    node = doc.select_node("/envelope/fulfillmentResult/resourceItemInfo/licenseToken/permissions/display/loan").node();
+
+	    if (node)
+		properties["id"] = node.first_child().value();
+	    else
+	    {
+		node = doc.select_node("/envelope/fulfillmentResult/resourceItemInfo/licenseToken/permissions/play/loan").node();
+		if (node)
+		    properties["id"] = node.first_child().value();
+		else
+		    EXCEPTION(FFI_INVALID_LOAN_TOKEN, "No loanToken/loan element in document");
+	    }
+	}
+
+	node = doc.select_node("/envelope/loanToken/operatorURL").node();
+
+	if (!node)
+	    EXCEPTION(FFI_INVALID_LOAN_TOKEN, "No loanToken/operatorURL element in document");
+
+	properties["operatorURL"] = node.first_child().value();
+
+	node = doc.select_node("/envelope/fulfillmentResult/resourceItemInfo/licenseToken/permissions/display/until").node();
+
+	if (node)
+	    properties["validity"] = node.first_child().value();
+	else
+	{
+	    node = doc.select_node("/envelope/fulfillmentResult/resourceItemInfo/licenseToken/permissions/play/until").node();
+
+	    if (node)
+		properties["validity"] = node.first_child().value();
+	    else
+		EXCEPTION(FFI_INVALID_LOAN_TOKEN, "No loanToken/operatorURL element in document");
+	}
+    }
+
+    std::string LoanToken::getProperty(const std::string& property, const std::string& _default)
+    {
+	if (properties.find(property) == properties.end())
+	{
+	    if (_default == "")
+		EXCEPTION(GOUROU_INVALID_PROPERTY, "Invalid property " << property);
+
+	    return _default;
+	}
+
+	return properties[property];
+    }
+
+    std::string LoanToken::operator[](const std::string& property)
+    {
+	return getProperty(property);
+    }
+}

utils/Makefile

@@ -1,10 +1,10 @@
 
-TARGETS=acsmdownloader adept_activate adept_remove
+TARGETS=acsmdownloader adept_activate adept_remove adept_loan_mgt launcher
 
-CXXFLAGS=-Wall `pkg-config --cflags Qt5Core Qt5Network` -fPIC -I$(ROOT)/include -I$(ROOT)/lib/pugixml/src/
+CXXFLAGS=-Wall -fPIC -I$(ROOT)/include -I$(ROOT)/lib/pugixml/src/
 
 STATIC_DEP=
-LDFLAGS=`pkg-config --libs Qt5Core Qt5Network` -L$(ROOT) -lcrypto -lzip -lz
+LDFLAGS += -L$(ROOT) -lcrypto -lzip -lz -lcurl
 
 ifneq ($(STATIC_UTILS),)
 STATIC_DEP = $(ROOT)/libgourou.a
@@ -13,25 +13,26 @@ LDFLAGS += -lgourou
 endif
 
 ifneq ($(DEBUG),)
-CXXFLAGS += -ggdb -O0
+CXXFLAGS += -ggdb -O0 -DDEBUG
 else
 CXXFLAGS += -O2
 endif
 
-COMMON_DEPS = drmprocessorclientimpl.cpp $(STATIC_DEP)
+
+COMMON_DEPS = drmprocessorclientimpl.cpp utils_common.cpp
+COMMON_OBJECTS = $(COMMON_DEPS:.cpp=.o)
+COMMON_LIB  = utils.a
 
 all: $(TARGETS)
 
-acsmdownloader: acsmdownloader.cpp $(COMMON_DEPS)
-	$(CXX) $(CXXFLAGS) $^ $(LDFLAGS) -o $@
+${COMMON_LIB}: ${COMMON_DEPS} ${STATIC_DEP}
+	$(CXX) $(CXXFLAGS) ${COMMON_DEPS} $(LDFLAGS) -c
+	$(AR) crs $@ ${COMMON_OBJECTS} $(STATIC_DEP)
 
-adept_activate: adept_activate.cpp $(COMMON_DEPS)
-	$(CXX) $(CXXFLAGS) $^ $(LDFLAGS) -o $@
-
-adept_remove: adept_remove.cpp $(COMMON_DEPS)
+%: %.cpp ${COMMON_LIB}
 	$(CXX) $(CXXFLAGS) $^ $(LDFLAGS) -o $@
 
 clean:
-	rm -f $(TARGETS)
+	rm -f $(TARGETS) $(COMMON_LIB)
 
 ultraclean: clean

utils/acsmdownloader.cpp

@@ -26,21 +26,17 @@
   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
-#include <unistd.h>
 #include <getopt.h>
+#include <libgen.h>
 
 #include <iostream>
-
-#include <QFile>
-#include <QDir>
-#include <QCoreApplication>
-#include <QRunnable>
-#include <QThreadPool>
+#include <algorithm>
 
 #include <libgourou.h>
-#include "drmprocessorclientimpl.h"
+#include <libgourou_common.h>
 
-#define ARRAY_SIZE(arr) (sizeof(arr)/sizeof(arr[0]))
+#include "drmprocessorclientimpl.h"
+#include "utils_common.h"
 
 static const char* deviceFile     = "device.xml";
 static const char* activationFile = "activation.xml";
@@ -49,28 +45,18 @@ static const char* acsmFile       = 0;
 static       bool  exportPrivateKey = false;
 static const char* outputFile     = 0;
 static const char* outputDir      = 0;
-static const char* defaultDirs[]  = {
-    ".adept/",
-    "./adobe-digital-editions/",
-    "./.adobe-digital-editions/"
-};
+static       bool  resume         = false;
 
 
-class ACSMDownloader: public QRunnable
+class ACSMDownloader
 {
 public:
-    ACSMDownloader(QCoreApplication* app):
-	app(app)
-    {
-	setAutoDelete(false);
-    }
     
-    void run()
+    int run()
     {
 	int ret = 0;
 	try
 	{
-	    DRMProcessorClientImpl client;
 	    gourou::DRMProcessor processor(&client, deviceFile, activationFile, devicekeyFile);
 	    gourou::User* user = processor.getUser();
 	    
@@ -84,9 +70,8 @@ public:
 	    
 		if (outputDir)
 		{
-		    QDir dir(outputDir);
-		    if (!dir.exists(outputDir))
-			dir.mkpath(outputDir);
+		    if (!fileExists(outputDir))
+			mkpath(outputDir);
 		    
 		    filename = std::string(outputDir) + "/" + filename;
 		}
@@ -116,14 +101,13 @@ public:
 	    
 		if (outputDir)
 		{
-		    QDir dir(outputDir);
-		    if (!dir.exists(outputDir))
-			dir.mkpath(outputDir);
+		    if (!fileExists(outputDir))
+			mkpath(outputDir);
 
 		    filename = std::string(outputDir) + "/" + filename;
 		}
 	    
-		gourou::DRMProcessor::ITEM_TYPE type = processor.download(item, filename);
+		gourou::DRMProcessor::ITEM_TYPE type = processor.download(item, filename, resume);
 
 		if (!outputFile)
 		{
@@ -132,11 +116,12 @@ public:
 			finalName += ".pdf";
 		    else
 			finalName += ".epub";
-		    QDir dir;
-		    dir.rename(filename.c_str(), finalName.c_str());
+		    rename(filename.c_str(), finalName.c_str());
 		    filename = finalName;
 		}
 		std::cout << "Created " << filename << std::endl;
+
+		serializeLoanToken(item);
 	    }
 	} catch(std::exception& e)
 	{
@@ -144,43 +129,62 @@ public:
 	    ret = 1;
 	}
 
-	this->app->exit(ret);
+	return ret;
+    }
+
+    void serializeLoanToken(gourou::FulfillmentItem* item)
+    {
+	gourou::LoanToken* token = item->getLoanToken();
+
+	// No loan token available
+	if (!token)
+	    return;
+
+	pugi::xml_document doc;
+
+	pugi::xml_node decl = doc.append_child(pugi::node_declaration);
+	decl.append_attribute("version") = "1.0";
+
+	pugi::xml_node root = doc.append_child("loanToken");
+	gourou::appendTextElem(root, "id",          (*token)["id"]);
+	gourou::appendTextElem(root, "operatorURL", (*token)["operatorURL"]);
+	gourou::appendTextElem(root, "validity",    (*token)["validity"]);
+	gourou::appendTextElem(root, "name",        item->getMetadata("title"));
+
+	char * activationDir = strdup(deviceFile);
+	activationDir = dirname(activationDir);
+		
+	gourou::StringXMLWriter xmlWriter;
+	doc.save(xmlWriter, "  ");
+	std::string xmlStr = xmlWriter.getResult();
+
+	// Use first bytes of SHA1(id) as filename
+	unsigned char sha1[gourou::SHA1_LEN];
+	client.digest("SHA1", (unsigned char*)(*token)["id"].c_str(), (*token)["id"].size(), sha1);
+	gourou::ByteArray tmp(sha1, sizeof(sha1));
+	std::string filenameHex = tmp.toHex();
+	std::string filename(filenameHex.c_str(), ID_HASH_SIZE);
+	std::string fullPath = std::string(activationDir);
+	fullPath += std::string ("/") + std::string(LOANS_DIR);
+	mkpath(fullPath.c_str());
+	fullPath += filename + std::string(".xml");
+	gourou::writeFile(fullPath, xmlStr);
+
+	std::cout << "Loan token serialized into " << fullPath << std::endl;
+
+	free(activationDir);
     }
     
 private:
-    QCoreApplication* app;
+    DRMProcessorClientImpl client;
 };	      
 
-static const char* findFile(const char* filename, bool inDefaultDirs=true)
-{
-    QFile file(filename);
-
-    if (file.exists())
-	return strdup(filename);
-
-    if (!inDefaultDirs) return 0;
-    
-    for (int i=0; i<(int)ARRAY_SIZE(defaultDirs); i++)
-    {
-	QString path = QString(defaultDirs[i]) + QString(filename);
-	file.setFileName(path);
-	if (file.exists())
-	    return strdup(path.toStdString().c_str());
-    }
-    
-    return 0;
-}
-
-static void version(void)
-{
-    std::cout << "Current libgourou version : " << gourou::DRMProcessor::VERSION << std::endl ;
-}
 
 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] [(-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 << "Usage: " << basename((char*)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)] [(-r|--resume)] [(-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;
@@ -189,6 +193,7 @@ static void usage(const char* cmd)
     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 << "  " << "-r|--resume"          << "\t\t" << "Try to resume download (in case of previous failure)" << 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;
@@ -218,13 +223,14 @@ int main(int argc, char** argv)
 	    {"output-file",      required_argument, 0,  'o' },
 	    {"acsm-file",        required_argument, 0,  'f' },
 	    {"export-private-key",no_argument,      0,  'e' },
+	    {"resume",           no_argument,       0,  'r' },
 	    {"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:evVh",
+	c = getopt_long(argc, argv, "d:a:k:O:o:f:ervVh",
                         long_options, &option_index);
 	if (c == -1)
 	    break;
@@ -251,6 +257,9 @@ int main(int argc, char** argv)
 	case 'e':
 	    exportPrivateKey = true;
 	    break;
+	case 'r':
+	    resume = true;
+	    break;
 	case 'v':
 	    verbose++;
 	    break;
@@ -275,8 +284,7 @@ int main(int argc, char** argv)
 	return -1;
     }
 
-    QCoreApplication app(argc, argv);
-    ACSMDownloader downloader(&app);
+    ACSMDownloader downloader;
 
     int i;
     bool hasErrors = false;
@@ -306,8 +314,7 @@ int main(int argc, char** argv)
     }
     else
     {
-	QFile file(acsmFile);
-	if (!file.exists())
+	if (!fileExists(acsmFile))
 	{
 	    std::cout << "Error : " << acsmFile << " doesn't exists" << std::endl;
 	    ret = -1;
@@ -315,9 +322,7 @@ int main(int argc, char** argv)
 	}
     }
     
-    QThreadPool::globalInstance()->start(&downloader);
-
-    ret = app.exec();
+    ret = downloader.run();
 
 end:
     for (i=0; i<(int)ARRAY_SIZE(files); i++)

utils/adept_activate.cpp

@@ -28,22 +28,16 @@
 
 #include <unistd.h>
 #include <getopt.h>
-#include <stdlib.h>
 #include <termios.h>
+#include <string.h>
+#include <limits.h>
 
 #include <iostream>
 #include <ostream>
 
-#include <QFile>
-#include <QDir>
-#include <QCoreApplication>
-#include <QRunnable>
-#include <QThreadPool>
-
 #include <libgourou.h>
 #include "drmprocessorclientimpl.h"
-
-#define ARRAY_SIZE(arr) (sizeof(arr)/sizeof(arr[0]))
+#include "utils_common.h"
 
 static const char* username      = 0;
 static const char* password      = 0;
@@ -100,16 +94,11 @@ static std::string getpass(const char *prompt, bool show_asterisk=false)
 }
 
 
-class ADEPTActivate: public QRunnable
+class ADEPTActivate
 {
 public:  
-    ADEPTActivate(QCoreApplication* app):
-	app(app)
-    {
-	setAutoDelete(false);
-    }
 
-    void run()
+    int run()
     {
 	int ret = 0;
 	try
@@ -128,23 +117,16 @@ public:
 	    ret = 1;
 	}
 
-	this->app->exit(ret);
+	return ret;
     }
-
-private:
-    QCoreApplication* app;
 };	      
 
-static void version(void)
-{
-    std::cout << "Current libgourou version : " << gourou::DRMProcessor::VERSION << std::endl ;
-}
 
 static void usage(const char* cmd)
 {
     std::cout << "Create new device files used by ADEPT DRM" << std::endl;
     
-    std::cout << "Usage: " << cmd << " (-a|--anonymous) | ( (-u|--username) username [(-p|--password) password] ) [(-O|--output-dir) dir] [(-r|--random-serial)] [(-v|--verbose)] [(-h|--help)]" << std::endl << std::endl;
+    std::cout << "Usage: " << basename((char*)cmd) << " (-a|--anonymous) | ( (-u|--username) username [(-p|--password) password] ) [(-O|--output-dir) dir] [(-r|--random-serial)] [(-v|--verbose)] [(-h|--help)]" << std::endl << std::endl;
     
     std::cout << "  " << "-a|--anonymous"  << "\t"   << "Anonymous account, no need for username/password (Use it only with a DRM removal software)" << std::endl;
     std::cout << "  " << "-u|--username"   << "\t\t" << "AdobeID username (ie adobe.com email account)" << std::endl;
@@ -162,8 +144,8 @@ static void usage(const char* cmd)
 static const char* abspath(const char* filename)
 {
     const char* root = getcwd(0, PATH_MAX);
-    QString fullPath = QString(root) + QString("/") + QString(filename);
-    const char* res = strdup(fullPath.toStdString().c_str());
+    std::string fullPath = std::string(root) + std::string("/") + filename;
+    const char* res = strdup(fullPath.c_str());
 
     free((void*)root);
 
@@ -255,9 +237,8 @@ int main(int argc, char** argv)
 	// Relative path
 	if (_outputDir[0] == '.' || _outputDir[0] != '/')
 	{
-	    QFile file(_outputDir);
 	    // realpath doesn't works if file/dir doesn't exists
-	    if (file.exists())
+	    if (fileExists(_outputDir))
 		outputDir = strdup(realpath(_outputDir, 0));
 	    else
 		outputDir = strdup(abspath(_outputDir));
@@ -266,10 +247,8 @@ int main(int argc, char** argv)
 	    outputDir = strdup(_outputDir);
     }
 
-    QCoreApplication app(argc, argv);
-
-    QFile file(outputDir);
-    if (file.exists())
+    std::string pass;
+    if (fileExists(outputDir))
     {
 	int key;
 	
@@ -289,7 +268,6 @@ int main(int argc, char** argv)
 	    ;
     }
 
-    std::string pass;
     if (!password)
     {
 	char prompt[128];
@@ -298,13 +276,11 @@ int main(int argc, char** argv)
 	password = pass.c_str();
     }
         
-    ADEPTActivate activate(&app);
-    QThreadPool::globalInstance()->start(&activate);
+    ADEPTActivate activate;
 
-    ret = app.exec();
+    ret = activate.run();
 
 end:    
-    
     free((void*)outputDir);
     return ret;
 }

utils/adept_loan_mgt.cpp

@@ -0,0 +1,479 @@
+/*
+  Copyright (c) 2022, Grégory Soutadé
+
+  All rights reserved.
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+  
+  * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+  * Neither the name of the copyright holder nor the
+    names of its contributors may be used to endorse or promote products
+    derived from this software without specific prior written permission.
+  
+  THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+  DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include <getopt.h>
+
+#include <iostream>
+#include <algorithm>
+
+#define _XOPEN_SOURCE 700
+#include <stdio.h>
+#include <sys/types.h>
+#include <dirent.h>
+#include <libgen.h>
+#include <time.h>
+
+#include <libgourou.h>
+#include <libgourou_common.h>
+#include "drmprocessorclientimpl.h"
+#include "utils_common.h"
+
+#define MAX_SIZE_BOOK_NAME   30
+
+static       char* activationDir  = 0;
+static const char* deviceFile     = "device.xml";
+static const char* activationFile = "activation.xml";
+static const char* devicekeyFile  = "devicesalt";
+static       bool  list           = false;
+static const char* returnID       = 0;
+static const char* deleteID       = 0;
+
+struct Loan
+{
+    std::string id;
+    std::string operatorURL;
+    std::string validity;
+    std::string bookName;
+    
+    std::string path;
+};
+    
+class LoanMGT
+{
+public:
+    ~LoanMGT()
+    {
+	for (const auto& kv : loanedBooks)
+	    delete kv.second;
+    }
+    
+    int run()
+    {
+	int ret = 0;
+	try
+	{
+	    DRMProcessorClientImpl client;
+	    gourou::DRMProcessor processor(&client, deviceFile, activationFile, devicekeyFile);
+
+	    loadLoanedBooks();
+
+	    if (list)
+		displayLoanList();
+	    else if (returnID)
+		returnBook(processor);
+	    else if (deleteID)
+		deleteLoan();
+	} catch(std::exception& e)
+	{
+	    std::cout << e.what() << std::endl;
+	    ret = 1;
+	}
+
+	return ret;
+    }
+
+private:
+    void loadLoanedBooks()
+    {
+	DIR *dp;
+	struct dirent *ep;
+	int entryLen;
+	struct Loan* loan;
+	char * res;
+	
+	std::string loanDir = std::string(activationDir) + std::string("/") + LOANS_DIR;
+
+	if (!fileExists(loanDir.c_str()))
+	    return;
+	
+	dp = opendir (loanDir.c_str());
+
+	if(!dp)
+	    EXCEPTION(gourou::USER_INVALID_INPUT, "Cannot read directory " << loanDir);
+
+	while ((ep = readdir (dp)))
+	{
+	    if (ep->d_type != DT_LNK &&
+		ep->d_type != DT_REG)
+		continue;
+
+	    entryLen = strlen(ep->d_name);
+
+	    if (entryLen <= 4 ||
+		ep->d_name[entryLen-4] != '.' ||
+		ep->d_name[entryLen-3] != 'x' ||
+		ep->d_name[entryLen-2] != 'm' ||
+		ep->d_name[entryLen-1] != 'l')
+		continue;
+
+	    std::string id = std::string(ep->d_name, entryLen-4);
+	    
+	    loan = new Loan;
+	    loan->path = loanDir + std::string("/") + ep->d_name;
+
+	    pugi::xml_document xmlDoc;
+	    pugi::xml_node node;
+
+	    if (!xmlDoc.load_file(loan->path.c_str(), pugi::parse_ws_pcdata_single|pugi::parse_escapes, pugi::encoding_utf8))
+	    {
+		std::cout << "Invalid loan entry " << loan->path << std::endl;
+		goto error;
+	    }
+
+	    // id
+	    node = xmlDoc.select_node("//id").node();
+	    if (!node)
+	    {
+		std::cout << "Invalid loan entry " << ep->d_name << ", no id element" << std::endl;
+		goto error;
+	    }
+	    loan->id = node.first_child().value();
+
+	    // operatorURL
+	    node = xmlDoc.select_node("//operatorURL").node();
+	    if (!node)
+	    {
+		std::cout << "Invalid loan entry " << ep->d_name << ", no operatorURL element" << std::endl;
+		goto error;
+	    }
+	    loan->operatorURL = node.first_child().value();
+
+	    // validity
+	    node = xmlDoc.select_node("//validity").node();
+	    if (!node)
+	    {
+		std::cout << "Invalid loan entry " << ep->d_name << ", no validity element" << std::endl;
+		goto error;
+	    }
+	    loan->validity = node.first_child().value();
+
+	    // bookName
+	    node = xmlDoc.select_node("//name").node();
+	    if (!node)
+	    {
+		std::cout << "Invalid loan entry " << ep->d_name << ", no name element" << std::endl;
+		goto error;
+	    }
+	    loan->bookName = node.first_child().value();
+
+	    struct tm tm;
+	    res = strptime(loan->validity.c_str(), "%Y-%m-%dT%H:%M:%S%Z", &tm);
+	    if (*res == 0)
+	    {
+		if (mktime(&tm) <= time(NULL))
+		    loan->validity = "     (Expired)";
+	    }
+	    else
+	    {
+		std::cout << "Unable to parse validity timestamp :" << loan->validity << std::endl;
+		loan->validity = "     (Unknown)";
+	    }
+	    
+	    loanedBooks[id] = loan;
+	    continue;
+
+	error:
+	    if (loan)
+		delete loan;
+	}
+
+	closedir (dp);
+    }
+
+    void displayLoanList()
+    {
+	if (!loanedBooks.size())
+	{
+	    std::cout << "Any book loaned" << std::endl;
+	    return;
+	}
+
+	struct Loan* loan;
+	unsigned int maxSizeBookName=0;
+	// Compute max size
+	for (const auto& kv : loanedBooks)
+	{
+	    loan = kv.second;
+	    if (loan->bookName.size() > maxSizeBookName)
+		maxSizeBookName = loan->bookName.size();
+	}
+
+	if (maxSizeBookName > MAX_SIZE_BOOK_NAME)
+	    maxSizeBookName = MAX_SIZE_BOOK_NAME;
+	else if ((maxSizeBookName % 2))
+	    maxSizeBookName++;
+
+	// std::cout << "  ID      Book      Expiration" << std::endl;
+	// std::cout << "------------------------------" << std::endl;
+
+	int fillID, fillBookName, fillExpiration=(20 - 10)/2;
+	
+	fillID = (ID_HASH_SIZE - 2) / 2;
+	fillBookName = (maxSizeBookName - 4) / 2;
+
+	std::cout.width (fillID);
+	std::cout << "";
+	std::cout << "ID" ;
+	std::cout.width (fillID);
+	std::cout << "";
+	std::cout << "    " ;
+	
+	std::cout.width (fillBookName);
+	std::cout << "";
+	std::cout << "Book" ;
+	std::cout.width (fillBookName);
+	std::cout << "";
+	std::cout << "    " ;
+
+	std::cout.width (fillExpiration);
+	std::cout << "";
+	std::cout << "Exipration";
+	std::cout.width (fillExpiration);
+	std::cout << "" << std::endl;
+
+	std::cout.fill ('-');
+	std::cout.width (ID_HASH_SIZE + 4 + maxSizeBookName + 4 + 20);
+	std::cout << "" << std::endl;
+	std::cout.fill (' ');
+
+	std::string bookName;
+
+	for (const auto& kv : loanedBooks)
+	{
+	    loan = kv.second;
+
+	    std::cout << kv.first;
+	    std::cout << "    ";
+
+	    if (loan->bookName.size() > MAX_SIZE_BOOK_NAME)
+		bookName = std::string(loan->bookName.c_str(), MAX_SIZE_BOOK_NAME);
+	    else
+		bookName = loan->bookName;
+
+	    std::cout << bookName;
+	    std::cout.width (maxSizeBookName - bookName.size());
+	    std::cout << "";
+	    std::cout << "    ";
+	    
+	    std::cout << loan->validity << std::endl;
+	}
+
+	std::cout << std::endl;
+    }
+
+    void returnBook(gourou::DRMProcessor& processor)
+    {
+	struct Loan* loan = loanedBooks[std::string(returnID)];
+
+	if (!loan)
+	{
+	    std::cout << "Error : Loan " << returnID << " doesn't exists" << std::endl;
+	    return;
+	}
+
+	processor.returnLoan(loan->id, loan->operatorURL);
+	
+	deleteID = returnID;
+	if (deleteLoan(false))
+	{
+	    std::cout << "Loan " << returnID << " successfully returned" << std::endl;
+	}
+    }
+    
+    bool deleteLoan(bool displayResult=true)
+    {
+	struct Loan* loan = loanedBooks[std::string(deleteID)];
+
+	if (!loan)
+	{
+	    std::cout << "Error : Loan " << deleteID << " doesn't exists" << std::endl;
+	    return false;
+	}
+
+	if (unlink(loan->path.c_str()))
+	{
+	    std::cout << "Error : Cannot delete " << loan->path << std::endl;
+	    return false;
+	}
+	else if (displayResult)
+	{
+	    std::cout << "Loan " << deleteID << " deleted" << std::endl;
+	}
+	
+	return true;
+    }
+
+    std::map<std::string, struct Loan*> loanedBooks;
+};	      
+
+
+static void usage(const char* cmd)
+{
+    std::cout << "Manage loaned books" << std::endl;
+    
+    std::cout << "Usage: " << basename((char*)cmd) << " [(-d|--activation-dir) dir] (-l|--list)|(-D|--delete loanID)|(-R|--delete loanID) [(-v|--verbose)] [(-h|--help)]" << std::endl << std::endl;
+    
+    std::cout << "  " << "-d|--activation-dir"  << "\t"   << "Directory of device.xml/activation.xml and device key" << std::endl;
+    std::cout << "  " << "-l|--list"            << "\t\t" << "List all loaned books" << std::endl;
+    std::cout << "  " << "-r|--return"          << "\t\t" << "Return a loaned book" << std::endl;
+    std::cout << "  " << "-D|--delete"          << "\t\t" << "Delete a loan entry without returning it" << 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;
+
+    std::cout << std::endl;
+    std::cout << "Activation directory is optional. If not set, it's looked into :" << std::endl;
+    std::cout << "  * Current directory" << std::endl;
+    std::cout << "  * .adept" << std::endl;
+    std::cout << "  * adobe-digital-editions directory" << std::endl;
+    std::cout << "  * .adobe-digital-editions directory" << std::endl;
+}
+
+int main(int argc, char** argv)
+{
+    int c, ret = -1;
+
+    const char** files[] = {&devicekeyFile, &deviceFile, &activationFile};
+    int verbose = gourou::DRMProcessor::getLogLevel();
+    int actions = 0;
+    
+    while (1) {
+	int option_index = 0;
+	static struct option long_options[] = {
+	    {"activation-dir",   required_argument, 0,  'd' },
+	    {"list",             no_argument,       0,  'l' },
+	    {"return",           no_argument,       0,  'r' },
+	    {"delete",           no_argument,       0,  'D' },
+	    {"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:lr:D:vVh",
+                        long_options, &option_index);
+	if (c == -1)
+	    break;
+
+	switch (c) {
+	case 'd':
+	    activationDir = optarg;
+	    break;
+	case 'l':
+	    list = true;
+	    actions++;
+	    break;
+	case 'r':
+	    returnID = optarg;
+	    actions++;
+	    break;
+	case 'D':
+	    deleteID = optarg;
+	    actions++;
+	    break;
+	case 'v':
+	    verbose++;
+	    break;
+	case 'V':
+	    version();
+	    return 0;
+	case 'h':
+	    usage(argv[0]);
+	    return 0;
+	default:
+	    usage(argv[0]);
+	    return -1;
+	}
+    }
+   
+    gourou::DRMProcessor::setLogLevel(verbose);
+
+    // By default, simply list books loaned
+    if (actions == 0)
+	list = true;
+    else if (actions != 1)
+    {
+	usage(argv[0]);
+	return -1;
+    }
+
+    LoanMGT loanMGT;
+
+    int i;
+    bool hasErrors = false;
+    const char* orig;
+    char *filename;
+    for (i=0; i<(int)ARRAY_SIZE(files); i++)
+    {
+	orig = *files[i];
+	
+	if (activationDir)
+	{
+	    std::string path = std::string(activationDir) + std::string("/") + orig;
+	    filename = strdup(path.c_str());
+	}
+	else
+	    filename = strdup(orig);
+	*files[i] = findFile(filename);
+	free(filename);
+	if (!*files[i])
+	{
+	    std::cout << "Error : " << orig << " doesn't exists, did you activate your device ?" << std::endl;
+	    hasErrors = true;
+	}
+    }
+
+    if (hasErrors)
+    {
+	// In case of activation dir was provided by user
+	activationDir = 0;
+	goto end;
+    }
+
+    if (activationDir)
+	activationDir = strdup(activationDir); // For below free
+    else
+    {
+	activationDir = strdup(deviceFile);
+	activationDir = dirname(activationDir);
+    }
+
+    ret = loanMGT.run();
+    
+end:
+    for (i=0; i<(int)ARRAY_SIZE(files); i++)
+    {
+	if (*files[i])
+	    free((void*)*files[i]);
+    }
+
+    if (activationDir)
+	free(activationDir);
+    
+    return ret;
+}

utils/adept_remove.cpp

@@ -26,23 +26,15 @@
   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
-#include <unistd.h>
 #include <getopt.h>
 
 #include <iostream>
 
-#include <QFile>
-#include <QDir>
-#include <QCoreApplication>
-#include <QRunnable>
-#include <QThreadPool>
-#include <QTemporaryFile>
-
 #include <libgourou.h>
 #include <libgourou_common.h>
-#include "drmprocessorclientimpl.h"
 
-#define ARRAY_SIZE(arr) (sizeof(arr)/sizeof(arr[0]))
+#include "drmprocessorclientimpl.h"
+#include "utils_common.h"
 
 static const char* deviceFile     = "device.xml";
 static const char* activationFile = "activation.xml";
@@ -50,11 +42,7 @@ static const char* devicekeyFile  = "devicesalt";
 static const char* inputFile      = 0;
 static const char* outputFile     = 0;
 static const char* outputDir      = 0;
-static const char* defaultDirs[]  = {
-    ".adept/",
-    "./adobe-digital-editions/",
-    "./.adobe-digital-editions/"
-};
+
 static char*          encryptionKeyUser  = 0;
 static unsigned char* encryptionKey      = 0;
 static unsigned       encryptionKeySize  = 0;
@@ -78,16 +66,11 @@ static inline bool endsWith(const std::string& s, const std::string& suffix)
     return s.rfind(suffix) == std::abs((int)(s.size()-suffix.size()));
 }
 
-class ADEPTRemove: public QRunnable
+class ADEPTRemove
 {
 public:
-    ADEPTRemove(QCoreApplication* app):
-	app(app)
-    {
-	setAutoDelete(false);
-    }
    
-    void run()
+    int run()
     {
 	int ret = 0;
 	try
@@ -104,9 +87,8 @@ public:
 	    
 	    if (outputDir)
 	    {
-		QDir dir(outputDir);
-		if (!dir.exists(outputDir))
-		    dir.mkpath(outputDir);
+		if (!fileExists(outputDir))
+		    mkpath(outputDir);
 
 		filename = std::string(outputDir) + "/" + filename;
 	    }
@@ -122,11 +104,8 @@ public:
 	    
 	    if (inputFile != filename)
 	    {
-		QFile::remove(filename.c_str());
-		if (!QFile::copy(inputFile, filename.c_str()))
-		{
-		    EXCEPTION(gourou::DRM_FILE_ERROR, "Unable to copy " << inputFile << " into " << filename);
-		}
+		unlink(filename.c_str());
+		fileCopy(inputFile, filename.c_str());
 		processor.removeDRM(inputFile, filename, type, encryptionKey, encryptionKeySize);
 		std::cout << "DRM removed into new file " << filename << std::endl;
 	    }
@@ -135,18 +114,16 @@ public:
 		// Use temp file for PDF
 		if (type == gourou::DRMProcessor::ITEM_TYPE::PDF)
 		{
-		    QTemporaryFile tempFile;
-		    tempFile.open();
-		    tempFile.setAutoRemove(false); // In case of failure
-		    processor.removeDRM(inputFile, tempFile.fileName().toStdString(), type, encryptionKey, encryptionKeySize);
+		    std::string tempFile = filename + ".tmp";
+		    /* Be sure there is not already a temp file */
+		    unlink(tempFile.c_str());
+		    processor.removeDRM(filename, tempFile, type, encryptionKey, encryptionKeySize);
 		    /* Original file must be removed before doing a copy... */
-		    QFile origFile(inputFile);
-		    origFile.remove();
-		    if (!QFile::copy(tempFile.fileName(), filename.c_str()))
+		    unlink(filename.c_str());
+		    if (rename(tempFile.c_str(), filename.c_str()))
 		    {
-			EXCEPTION(gourou::DRM_FILE_ERROR, "Unable to copy " << tempFile.fileName().toStdString() << " into " << filename);
+			EXCEPTION(gourou::DRM_FILE_ERROR, "Unable to copy " << tempFile << " into " << filename);
 		    }
-		    tempFile.setAutoRemove(true);
 		}
 		else
 		    processor.removeDRM(inputFile, filename, type, encryptionKey, encryptionKeySize);
@@ -158,43 +135,15 @@ public:
 	    ret = 1;
 	}
 
-	this->app->exit(ret);
+	return ret;
     }
-
-private:
-    QCoreApplication* app;
 };	      
 
-static const char* findFile(const char* filename, bool inDefaultDirs=true)
-{
-    QFile file(filename);
-
-    if (file.exists())
-	return strdup(filename);
-
-    if (!inDefaultDirs) return 0;
-    
-    for (int i=0; i<(int)ARRAY_SIZE(defaultDirs); i++)
-    {
-	QString path = QString(defaultDirs[i]) + QString(filename);
-	file.setFileName(path);
-	if (file.exists())
-	    return strdup(path.toStdString().c_str());
-    }
-    
-    return 0;
-}
-
-static void version(void)
-{
-    std::cout << "Current libgourou version : " << gourou::DRMProcessor::VERSION << std::endl ;
-}
-
 static void usage(const char* cmd)
 {
     std::cout << "Remove ADEPT DRM (from Adobe) of EPUB/PDF file" << 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|--input-file) file(.epub|pdf)" << std::endl << std::endl;
+    std::cout << "Usage: " << basename((char*)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|--input-file) file(.epub|pdf)" << 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;
@@ -288,8 +237,7 @@ int main(int argc, char** argv)
 	return -1;
     }
 
-    QCoreApplication app(argc, argv);
-    ADEPTRemove remover(&app);
+    ADEPTRemove remover;
 
     int i;
     bool hasErrors = false;
@@ -335,9 +283,7 @@ int main(int argc, char** argv)
     if (hasErrors)
 	goto end;
        
-    QThreadPool::globalInstance()->start(&remover);
-
-    ret = app.exec();
+    ret = remover.run();
     
 end:
     for (i=0; i<(int)ARRAY_SIZE(files); i++)

utils/drmprocessorclientimpl.cpp

@@ -25,25 +25,54 @@
   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
+#include <bytearray.h>
+
+#include <algorithm> 
+#include <cctype>
+#include <locale>
+
+#define OPENSSL_NO_DEPRECATED 1
 
 #include <openssl/rand.h>
 #include <openssl/pkcs12.h>
 #include <openssl/evp.h>
 #include <openssl/err.h>
+#include <openssl/rsa.h>
+#include <openssl/bn.h>
 
-#include <QCoreApplication>
-#include <QNetworkReply>
-#include <QNetworkRequest>
-#include <QNetworkAccessManager>
-#include <QFile>
+#include <curl/curl.h>
 
 #include <zlib.h>
 #include <zip.h>
 
 #include <libgourou_common.h>
-#include <libgourou_log.h>
 #include "drmprocessorclientimpl.h"
 
+DRMProcessorClientImpl::DRMProcessorClientImpl():
+    legacy(0), deflt(0)
+{
+#if OPENSSL_VERSION_MAJOR >= 3
+    legacy = OSSL_PROVIDER_load(NULL, "legacy");
+    if (!legacy)
+	EXCEPTION(gourou::CLIENT_OSSL_ERROR, "Error, OpenSSL legacy provider not available");
+
+    deflt = OSSL_PROVIDER_load(NULL, "default");
+    if (!deflt)
+	EXCEPTION(gourou::CLIENT_OSSL_ERROR, "Error, OpenSSL default provider not available");
+#endif
+}
+
+DRMProcessorClientImpl::~DRMProcessorClientImpl()
+{
+#if OPENSSL_VERSION_MAJOR >= 3
+    if (legacy)
+	OSSL_PROVIDER_unload(legacy);
+
+    if (deflt)
+	OSSL_PROVIDER_unload(deflt);
+#endif
+}
+
 /* Digest interface */
 void* DRMProcessorClientImpl::createDigest(const std::string& digestName)
 {
@@ -53,32 +82,32 @@ void* DRMProcessorClientImpl::createDigest(const std::string& digestName)
     if (EVP_DigestInit(md_ctx, md) != 1)
     {
 	EVP_MD_CTX_free(md_ctx);
-	return 0;
+	EXCEPTION(gourou::CLIENT_DIGEST_ERROR, ERR_error_string(ERR_get_error(), NULL));
     }
 
     return md_ctx;
 }
 
-int DRMProcessorClientImpl::digestUpdate(void* handler, unsigned char* data, unsigned int length)
+void DRMProcessorClientImpl::digestUpdate(void* handler, unsigned char* data, unsigned int length)
 {
-    return (EVP_DigestUpdate((EVP_MD_CTX *)handler, data, length)) ? 0 : -1;
+    if (EVP_DigestUpdate((EVP_MD_CTX *)handler, data, length) != 1)
+	EXCEPTION(gourou::CLIENT_DIGEST_ERROR, ERR_error_string(ERR_get_error(), NULL));
 }
 
-int DRMProcessorClientImpl::digestFinalize(void* handler, unsigned char* digestOut)
+void DRMProcessorClientImpl::digestFinalize(void* handler, unsigned char* digestOut)
 {
     int res = EVP_DigestFinal((EVP_MD_CTX *)handler, digestOut, NULL);
     EVP_MD_CTX_free((EVP_MD_CTX *)handler);
-    return (res == 1) ? 0 : -1;
+
+    if (res <= 0)
+	EXCEPTION(gourou::CLIENT_DIGEST_ERROR, ERR_error_string(ERR_get_error(), NULL));
 }
 
-int DRMProcessorClientImpl::digest(const std::string& digestName, unsigned char* data, unsigned int length, unsigned char* digestOut)
+void DRMProcessorClientImpl::digest(const std::string& digestName, unsigned char* data, unsigned int length, unsigned char* digestOut)
 {
     void* handler = createDigest(digestName);
-    if (!handler)
-	return -1;
-    if (digestUpdate(handler, data, length))
-	return -1;
-    return digestFinalize(handler, digestOut);
+    digestUpdate(handler, data, length);
+    digestFinalize(handler, digestOut);
 }
 
 /* Random interface */
@@ -88,111 +117,254 @@ void DRMProcessorClientImpl::randBytes(unsigned char* bytesOut, unsigned int len
 }
 
 /* HTTP interface */
+#define HTTP_REQ_MAX_RETRY  5
 #define DISPLAY_THRESHOLD   10*1024 // Threshold to display download progression
+static unsigned downloadedBytes;
 
-static void downloadProgress(qint64 bytesReceived, qint64 bytesTotal) {
+static int downloadProgress(void *clientp, curl_off_t dltotal, curl_off_t dlnow,
+			    curl_off_t ultotal, curl_off_t ulnow)
+{
 // For "big" files only
-    if (bytesTotal >= DISPLAY_THRESHOLD && gourou::logLevel >= gourou::WARN)
+    if (dltotal >= DISPLAY_THRESHOLD && gourou::logLevel >= gourou::LG_LOG_WARN)
     {
 	int percent = 0;
-	if (bytesTotal)
-	    percent = (bytesReceived * 100) / bytesTotal;
+	if (dltotal)
+	    percent = (dlnow * 100) / dltotal;
 
 	std::cout << "\rDownload " << percent << "%" << std::flush;
     }
+
+    return 0;
 }
 
-std::string DRMProcessorClientImpl::sendHTTPRequest(const std::string& URL, const std::string& POSTData, const std::string& contentType, std::map<std::string, std::string>* responseHeaders)
+static size_t curlRead(void *data, size_t size, size_t nmemb, void *userp)
 {
-    QNetworkRequest request(QUrl(URL.c_str()));
-    QNetworkAccessManager networkManager;
-    QByteArray replyData;
+    gourou::ByteArray* replyData = (gourou::ByteArray*) userp;
     
-    GOUROU_LOG(gourou::INFO, "Send request to " << URL);
-    if (POSTData.size())
-    {
-	GOUROU_LOG(gourou::DEBUG, "<<< " << std::endl << POSTData);
+    replyData->append((unsigned char*)data, size*nmemb);
+
+    return size*nmemb;
 }
 
-    request.setRawHeader("Accept", "*/*");
-    request.setRawHeader("User-Agent", "book2png");
-    if (contentType.size())
-	request.setRawHeader("Content-Type", contentType.c_str());
+static size_t curlReadFd(void *data, size_t size, size_t nmemb, void *userp)
+{
+    int fd = *(int*) userp;
 
-    QNetworkReply* reply;
+    size_t res = write(fd, data, size*nmemb);
 
+    downloadedBytes += res;
+
+    return res;
+}
+
+static size_t curlHeaders(char *buffer, size_t size, size_t nitems, void *userdata)
+{
+    std::map<std::string, std::string>* responseHeaders = (std::map<std::string, std::string>*)userdata;
+    std::string::size_type pos = 0;
+    std::string buf(buffer, size*nitems);
+
+    pos = buf.find(":", pos);
+
+    if (pos != std::string::npos)
+    {
+	std::string key   = std::string(buffer, pos);
+	std::string value = std::string(&buffer[pos+1], (size*nitems)-(pos+1));
+
+	key = gourou::trim(key);
+	value = gourou::trim(value);
+
+	(*responseHeaders)[key] = value;
+    
+	if (gourou::logLevel >= gourou::LG_LOG_DEBUG)
+	    std::cout << key << " : "  << value << std::endl;
+    }
+    
+    return size*nitems;
+}
+
+std::string DRMProcessorClientImpl::sendHTTPRequest(const std::string& URL, const std::string& POSTData, const std::string& contentType, std::map<std::string, std::string>* responseHeaders, int fd, bool resume)
+{
+    gourou::ByteArray replyData;
+    std::map<std::string, std::string> localHeaders;
+
+    if (!responseHeaders)
+	responseHeaders = &localHeaders;
+    
+    GOUROU_LOG(INFO, "Send request to " << URL);
     if (POSTData.size())
-	reply = networkManager.post(request, POSTData.c_str());
+    {
+	GOUROU_LOG(DEBUG, "<<< " << std::endl << POSTData);
+    }
+
+    unsigned prevDownloadedBytes;
+    downloadedBytes = 0;
+    if (fd && resume)
+    {
+	struct stat _stat;
+	if (!fstat(fd, &_stat))
+	{
+	    GOUROU_LOG(WARN, "Resume download @ " << _stat.st_size << " bytes");
+	    downloadedBytes = _stat.st_size;
+	}
 	else
-	reply = networkManager.get(request);
+	    GOUROU_LOG(WARN, "Want to resume, but fstat failed");
+    }
     
-    QEventLoop loop;
+    CURL *curl = curl_easy_init();
+    CURLcode res;
+    curl_easy_setopt(curl, CURLOPT_URL, URL.c_str());
+    curl_easy_setopt(curl, CURLOPT_USERAGENT, "book2png");
+    curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
 
-    QObject::connect(reply, &QNetworkReply::finished, &loop, &QEventLoop::quit);
-    // Handled just below
-    QObject::connect(reply, &QNetworkReply::errorOccurred, &loop, &QEventLoop::quit);
-    QObject::connect(reply, &QNetworkReply::downloadProgress, &loop, downloadProgress);
     
-    loop.exec();
-    
-    QByteArray location = reply->rawHeader("Location");
-    if (location.size() != 0)
+    struct curl_slist *list = NULL;
+    list = curl_slist_append(list, "Accept: */*");
+    std::string _contentType;
+    if (contentType.size())
     {
-	GOUROU_LOG(gourou::DEBUG, "New location");
-	return sendHTTPRequest(location.constData(), POSTData, contentType, responseHeaders);
+	_contentType = "Content-Type: " + contentType;
+	list = curl_slist_append(list, _contentType.c_str());
     }
 
-    if (reply->error() != QNetworkReply::NoError)
-	EXCEPTION(gourou::CLIENT_NETWORK_ERROR, "Error " << reply->errorString().toStdString());
+    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, list);
 
-    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();
+    if (POSTData.size())
+    {
+	curl_easy_setopt(curl, CURLOPT_POST, 1L);
+	curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, POSTData.size());
+	curl_easy_setopt(curl, CURLOPT_POSTFIELDS, POSTData.data());
     }
 
-    replyData = reply->readAll();
-    if (replyData.size() >= DISPLAY_THRESHOLD && gourou::logLevel >= gourou::WARN)
+    if (fd)
+    {
+	curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, curlReadFd);
+	curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void*)&fd);
+    }
+    else
+    {
+	curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, curlRead);
+	curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void*)&replyData);
+    }
+    
+    curl_easy_setopt(curl, CURLOPT_HEADERFUNCTION, curlHeaders);
+    curl_easy_setopt(curl, CURLOPT_HEADERDATA, (void*)responseHeaders);
+    
+    curl_easy_setopt(curl, CURLOPT_XFERINFOFUNCTION, downloadProgress);
+    curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0);
+
+    for (int i=0; i<HTTP_REQ_MAX_RETRY; i++)
+    {
+	prevDownloadedBytes = downloadedBytes;
+	if (downloadedBytes)
+	    curl_easy_setopt(curl, CURLOPT_RESUME_FROM, downloadedBytes);
+	    
+	res = curl_easy_perform(curl);
+
+	// Connexion failed, wait & retry
+	if (res == CURLE_COULDNT_CONNECT)
+	{
+	    GOUROU_LOG(WARN, "\nConnection failed, attempt " << (i+1) << "/" << HTTP_REQ_MAX_RETRY);	    
+	}
+	// Transfer failed but some data has been received
+	// --> try again without incrementing tries
+	else if (res == CURLE_RECV_ERROR)
+	{
+	    if (prevDownloadedBytes != downloadedBytes)
+	    {
+		GOUROU_LOG(WARN, "\nConnection broken, but data received, try again");	    
+		i--;
+	    }
+	    else
+		GOUROU_LOG(WARN, "\nConnection broken and no data received, attempt " << (i+1) << "/" << HTTP_REQ_MAX_RETRY);
+	}
+	// Other error --> fail
+	else
+	    break;
+
+	// Wait a little bit (250ms * i)
+	usleep((250 * 1000) * (i+1));
+    }
+    
+    curl_slist_free_all(list);
+    curl_easy_cleanup(curl);
+   
+    if (res != CURLE_OK)
+	EXCEPTION(gourou::CLIENT_NETWORK_ERROR, "Error " << curl_easy_strerror(res));
+    
+    if ((downloadedBytes >= DISPLAY_THRESHOLD || replyData.size() >= DISPLAY_THRESHOLD) &&
+	gourou::logLevel >= gourou::LG_LOG_WARN)
 	std::cout << std::endl;
-    if (reply->rawHeader("Content-Type") == "application/vnd.adobe.adept+xml")
+
+    if ((*responseHeaders)["Content-Type"] == "application/vnd.adobe.adept+xml")
     {
-	GOUROU_LOG(gourou::DEBUG, ">>> " << std::endl << replyData.data());
+	GOUROU_LOG(DEBUG, ">>> " << std::endl << replyData.data());
     }
 	
-    return std::string(replyData.data(), replyData.length());
+    return std::string((char*)replyData.data(), replyData.length());
 }
 
+void DRMProcessorClientImpl::padWithPKCS1(unsigned char* out, unsigned int outLength,
+					  const unsigned char* in, unsigned int inLength)
+{
+    if (outLength < (inLength + 3))
+	EXCEPTION(gourou::CLIENT_RSA_ERROR, "Not enough space for PKCS1 padding");
+    
+    /*
+      PKCS1v5 Padding is :
+          0x00 0x01 0xff * n 0x00 dataIn
+    */
+    
+    memset(out, 0xFF, outLength);
+    
+    out[0] = 0x0;
+    out[1] = 0x1;
+    out[outLength - inLength - 1] = 0x00;
+    memcpy(&out[outLength - inLength], in, inLength);
+}
+
+
 void DRMProcessorClientImpl::RSAPrivateEncrypt(const unsigned char* RSAKey, unsigned int RSAKeyLength,
 					       const RSA_KEY_TYPE keyType, const std::string& password,
 					       const unsigned char* data, unsigned dataLength,
 					       unsigned char* res)
 {
     PKCS12 * pkcs12;
-    EVP_PKEY* pkey;
-    X509* cert;
-    STACK_OF(X509)* ca;
-    RSA * rsa;
+    EVP_PKEY_CTX *ctx;
+    EVP_PKEY* pkey = NULL;
+    size_t outlen;
+    unsigned char* tmp;
+    int ret;
     
     pkcs12 = d2i_PKCS12(NULL, &RSAKey, RSAKeyLength);
     if (!pkcs12)
 	EXCEPTION(gourou::CLIENT_INVALID_PKCS12, ERR_error_string(ERR_get_error(), NULL));
-    PKCS12_parse(pkcs12, password.c_str(), &pkey, &cert, &ca);
-    rsa = EVP_PKEY_get1_RSA(pkey);
 
-    int ret = RSA_private_encrypt(dataLength, data, res, rsa, RSA_PKCS1_PADDING);
+    if (PKCS12_parse(pkcs12, password.c_str(), &pkey, NULL, NULL) <= 0)
+	EXCEPTION(gourou::CLIENT_INVALID_PKCS12, ERR_error_string(ERR_get_error(), NULL));
 
-    if (ret < 0)
+    outlen = EVP_PKEY_get_size(pkey);
+
+    ctx = EVP_PKEY_CTX_new(pkey, NULL);
+
+    /* Use RSA private key */
+    if (EVP_PKEY_decrypt_init(ctx) <= 0)
 	EXCEPTION(gourou::CLIENT_RSA_ERROR, ERR_error_string(ERR_get_error(), NULL));
 
-    if (gourou::logLevel >= gourou::DEBUG)
-    {
-	printf("Encrypted : ");
-	for(int i=0; i<ret; i++)
-	    printf("%02x ", res[i]);
-	printf("\n");
-    }
+    if (EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_NO_PADDING) <= 0)
+	EXCEPTION(gourou::CLIENT_RSA_ERROR, ERR_error_string(ERR_get_error(), NULL));
+
+    tmp = (unsigned char*)malloc(outlen);
+
+    /* PKCS1 functions are no more exported */
+    padWithPKCS1(tmp, outlen, data, dataLength);
+   
+    ret = EVP_PKEY_decrypt(ctx, res, &outlen, tmp, outlen);
+
+    EVP_PKEY_CTX_free(ctx);
+    free(tmp);
+    
+    if (ret <= 0)
+	EXCEPTION(gourou::CLIENT_RSA_ERROR, ERR_error_string(ERR_get_error(), NULL));
 }
 
 void DRMProcessorClientImpl::RSAPrivateDecrypt(const unsigned char* RSAKey, unsigned int RSAKeyLength,
@@ -206,24 +378,30 @@ void DRMProcessorClientImpl::RSAPrivateDecrypt(const unsigned char* RSAKey, unsi
     if (!p8inf)
 	EXCEPTION(gourou::CLIENT_INVALID_PKCS8, ERR_error_string(ERR_get_error(), NULL));
    
+    EVP_PKEY_CTX *ctx;
     EVP_PKEY* pkey = EVP_PKCS82PKEY(p8inf);
-    RSA * rsa;
+    size_t outlen = dataLength;
     int ret;
 
-    rsa = EVP_PKEY_get1_RSA(pkey);
+    if (!pkey)
+	EXCEPTION(gourou::CLIENT_INVALID_PKCS8, ERR_error_string(ERR_get_error(), NULL));
 
-    ret = RSA_private_decrypt(dataLength, data, res, rsa, RSA_NO_PADDING);
+    ctx = EVP_PKEY_CTX_new(pkey, NULL);
 
-    if (ret < 0)
+    if (EVP_PKEY_decrypt_init(ctx) <= 0)
 	EXCEPTION(gourou::CLIENT_RSA_ERROR, ERR_error_string(ERR_get_error(), NULL));
 
-    if (gourou::logLevel >= gourou::DEBUG)
-    {
-	printf("Decrypted : ");
-	for(int i=0; i<ret; i++)
-	    printf("%02x ", res[i]);
-	printf("\n");
-    }
+    if (EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_NO_PADDING) <= 0)
+	EXCEPTION(gourou::CLIENT_RSA_ERROR, ERR_error_string(ERR_get_error(), NULL));
+
+    ret = EVP_PKEY_decrypt(ctx, res, &outlen, data, dataLength);
+
+    PKCS8_PRIV_KEY_INFO_free(p8inf);
+    EVP_PKEY_CTX_free(ctx);
+    BIO_free(mem);
+
+    if (ret <= 0)
+	EXCEPTION(gourou::CLIENT_RSA_ERROR, ERR_error_string(ERR_get_error(), NULL));
 }
 
 void DRMProcessorClientImpl::RSAPublicEncrypt(const unsigned char* RSAKey, unsigned int RSAKeyLength,
@@ -231,61 +409,79 @@ void DRMProcessorClientImpl::RSAPublicEncrypt(const unsigned char* RSAKey, unsig
 					      const unsigned char* data, unsigned dataLength,
 					      unsigned char* res)
 {
+    size_t outlen;
+
     X509 * x509 = d2i_X509(0, &RSAKey, RSAKeyLength);
     if (!x509)
 	EXCEPTION(gourou::CLIENT_INVALID_CERTIFICATE, "Invalid certificate");
 	
+    EVP_PKEY_CTX *ctx;
     EVP_PKEY * evpKey = X509_get_pubkey(x509);
-    RSA* rsa = EVP_PKEY_get1_RSA(evpKey);
-    EVP_PKEY_free(evpKey);
 
-    if (!rsa)
-	EXCEPTION(gourou::CLIENT_NO_PRIV_KEY, "No private key in certificate");
+    if (!evpKey)
+	EXCEPTION(gourou::CLIENT_NO_PUB_KEY, "No public key in certificate");
+
+    ctx = EVP_PKEY_CTX_new(evpKey, NULL);
+
+    if (EVP_PKEY_encrypt_init(ctx) <= 0)
+	EXCEPTION(gourou::CLIENT_RSA_ERROR, ERR_error_string(ERR_get_error(), NULL));
+
+    if (EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_PADDING) <= 0)
+	EXCEPTION(gourou::CLIENT_RSA_ERROR, ERR_error_string(ERR_get_error(), NULL));
+
+    int ret = EVP_PKEY_encrypt(ctx, res, &outlen, data, dataLength);
+
+    EVP_PKEY_CTX_free(ctx);
     
-    int ret = RSA_public_encrypt(dataLength, data, res, rsa, RSA_PKCS1_PADDING);
     if (ret < 0)
 	EXCEPTION(gourou::CLIENT_RSA_ERROR, ERR_error_string(ERR_get_error(), NULL));
+
+    EVP_PKEY_free(evpKey);
 }
 
 void* DRMProcessorClientImpl::generateRSAKey(int keyLengthBits)
 {
     BIGNUM * bn = BN_new();
-    RSA * rsa = RSA_new();
+    EVP_PKEY_CTX* ctx = EVP_PKEY_CTX_new_id(EVP_PKEY_RSA, NULL);
+    EVP_PKEY *key = NULL;
+
     BN_set_word(bn, 0x10001);
-    RSA_generate_key_ex(rsa, keyLengthBits, bn, 0);
+
+    EVP_PKEY_keygen_init(ctx);
+
+    EVP_PKEY_CTX_set_rsa_keygen_bits(ctx, keyLengthBits);
+    EVP_PKEY_CTX_set_rsa_padding(ctx, RSA_PKCS1_PADDING);
+    EVP_PKEY_CTX_set1_rsa_keygen_pubexp(ctx, bn);
+    EVP_PKEY_keygen(ctx, &key);
+
+    EVP_PKEY_CTX_free(ctx);
     BN_free(bn);
     
-    return rsa;
+    return key;
 }
 
 void DRMProcessorClientImpl::destroyRSAHandler(void* handler)
 {
-    RSA_free((RSA*)handler);
+    free(handler);
 }
 
 void DRMProcessorClientImpl::extractRSAPublicKey(void* handler, unsigned char** keyOut, unsigned int* keyOutLength)
 {
-    EVP_PKEY * evpKey = EVP_PKEY_new();
-    EVP_PKEY_set1_RSA(evpKey, (RSA*)handler);
     X509_PUBKEY *x509_pubkey = 0;
-    X509_PUBKEY_set(&x509_pubkey, evpKey);
+    X509_PUBKEY_set(&x509_pubkey, (EVP_PKEY*)handler);
 
     *keyOutLength = i2d_X509_PUBKEY(x509_pubkey, keyOut);
 
     X509_PUBKEY_free(x509_pubkey);
-    EVP_PKEY_free(evpKey);
 }
 
 void DRMProcessorClientImpl::extractRSAPrivateKey(void* handler, unsigned char** keyOut, unsigned int* keyOutLength)
 {
-    EVP_PKEY * evpKey = EVP_PKEY_new();
-    EVP_PKEY_set1_RSA(evpKey, (RSA*)handler);
-    PKCS8_PRIV_KEY_INFO * privKey = EVP_PKEY2PKCS8(evpKey);
+    PKCS8_PRIV_KEY_INFO * privKey = EVP_PKEY2PKCS8((EVP_PKEY*)handler);
 
     *keyOutLength = i2d_PKCS8_PRIV_KEY_INFO(privKey, keyOut);
 
     PKCS8_PRIV_KEY_INFO_free(privKey);
-    EVP_PKEY_free(evpKey);
 }
 				 
 void DRMProcessorClientImpl::extractCertificate(const unsigned char* RSAKey, unsigned int RSAKeyLength,
@@ -295,12 +491,14 @@ void DRMProcessorClientImpl::extractCertificate(const unsigned char* RSAKey, uns
     PKCS12 * pkcs12;
     EVP_PKEY* pkey = 0;
     X509* cert = 0;
-    STACK_OF(X509)* ca;
 
     pkcs12 = d2i_PKCS12(NULL, &RSAKey, RSAKeyLength);
     if (!pkcs12)
 	EXCEPTION(gourou::CLIENT_INVALID_PKCS12, ERR_error_string(ERR_get_error(), NULL));
-    PKCS12_parse(pkcs12, password.c_str(), &pkey, &cert, &ca);
+    PKCS12_parse(pkcs12, password.c_str(), &pkey, &cert, NULL);
+
+    if (!cert)
+	EXCEPTION(gourou::CLIENT_INVALID_PKCS12, ERR_error_string(ERR_get_error(), NULL));
 
     *certOutLength = i2d_X509(cert, certOut);
 
@@ -308,24 +506,27 @@ void DRMProcessorClientImpl::extractCertificate(const unsigned char* RSAKey, uns
 }
 
 /* Crypto interface */
-void DRMProcessorClientImpl::Encrypt(CRYPTO_ALGO algo, CHAINING_MODE chaining,
+void DRMProcessorClientImpl::encrypt(CRYPTO_ALGO algo, CHAINING_MODE chaining,
 				     const unsigned char* key, unsigned int keyLength,
 				     const unsigned char* iv, unsigned int ivLength,
 				     const unsigned char* dataIn, unsigned int dataInLength,
 				     unsigned char* dataOut, unsigned int* dataOutLength)
 {
-    void* handler = EncryptInit(algo, chaining, key, keyLength, iv, ivLength);
-    EncryptUpdate(handler, dataIn, dataInLength, dataOut, dataOutLength);
-    EncryptFinalize(handler, dataOut+*dataOutLength, dataOutLength);
+    void* handler = encryptInit(algo, chaining, key, keyLength, iv, ivLength);
+    encryptUpdate(handler, dataIn, dataInLength, dataOut, dataOutLength);
+    encryptFinalize(handler, dataOut+*dataOutLength, dataOutLength);
 }
 
-void* DRMProcessorClientImpl::EncryptInit(CRYPTO_ALGO algo, CHAINING_MODE chaining,
+void* DRMProcessorClientImpl::encryptInit(CRYPTO_ALGO algo, CHAINING_MODE chaining,
 					  const unsigned char* key, unsigned int keyLength,
 					  const unsigned char* iv, unsigned int ivLength)
 {
     EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();
+    int ret = 0;
     
-    if (algo == ALGO_AES)
+    switch (algo)
+    {
+    case ALGO_AES:
     {
 	switch(keyLength)
 	{
@@ -333,10 +534,10 @@ void* DRMProcessorClientImpl::EncryptInit(CRYPTO_ALGO algo, CHAINING_MODE chaini
 	    switch(chaining)
 	    {
 	    case CHAIN_ECB:
-		EVP_EncryptInit(ctx, EVP_aes_128_ecb(), key, iv);
+		ret = EVP_EncryptInit(ctx, EVP_aes_128_ecb(), key, iv);
 		break;
 	    case CHAIN_CBC:
-		EVP_EncryptInit(ctx, EVP_aes_128_cbc(), key, iv);
+		ret = EVP_EncryptInit(ctx, EVP_aes_128_cbc(), key, iv);
 		break;
 	    default:
 		EXCEPTION(gourou::CLIENT_BAD_CHAINING, "Unknown chaining mode " << chaining);
@@ -346,26 +547,39 @@ void* DRMProcessorClientImpl::EncryptInit(CRYPTO_ALGO algo, CHAINING_MODE chaini
 	    EVP_CIPHER_CTX_free(ctx);
 	    EXCEPTION(gourou::CLIENT_BAD_KEY_SIZE, "Invalid key size " << keyLength);
 	}
+	break;
     }
-    else if (algo == ALGO_RC4)
+    case ALGO_RC4:
     {
 	if (keyLength != 16)
 	{
 	    EVP_CIPHER_CTX_free(ctx);
 	    EXCEPTION(gourou::CLIENT_BAD_KEY_SIZE, "Invalid key size " << keyLength);
 	}
-	EVP_DecryptInit(ctx, EVP_rc4(), key, iv);
+	ret = EVP_DecryptInit(ctx, EVP_rc4(), key, iv);
+	break;
     }
+    }
+    
+    if (ret <= 0)
+    {
+	EVP_CIPHER_CTX_free(ctx);
+	EXCEPTION(gourou::CLIENT_CRYPT_ERROR, ERR_error_string(ERR_get_error(), NULL));
+    }
+    
     return ctx;
 }
 
-void* DRMProcessorClientImpl::DecryptInit(CRYPTO_ALGO algo, CHAINING_MODE chaining,
+void* DRMProcessorClientImpl::decryptInit(CRYPTO_ALGO algo, CHAINING_MODE chaining,
 					     const unsigned char* key, unsigned int keyLength,
 					     const unsigned char* iv, unsigned int ivLength)
 {
     EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();
+    int ret = 0;
     
-    if (algo == ALGO_AES)
+    switch(algo)
+    {
+    case ALGO_AES:
     {
 	switch(keyLength)
 	{
@@ -373,10 +587,10 @@ void* DRMProcessorClientImpl::DecryptInit(CRYPTO_ALGO algo, CHAINING_MODE chaini
 	    switch(chaining)
 	    {
 	    case CHAIN_ECB:
-		EVP_DecryptInit(ctx, EVP_aes_128_ecb(), key, iv);
+		ret = EVP_DecryptInit(ctx, EVP_aes_128_ecb(), key, iv);
 		break;
 	    case CHAIN_CBC:
-		EVP_DecryptInit(ctx, EVP_aes_128_cbc(), key, iv);
+		ret = EVP_DecryptInit(ctx, EVP_aes_128_cbc(), key, iv);
 		break;
 	    default:
 		EXCEPTION(gourou::CLIENT_BAD_CHAINING, "Unknown chaining mode " << chaining);
@@ -386,58 +600,81 @@ void* DRMProcessorClientImpl::DecryptInit(CRYPTO_ALGO algo, CHAINING_MODE chaini
 	    EVP_CIPHER_CTX_free(ctx);
 	    EXCEPTION(gourou::CLIENT_BAD_KEY_SIZE, "Invalid key size " << keyLength);
 	}
+	break;
     }
-    else if (algo == ALGO_RC4)
+    case ALGO_RC4:
     {
 	if (keyLength != 16)
 	{
 	    EVP_CIPHER_CTX_free(ctx);
 	    EXCEPTION(gourou::CLIENT_BAD_KEY_SIZE, "Invalid key size " << keyLength);
 	}
-	EVP_DecryptInit(ctx, EVP_rc4(), key, iv);
+	ret = EVP_DecryptInit(ctx, EVP_rc4(), key, iv);
+	break;
+    }
+    }
+    
+    if (ret <= 0)
+    {
+	EVP_CIPHER_CTX_free(ctx);
+	EXCEPTION(gourou::CLIENT_CRYPT_ERROR, ERR_error_string(ERR_get_error(), NULL));
     }
 
     return ctx;
 }
 
-void DRMProcessorClientImpl::EncryptUpdate(void* handler, const unsigned char* dataIn, unsigned int dataInLength,
+void DRMProcessorClientImpl::encryptUpdate(void* handler, const unsigned char* dataIn, unsigned int dataInLength,
 					   unsigned char* dataOut, unsigned int* dataOutLength)
 {
-    EVP_EncryptUpdate((EVP_CIPHER_CTX*)handler, dataOut, (int*)dataOutLength, dataIn, dataInLength);
+    int ret = EVP_EncryptUpdate((EVP_CIPHER_CTX*)handler, dataOut, (int*)dataOutLength, dataIn, dataInLength);
+
+   if (ret <= 0)
+       EXCEPTION(gourou::CLIENT_CRYPT_ERROR, ERR_error_string(ERR_get_error(), NULL));
 }
 
-void DRMProcessorClientImpl::EncryptFinalize(void* handler,
+void DRMProcessorClientImpl::encryptFinalize(void* handler,
 					     unsigned char* dataOut, unsigned int* dataOutLength)
 {
-    int len;
-    EVP_EncryptFinal_ex((EVP_CIPHER_CTX*)handler, dataOut, &len);
+    int len, ret;
+    
+    ret = EVP_EncryptFinal_ex((EVP_CIPHER_CTX*)handler, dataOut, &len);
     *dataOutLength += len;
     EVP_CIPHER_CTX_free((EVP_CIPHER_CTX*)handler);
+
+   if (ret <= 0)
+       EXCEPTION(gourou::CLIENT_CRYPT_ERROR, ERR_error_string(ERR_get_error(), NULL));
 }
 
-void DRMProcessorClientImpl::Decrypt(CRYPTO_ALGO algo, CHAINING_MODE chaining,
+void DRMProcessorClientImpl::decrypt(CRYPTO_ALGO algo, CHAINING_MODE chaining,
 				     const unsigned char* key, unsigned int keyLength,
 				     const unsigned char* iv, unsigned int ivLength,
 				     const unsigned char* dataIn, unsigned int dataInLength,
 				     unsigned char* dataOut, unsigned int* dataOutLength)
 {
-    void* handler = DecryptInit(algo, chaining, key, keyLength, iv, ivLength);
-    DecryptUpdate(handler, dataIn, dataInLength, dataOut, dataOutLength);
-    DecryptFinalize(handler, dataOut+*dataOutLength, dataOutLength);
+    void* handler = decryptInit(algo, chaining, key, keyLength, iv, ivLength);
+    decryptUpdate(handler, dataIn, dataInLength, dataOut, dataOutLength);
+    decryptFinalize(handler, dataOut+*dataOutLength, dataOutLength);
 }
 
-void DRMProcessorClientImpl::DecryptUpdate(void* handler, const unsigned char* dataIn, unsigned int dataInLength,
+void DRMProcessorClientImpl::decryptUpdate(void* handler, const unsigned char* dataIn, unsigned int dataInLength,
 					   unsigned char* dataOut, unsigned int* dataOutLength)
 {
-    EVP_DecryptUpdate((EVP_CIPHER_CTX*)handler, dataOut, (int*)dataOutLength, dataIn, dataInLength);
+    int ret = EVP_DecryptUpdate((EVP_CIPHER_CTX*)handler, dataOut, (int*)dataOutLength, dataIn, dataInLength);
+
+    if (ret <= 0)
+       EXCEPTION(gourou::CLIENT_CRYPT_ERROR, ERR_error_string(ERR_get_error(), NULL));
 }
 
-void DRMProcessorClientImpl::DecryptFinalize(void* handler, unsigned char* dataOut, unsigned int* dataOutLength)
+void DRMProcessorClientImpl::decryptFinalize(void* handler, unsigned char* dataOut, unsigned int* dataOutLength)
 {
-    int len;
-    EVP_DecryptFinal_ex((EVP_CIPHER_CTX*)handler, dataOut, &len);
+    int len, ret;
+
+    ret = EVP_DecryptFinal_ex((EVP_CIPHER_CTX*)handler, dataOut, &len);
     *dataOutLength += len;
     EVP_CIPHER_CTX_free((EVP_CIPHER_CTX*)handler);
+
+   if (ret <= 0)
+       EXCEPTION(gourou::CLIENT_CRYPT_ERROR, ERR_error_string(ERR_get_error(), NULL));
 }
 
 void* DRMProcessorClientImpl::zipOpen(const std::string& path)

utils/drmprocessorclientimpl.h

@@ -31,22 +31,29 @@
 
 #include <string>
 
+#if OPENSSL_VERSION_MAJOR >= 3
+#include <openssl/provider.h>
+#endif
+
 #include <drmprocessorclient.h>
 
 class DRMProcessorClientImpl : public gourou::DRMProcessorClient
 {
 public:
+    DRMProcessorClientImpl();
+    ~DRMProcessorClientImpl();
+    
     /* Digest interface */
     virtual void* createDigest(const std::string& digestName);
-    virtual int digestUpdate(void* handler, unsigned char* data, unsigned int length);
-    virtual int digestFinalize(void* handler,unsigned char* digestOut);
-    virtual int digest(const std::string& digestName, unsigned char* data, unsigned int length, unsigned char* digestOut);
+    virtual void digestUpdate(void* handler, unsigned char* data, unsigned int length);
+    virtual void digestFinalize(void* handler,unsigned char* digestOut);
+    virtual void digest(const std::string& digestName, unsigned char* data, unsigned int length, unsigned char* digestOut);
 
     /* Random interface */
     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(""), std::map<std::string, std::string>* responseHeaders=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, int fd=0, bool resume=false);
 
     virtual void RSAPrivateEncrypt(const unsigned char* RSAKey, unsigned int RSAKeyLength,
 				   const RSA_KEY_TYPE keyType, const std::string& password,
@@ -73,34 +80,34 @@ public:
 				    unsigned char** certOut, unsigned int* certOutLength);
 				 
     /* Crypto interface */
-    virtual void Encrypt(CRYPTO_ALGO algo, CHAINING_MODE chaining,
+    virtual void encrypt(CRYPTO_ALGO algo, CHAINING_MODE chaining,
 			 const unsigned char* key, unsigned int keyLength,
 			 const unsigned char* iv, unsigned int ivLength,
 			 const unsigned char* dataIn, unsigned int dataInLength,
 			 unsigned char* dataOut, unsigned int* dataOutLength);
 
-    virtual void* EncryptInit(CRYPTO_ALGO algo, CHAINING_MODE chaining,
+    virtual void* encryptInit(CRYPTO_ALGO algo, CHAINING_MODE chaining,
 			      const unsigned char* key, unsigned int keyLength,
 			      const unsigned char* iv=0, unsigned int ivLength=0);
 
 
-    virtual void EncryptUpdate(void* handler, const unsigned char* dataIn, unsigned int dataInLength,
+    virtual void encryptUpdate(void* handler, const unsigned char* dataIn, unsigned int dataInLength,
 				   unsigned char* dataOut, unsigned int* dataOutLength);
-    virtual void EncryptFinalize(void* handler, unsigned char* dataOut, unsigned int* dataOutLength);
+    virtual void encryptFinalize(void* handler, unsigned char* dataOut, unsigned int* dataOutLength);
 
-    virtual void Decrypt(CRYPTO_ALGO algo, CHAINING_MODE chaining,
+    virtual void decrypt(CRYPTO_ALGO algo, CHAINING_MODE chaining,
 			 const unsigned char* key, unsigned int keyLength,
 			 const unsigned char* iv, unsigned int ivLength,
 			 const unsigned char* dataIn, unsigned int dataInLength,
 			 unsigned char* dataOut, unsigned int* dataOutLength);
 
-    virtual void* DecryptInit(CRYPTO_ALGO algo, CHAINING_MODE chaining,
+    virtual void* decryptInit(CRYPTO_ALGO algo, CHAINING_MODE chaining,
 			      const unsigned char* key, unsigned int keyLength,
 			      const unsigned char* iv=0, unsigned int ivLength=0);
 
-    virtual void DecryptUpdate(void* handler, const unsigned char* dataIn, unsigned int dataInLength,
+    virtual void decryptUpdate(void* handler, const unsigned char* dataIn, unsigned int dataInLength,
 			       unsigned char* dataOut, unsigned int* dataOutLength);
-    virtual void DecryptFinalize(void* handler, unsigned char* dataOut, unsigned int* dataOutLength);
+    virtual void decryptFinalize(void* handler, unsigned char* dataOut, unsigned int* dataOutLength);
 
     /* ZIP Interface */
     virtual void* zipOpen(const std::string& path);
@@ -118,6 +125,17 @@ public:
 	
     virtual void deflate(gourou::ByteArray& data, gourou::ByteArray& result,
 			 int wbits=-15, int compressionLevel=8);
+
+private:
+
+    void padWithPKCS1(unsigned char* out, unsigned int outLength,
+		      const unsigned char* in, unsigned int inLength);
+    
+#if OPENSSL_VERSION_MAJOR >= 3
+    OSSL_PROVIDER *legacy, *deflt;
+#else
+    void *legacy, *deflt;
+#endif
 };
 
 #endif

utils/launcher.cpp

@@ -0,0 +1,40 @@
+#include <iostream>
+#include <unistd.h>
+#include <libgen.h>
+#include <string.h>
+
+#include "utils_common.h"
+
+#ifndef DEFAULT_UTIL
+#define DEFAULT_UTIL "acsmdownloader"
+#endif
+
+/* Inspired from https://discourse.appimage.org/t/call-alternative-binary-from-appimage/93/10*/
+
+int main(int argc, char** argv)
+{
+    char* util, *argv0;
+    char* mountPoint = getenv("APPDIR");
+    std::string fullPath;
+
+    /* Original command is in ARGV0 env variable*/
+    argv0 = strdup(getenv("ARGV0"));
+    util = basename(argv0);
+
+    fullPath = std::string(mountPoint) + util;
+
+    if (std::string(util) == "launcher" || !fileExists(fullPath.c_str()))
+	fullPath = std::string(mountPoint) + DEFAULT_UTIL;
+
+    free(argv0);
+    
+    argv[0] = strdup(fullPath.c_str());
+
+    if (execvp(argv[0], argv))
+	std::cout << "Unable to launch '" << argv[0] << "'" << std::endl;
+
+    /* Should not happens */
+    free(argv[0]);
+    
+    return 0;
+}

utils/utils_common.cpp

@@ -0,0 +1,127 @@
+/*
+  Copyright (c) 2022, Grégory Soutadé
+
+  All rights reserved.
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+  
+  * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+  * Neither the name of the copyright holder nor the
+    names of its contributors may be used to endorse or promote products
+    derived from this software without specific prior written permission.
+  
+  THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+  DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <limits.h>
+
+#include <iostream>
+
+#include <libgourou.h>
+#include <libgourou_common.h>
+#include "utils_common.h"
+
+static const char* defaultDirs[]  = {
+    ".adept/",
+    "./adobe-digital-editions/",
+    "./.adobe-digital-editions/"
+};
+
+void version(void)
+{
+    std::cout << "Current libgourou version : " << gourou::DRMProcessor::VERSION << std::endl ;
+}
+
+bool fileExists(const char* filename)
+{
+    struct stat _stat;
+    int ret = stat(filename, &_stat);
+
+    return (ret == 0);
+}
+
+const char* findFile(const char* filename, bool inDefaultDirs)
+{
+    if (fileExists(filename))
+	return strdup(filename);
+
+    if (!inDefaultDirs) return 0;
+    
+    for (int i=0; i<(int)ARRAY_SIZE(defaultDirs); i++)
+    {
+	std::string path = std::string(defaultDirs[i]) + filename;
+	if (fileExists(path.c_str()))
+	    return strdup(path.c_str());
+    }
+    
+    return 0;
+}
+
+// https://stackoverflow.com/questions/2336242/recursive-mkdir-system-call-on-unix
+void mkpath(const char *dir)
+{
+    char tmp[PATH_MAX];
+    char *p = NULL;
+    size_t len;
+
+    snprintf(tmp, sizeof(tmp),"%s",dir);
+    len = strlen(tmp);
+    if (tmp[len - 1] == '/')
+        tmp[len - 1] = 0;
+    for (p = tmp + 1; *p; p++)
+        if (*p == '/') {
+            *p = 0;
+            mkdir(tmp, S_IRWXU);
+            *p = '/';
+        }
+    mkdir(tmp, S_IRWXU);
+}
+
+void fileCopy(const char* in, const char* out)
+{
+    char buffer[4096];
+    int ret, fdIn, fdOut;
+
+    fdIn = open(in, O_RDONLY);
+
+    if (!fdIn)
+	EXCEPTION(gourou::CLIENT_FILE_ERROR, "Unable to open " << in);
+    
+    fdOut = gourou::createNewFile(out);
+    
+    if (!fdOut)
+    {
+	close (fdIn);
+	EXCEPTION(gourou::CLIENT_FILE_ERROR, "Unable to open " << out);
+    }
+
+    while (true)
+    {
+	ret = ::read(fdIn, buffer, sizeof(buffer));
+	if (ret <= 0)
+	    break;
+	::write(fdOut, buffer, ret);
+    }
+
+    close (fdIn);
+    close (fdOut);
+}

utils/utils_common.h

@@ -0,0 +1,67 @@
+/*
+  Copyright (c) 2022, Grégory Soutadé
+
+  All rights reserved.
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+  
+  * Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+  * Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+  * Neither the name of the copyright holder nor the
+    names of its contributors may be used to endorse or promote products
+    derived from this software without specific prior written permission.
+  
+  THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+  DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#ifndef _UTILS_COMMON_H_
+#define _UTILS_COMMON_H_
+
+#define LOANS_DIR            "loans/"
+#define ID_HASH_SIZE         16
+
+#define ARRAY_SIZE(arr) (sizeof(arr)/sizeof(arr[0]))
+
+/**
+ * @brief Display libgourou version
+ */
+void version(void);
+
+/**
+ * @brief Find a given filename in current directory and/or in default directories
+ *
+ * @param filename        Filename to search
+ * @param inDefaultDirs   Search is default directories or not
+ *
+ * @return A copy of full path
+ */
+const char* findFile(const char* filename, bool inDefaultDirs=true);
+
+/**
+ * @brief Does the file (or directory exists)
+ */
+bool fileExists(const char* filename);
+
+/**
+ * @brief Recursively created dir
+ */
+void mkpath(const char *dir);
+
+/**
+ * @brief Copy file in into file out
+ */
+void fileCopy(const char* in, const char* out);
+
+#endif