Use -fmacro-prefix-map for utils

The __FILE__ macro is used in the EXCEPTION macro to report the file name alongside error messages. This macro reports the file name exactly as it is passed to the compiler. For most source files in libgourou this is a nice relative path such as "src/libgourou.cpp". However, for EXCEPTION instances in libgourou_common.h, the compiler flag is "-I$(ROOT)/include", where $(ROOT) is an absolute path passed from the higher Makefile. This results in an absolute path to the build directory being hardcoded into the utils shared library and binaries, and reported in error messages. Besides being less readable than the more common relative paths, this triggers warnings from packaging tools that detect inadvertent references to temporary build directories that end up in compiled binaries and might indicate a bug. There is a GCC feature -fmacro-prefix-map which allows to perform substition on the values that are used for __FILE__. Use that option to strip out the absolute path component, without changing any functionality. The feature was added to GCC on 2018-01-18 and released in GCC 8.1.0. 7365279fca
Refresh curl download percent only when updated
2026-03-27 01:36:58 +00:00 · 2026-03-14 13:51:40 +01:00 · 2026-02-17 20:07:57 +01:00 · 2026-02-01 08:56:27 +01:00 · 2026-01-31 20:31:44 +01:00 · 2026-01-25 10:15:35 +01:00
37 changed files with 6303 additions and 2392 deletions
--- a/.gitignore
+++ b/.gitignore
@ -1,8 +1,11 @@
 obj
 lib
+*.o
 *.a
 *.so
 *~
 utils/acsmdownloader
-utils/activate
-.adept
+utils/adept_activate
+utils/adept_remove
+utils/adept_loan_mgt
+.adept*
--- a/106
+++ b/106
@ -1,55 +1,125 @@
+PREFIX ?= /usr/local
+LIBDIR ?= /lib
+INCDIR ?= /include

 AR ?= $(CROSS)ar
 CXX ?= $(CROSS)g++

-CXXFLAGS=-Wall -fPIC -I./include -I./lib -I./lib/pugixml/src/
-LDFLAGS=
+UPDFPARSERLIB = ./lib/updfparser/libupdfparser.a
+
+CXXFLAGS += -Wall -fPIC -I./include -I./usr/include/pugixml -I./lib/updfparser/include
+LDFLAGS = -lpugixml
+
+VERSION     := $(shell cat include/libgourou.h |grep LIBGOUROU_VERSION|cut -d '"' -f2)
+
+UNAME := $(shell uname -s)
+
+BUILD_STATIC ?= 0
+BUILD_SHARED ?= 1
+BUILD_UTILS  ?= 1
+
+TARGETS =
+TARGET_LIBRARIES =
+ifneq ($(STATIC_UTILS),)
+  BUILD_STATIC=1
+endif
+ifneq ($(BUILD_STATIC), 0)
+  TARGETS += libgourou.a
+  TARGET_LIBRARIES += libgourou.a
+  STATIC_UTILS=1
+endif
+ifneq ($(BUILD_SHARED), 0)
+  ifeq ($(UNAME), Darwin)
+	TARGETS += libgourou.dylib
+	TARGET_LIBRARIES += libgourou.dylib libgourou.dylib.$(VERSION)
+  else
+	TARGETS += libgourou.so
+	TARGET_LIBRARIES += libgourou.so libgourou.so.$(VERSION)
+  endif
+endif
+ifneq ($(BUILD_UTILS), 0)
+  TARGETS += build_utils
+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
-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
 OBJECTS     := $(patsubst $(SRCDIR)/%,$(BUILDDIR)/%,$(SOURCES:.$(SRCEXT)=.$(OBJEXT)))

-.PHONY: utils
+all: version lib obj $(TARGETS)

-all: lib obj libgourou utils
+version:
+	@echo "Building libgourou $(VERSION)"

 lib:
 	mkdir lib
 	./scripts/setup.sh

+update_lib:
+	./scripts/update_lib.sh
+
 obj:
 	mkdir obj

 $(BUILDDIR)/%.$(OBJEXT): $(SRCDIR)/%.$(SRCEXT)
 	$(CXX) $(CXXFLAGS) -c $^ -o $@

-libgourou: libgourou.a libgourou.so
+libgourou: $(TARGET_LIBRARIES)

-libgourou.a: $(OBJECTS)
-	$(AR) crs $@ obj/*.o
+libgourou.a: $(OBJECTS) $(UPDFPARSERLIB)
+	$(AR) rcs --thin $@ $^

-libgourou.so: libgourou.a
-	$(CXX) obj/*.o $(LDFLAGS) -o $@ -shared
+libgourou.so.$(VERSION): $(OBJECTS) $(UPDFPARSERLIB)
+	$(CXX) $^ -Wl,-soname,$@ $(LDFLAGS) -o $@ -shared

-utils:
-	make -C utils ROOT=$(PWD) CXX=$(CXX) AR=$(AR) DEBUG=$(DEBUG) STATIC_UTILS=$(STATIC_UTILS)
+libgourou.so: libgourou.so.$(VERSION)
+	ln -f -s $^ $@
+
+libgourou.dylib.$(VERSION): $(OBJECTS) $(UPDFPARSERLIB)
+	$(CXX) $^ $(LDFLAGS) -o $@ -shared
+
+libgourou.dylib: libgourou.dylib.$(VERSION)
+	ln -f -s $^ $@
+
+build_utils: $(TARGET_LIBRARIES)
+	$(MAKE) -C utils ROOT=$(PWD) CXX=$(CXX) AR=$(AR) DEBUG=$(DEBUG) STATIC_UTILS=$(STATIC_UTILS) DESTDIR=$(DESTDIR) PREFIX=$(PREFIX)
+
+install: $(TARGET_LIBRARIES)
+	install -d $(DESTDIR)$(PREFIX)$(LIBDIR)
+# Use cp to preserver symlinks
+	cp --no-dereference $(TARGET_LIBRARIES) $(DESTDIR)$(PREFIX)$(LIBDIR)
+	$(MAKE) -C utils ROOT=$(PWD) CXX=$(CXX) AR=$(AR) DEBUG=$(DEBUG) STATIC_UTILS=$(STATIC_UTILS) DESTDIR=$(DESTDIR) PREFIX=$(PREFIX) install
+
+uninstall:
+	cd $(DESTDIR)$(PREFIX)/$(LIBDIR)
+	rm -f $(TARGET_LIBRARIES) libgourou.so.$(VERSION)
+	cd -
+
+install_headers:
+	install -d $(DESTDIR)$(PREFIX)/$(INCDIR)/libgourou
+	cp --no-dereference include/*.h $(DESTDIR)$(PREFIX)/$(INCDIR)/libgourou
+
+uninstall_headers:
+	rm -rf $(DESTDIR)$(PREFIX)/$(INCDIR)/libgourou

 clean:
-	rm -rf libgourou.a libgourou.so obj
-	make -C utils clean
+	rm -rf libgourou.a libgourou.so libgourou.so.$(VERSION)* obj
+	$(MAKE) -C utils clean

 ultraclean: clean
 	rm -rf lib
-	make -C utils ultraclean
+	$(MAKE) -C utils ultraclean
--- a/README.md
+++ b/README.md
@ -1,45 +1,62 @@
 Introduction
 ------------

-libgourou is a free implementation of Adobe's ADEPT protocol used to add DRM on ePub files. It overcome the lacks of Adobe support for Linux platforms.
+libgourou is a free implementation of Adobe's ADEPT protocol used to add DRM on ePub/PDF files. It overcomes the lack of Adobe support for Linux platforms.


 Architecture
 ------------

-Like RMSDK, libgourou has a client/server scheme. All platform specific functions (crypto, network...) has to be implemented in a client class (that derives from DRMProcessorClient) while server implements ADEPT protocol.
-A reference implementation using Qt, OpenSSL and libzip is provided (in _utils_ directory).
+Like RMSDK, libgourou has a client/server scheme. All platform specific functions (crypto, network...) have to be implemented in a client class (that derives from DRMProcessorClient) while server implements ADEPT protocol.
+A reference implementation using cURL, OpenSSL and libzip is provided (in _utils_ directory).

-Main fucntions to use from gourou::DRMProcessor are :
+Main functions to use from gourou::DRMProcessor are:

  * Get an ePub from an ACSM file : _fulfill()_ and _download()_
  * 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) :
+You can import configuration from (at least):

  * Kobo device    : .adept/device.xml, .adept/devicesalt  and .adept/activation.xml
  * Bookeen device : .adobe-digital-editions/device.xml, root/devkey.bin and .adobe-digital-editions/activation.xml
  
-Or create a new one. Be careful : there is a limited number of devices that can be created bye one account.
+Or create a new one. Be careful: there is a limited number of devices that can be created by one account.

-ePub are encrypted using a shared key : one account / multiple devices, so you can create and register a device into your computer and read downloaded (and encrypted) ePub file with your eReader configured using the same AdobeID account.
+ePub are encrypted using a shared key: one account / multiple devices, so you can create and register a device into your computer and read downloaded (and encrypted) ePub file with your eReader configured using the same AdobeID account.
+
+For those who want to remove DRM without adept_remove, you can export your private key and import it within [Calibre](https://calibre-ebook.com/) an its DeDRM plugin.


 Dependencies
 ------------

-For libgourou :
+For libgourou:

-  * None
+_externals_ :

-For utils :
+  * libpugixml

-  * QT5Core
-  * QT5Network
-  * OpenSSL
+_internals_:
+
+  * uPDFParser
+
+For utils:
+
+  * libcurl
+  * openssl
  * libzip
+  * libpugixml
+
+
+External & utils dependencies has to be installed by your package manager (_apt_ for example).
+Use _-dev_ flavours to get needed headers.
+Internal libraries are automatically fetched and statically compiled during the first compilation.
+When you update libgourou's repository, **don't forget to update internal libraries** with:
+
+    make update_lib


 Compilation
@ -47,29 +64,78 @@ Compilation

 Use _make_ command

-    make [CROSS=XXX] [DEBUG=1] [STATIC_UTILS=1]
+    make [CROSS=XXX] [DEBUG=(0*|1)] [STATIC_UTILS=(0*|1)] [BUILD_UTILS=(0|1*)] [BUILD_STATIC=(0*|1)] [BUILD_SHARED=(0|1*)] [all*|clean|ultraclean|build_utils|install|uninstall]

 CROSS can define a cross compiler prefix (ie arm-linux-gnueabihf-)

 DEBUG can be set to compile in DEBUG mode

+BUILD_UTILS to build utils or not
+
 STATIC_UTILS to build utils with static library (libgourou.a) instead of default dynamic one (libgourou.so)

+BUILD_STATIC build libgourou.a if 1, nothing if 0, can be combined with BUILD_SHARED
+
+BUILD_SHARED build libgourou.so if 1, nothing if 0, can be combined with BUILD_STATIC
+
+other variables are DESTDIR and PREFIX to handle destination install directory
+
+* Default value
+

 Utils
 -----

-You can import configuration from your eReader or create a new one with utils/activate :
+First, add libgourou.so to your LD_LIBRARY_PATH

    export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$PWD
-    ./utils/activate -u <USERNAME>

-Then a _./.adept_ directory is created with all configuration file
+You can optionaly specify your .adept directory

-To download an ePub :
+    export ADEPT_DIR=/home/XXX

-    export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$PWD
-    ./utils/acsmdownloader -f <ACSM_FILE>
+Then, use utils as following:
+
+You can import configuration from your eReader or create a new one with _utils/adept\_activate_:
+
+    ./utils/adept_activate -u <AdobeID USERNAME>
+
+Then a _/home/<user>/.config/adept_ directory is created with all configuration file
+
+To download an ePub/PDF:
+
+    ./utils/acsmdownloader <ACSM_FILE>
+
+To export your private key (for DeDRM software):
+
+    ./utils/acsmdownloader --export-private-key [-o adobekey_1.der]
+
+To remove ADEPT DRM:
+
+    ./utils/adept_remove <encryptedFile>
+
+To list loaned books:
+
+    ./utils/adept_loan_mgt [-l]
+
+To return a loaned book:
+
+    ./utils/adept_loan_mgt -r <id>
+
+
+You can get utils full options description with -h or --help switch
+
+
+Binary packages
+---------------
+
+Compiled version (and AppImage) of libgourou and utils are available in [Release page](https://forge.soutade.fr/soutade/libgourou/releases)
+
+
+Docker
+------
+
+A docker image (by bcliang) is available at [https://github.com/bcliang/docker-libgourou/](https://github.com/bcliang/docker-libgourou/)


 Copyright
@ -78,10 +144,32 @@ Copyright
 Grégory Soutadé


-
 License
 -------

 libgourou : LGPL v3 or later

 utils     : BSD
+
+
+Special thanks
+--------------
+
+  * _Jens_ for all test samples and utils testing
+  * _Milian_ for debug & code
+  * _Berwyn H_ for all test samples, feedbacks, patches and kind donation
+
+
+Donation
+--------
+
+https://www.paypal.com/donate/?hosted_button_id=JD3U6XMZCPHKN
+
+
+Donators
+--------
+
+  * _Berwyn H_
+  * _bwitt_
+  * _Ismail_
+  * _Radon_
--- a/include/Base64.h
+++ b/include/Base64.h
@ -0,0 +1,133 @@
+#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>
+#include <stdint.h>
+
+namespace macaron {
+
+    class Base64 {
+    public:
+
+        static std::string Encode(const std::string data) {
+            static
+#if __STDC_VERSION__ >= 201112L
+                constexpr
+#endif /* __STDC_VERSION__ >= 201112L */
+                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
+#if __STDC_VERSION__ >= 201112L
+                constexpr
+#endif /* __STDC_VERSION__ >= 201112L */
+                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_ */
--- a/include/bytearray.h
+++ b/include/bytearray.h
@ -32,6 +32,7 @@ namespace gourou
     *
     * Data handled is first copied in a newly allocated buffer
     * and then shared between all copies until last object is destroyed
+     * (internal reference counter == 0)
     */
    class ByteArray
    {
@ -39,8 +40,18 @@ namespace gourou

        /**
         * @brief Create an empty byte array
+         *
+         * @param useMalloc If true, use malloc() instead of new[] for allocation
         */
-	ByteArray();
+        ByteArray(bool useMalloc=false);
+
+        /**
+         * @brief Create an empty byte array of length bytes
+         *
+         * @param length  Length of data
+         * @param useMalloc If true, use malloc() instead of new[] for allocation
+         */
+        ByteArray(unsigned int length, bool useMalloc=false);

        /**
         * @brief Initialize ByteArray with a copy of data
@ -93,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
         */
@ -119,14 +137,38 @@ namespace gourou
        void append(const std::string& str);

        /**
-	 * @brief Get internal data. Must bot be modified nor freed
+         * @brief Get internal data. Must not be freed
         */
-	const unsigned char* data() {return _data;}
+        unsigned char* data() {return _data;}
+
+        /**
+         * @brief Get internal data and increment internal reference counter.
+         * Must bot be freed
+         */
+        unsigned char* takeShadowData() {addRef() ; return _data;}
+
+        /**
+         * @brief Release shadow data. It can now be freed by ByteArray
+         */
+        void releaseShadowData() {delRef();}

        /**
         * @brief Get internal data length
         */
-	unsigned int length() {return _length;}
+        unsigned int length() const {return _length;}
+
+        /**
+         * @brief Get internal data length
+         */
+        unsigned int size() const {return length();}
+
+        /**
+         * @brief Increase or decrease internal buffer
+         * @param length New length of internal buffer
+         * @param keepData If true copy old data on new buffer, if false,
+         * create a new buffer with random data
+         */
+        void resize(unsigned int length, bool keepData=true);

        ByteArray& operator=(const ByteArray& other);

@ -135,9 +177,10 @@ namespace gourou
        void addRef();
        void delRef();

-	const unsigned char* _data;
+        bool _useMalloc;
+        unsigned char* _data;
        unsigned int _length;
-	static std::map<const unsigned char*, int> refCounter;
+        static std::map<unsigned char*, int> refCounter;
    };
 }
 #endif
--- a/include/device.h
+++ b/include/device.h
@ -48,7 +48,7 @@ namespace gourou
        const unsigned char* getDeviceKey();

        /**
-	 * @brief Get one value of device.xml (deviceClass, deviceSerial, deviceName, deviceType, jobbes, clientOS, clientLocale)
+         * @brief Get one value of device.xml (deviceClass, deviceSerial, deviceName, deviceType, hobbes, clientOS, clientLocale)
         */
        std::string getProperty(const std::string& property, const std::string& _default=std::string(""));
        std::string operator[](const std::string& property);
--- a/include/drmprocessorclient.h
+++ b/include/drmprocessorclient.h
@ -21,6 +21,7 @@
 #define _DRMPROCESSORCLIENT_H_

 #include <string>
+#include <bytearray.h>

 namespace gourou
 {
@ -34,7 +35,7 @@ namespace gourou
    {
    public:
        /**
-	 * @brief Create a digest handler (for now only SHA1 is used)
+         * @brief Create a digest handler
         *
         * @param digestName      Digest name to instanciate
         */
@ -46,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
@ -68,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
@ -96,8 +91,13 @@ namespace gourou
         * @param URL             HTTP URL
         * @param POSTData        POST data if needed, if not set, a GET request is done
         * @param contentType     Optional content type of POST Data
+         * @param responseHeaders Optional Response headers of HTTP request
+         * @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("")) = 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
@ -105,6 +105,7 @@ namespace gourou
    public:
        enum RSA_KEY_TYPE {
            RSA_KEY_PKCS12 = 0,
+            RSA_KEY_PKCS8,
            RSA_KEY_X509
        };

@ -124,6 +125,22 @@ namespace gourou
                                       const unsigned char* data, unsigned dataLength,
                                       unsigned char* res) = 0;

+        /**
+         * @brief Decrypt data with RSA private key. Data is padded using PKCS1.5
+         *
+         * @param RSAKey         RSA key in binary form
+         * @param RSAKeyLength   RSA key length
+         * @param keyType        Key type
+         * @param password       Optional password for RSA PKCS12 certificate
+         * @param data           Data to encrypt
+         * @param dataLength     Data length
+         * @param res            Encryption result (pre allocated buffer)
+         */
+        virtual void RSAPrivateDecrypt(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) = 0;
+
        /**
         * @brief Encrypt data with RSA public key. Data is padded using PKCS1.5
         *
@ -173,19 +190,39 @@ namespace gourou
         * @param keyOutLength   Length of result
         */
        virtual void extractRSAPrivateKey(void* handler, unsigned char** keyOut, unsigned int* keyOutLength) = 0;
+
+        /**
+         * @brief Extract certificate from PKCS12 blob
+         *
+         * @param RSAKey         RSA key in binary form
+         * @param RSAKeyLength   RSA key length
+         * @param keyType        Key type
+         * @param password       Optional password for RSA PKCS12 certificate
+         * @param certOut        Result certificate
+         * @param certOutLength  Result certificate length
+         */
+        virtual void extractCertificate(const unsigned char* RSAKey, unsigned int RSAKeyLength,
+                                        const RSA_KEY_TYPE keyType, const std::string& password,
+                                        unsigned char** certOut, unsigned int* certOutLength) = 0;
    };

    class CryptoInterface
    {
    public:
+        enum CRYPTO_ALGO {
+            ALGO_AES=0,
+            ALGO_RC4
+        };
+
        enum CHAINING_MODE {
            CHAIN_ECB=0,
            CHAIN_CBC
        };

        /**
-	 * @brief Do AES encryption. If length of data is not multiple of 16, PKCS#5 padding is done
+         * @brief Do encryption. If length of data is not multiple of block size, PKCS#5 padding is done
         *
+         * @param algo           Algorithm to use
         * @param chaining       Chaining mode
         * @param key            AES key
         * @param keyLength      AES key length
@ -196,52 +233,53 @@ namespace gourou
         * @param dataOut        Encrypted data
         * @param dataOutLength  Length of encrypted data
         */
-	virtual void AESEncrypt(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) = 0;

        /**
-	 * @brief Init AES CBC encryption
+         * @brief Init encryption
         *
         * @param chaining       Chaining mode
-	 * @param key            AES key
-	 * @param keyLength      AES key length
-	 * @param iv             IV key
-	 * @param ivLength       IV key length
+         * @param key            Key
+         * @param keyLength      Key length
+         * @param iv             Optional IV key
+         * @param ivLength       Optional IV key length
         *
         * @return AES handler
         */
-	virtual void* AESEncryptInit(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;

        /**
         * @brief Encrypt data
         *
-	 * @param handler        AES handler
+         * @param handler        Crypto handler
         * @param dataIn         Data to encrypt
         * @param dataInLength   Data length
         * @param dataOut        Encrypted data
         * @param dataOutLength  Length of encrypted data
         */
-	virtual void AESEncryptUpdate(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;

        /**
-	 * @brief Finalize AES encryption (pad and encrypt last block if needed)
+         * @brief Finalize encryption (pad and encrypt last block if needed)
         * Destroy handler at the end
         *
-	 * @param handler        AES handler
+         * @param handler        Crypto handler
         * @param dataOut        Last block of encrypted data
         * @param dataOutLength  Length of encrypted data
         */
-	virtual void AESEncryptFinalize(void* handler, unsigned char* dataOut, unsigned int* dataOutLength) = 0;
+        virtual void encryptFinalize(void* handler, unsigned char* dataOut, unsigned int* dataOutLength) = 0;

        /**
-	 * @brief Do AES decryption. If length of data is not multiple of 16, PKCS#5 padding is done
+         * @brief Do decryption. If length of data is not multiple of block size, PKCS#5 padding is done
         *
+         * @param algo           Algorithm to use
         * @param chaining       Chaining mode
         * @param key            AES key
         * @param keyLength      AES key length
@ -252,47 +290,47 @@ namespace gourou
         * @param dataOut        Encrypted data
         * @param dataOutLength  Length of encrypted data
         */
-	virtual void AESDecrypt(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) = 0;

        /**
-	 * @brief Init AES decryption
+         * @brief Init decryption
         *
         * @param chaining       Chaining mode
-	 * @param key            AES key
-	 * @param keyLength      AES key length
+         * @param key            Key
+         * @param keyLength      Key length
         * @param iv             IV key
         * @param ivLength       IV key length
         *
         * @return AES handler
         */
-	virtual void* AESDecryptInit(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;

        /**
         * @brief Decrypt data
         *
-	 * @param handler        AES handler
+         * @param handler        Crypto handler
         * @param dataIn         Data to decrypt
         * @param dataInLength   Data length
         * @param dataOut        Decrypted data
         * @param dataOutLength  Length of decrypted data
         */
-	virtual void AESDecryptUpdate(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 AES decryption (decrypt last block and remove padding if it is set).
+         * @brief Finalize decryption (decrypt last block and remove padding if it is set).
         * Destroy handler at the end
         *
-	 * @param handler        AES handler
+         * @param handler        Crypto handler
         * @param dataOut        Last block decrypted data
         * @param dataOutLength  Length of decrypted data
         */
-	virtual void AESDecryptFinalize(void* handler, unsigned char* dataOut, unsigned int* dataOutLength) = 0;
+        virtual void decryptFinalize(void* handler, unsigned char* dataOut, unsigned int* dataOutLength) = 0;
    };


@ -313,19 +351,19 @@ namespace gourou
         *
         * @param handler        ZIP file handler
         * @param path           Internal path inside zip file
-	 *
-	 * @return File content
+         * @param result         Result buffer
+         * @param decompress     If false, don't decompress read data
         */
-	virtual std::string zipReadFile(void* handler, const std::string& path) = 0;
+        virtual void zipReadFile(void* handler, const std::string& path, ByteArray& result, bool decompress=true) = 0;

        /**
         * @brief Write zip internal file
         *
         * @param handler        ZIP file handler
         * @param path           Internal path inside zip file
-	 * @param content        Internal file content
+         * @param content        File content
         */
-	virtual void zipWriteFile(void* handler, const std::string& path, const std::string& content) = 0;
+        virtual void zipWriteFile(void* handler, const std::string& path, ByteArray& content) = 0;

        /**
         * @brief Delete zip internal file
@ -341,6 +379,27 @@ namespace gourou
         * @param handler        ZIP file handler
         */
        virtual void zipClose(void* handler) = 0;
+
+        /**
+         * @brief Inflate algorithm
+         *
+         * @param data           Data to inflate
+         * @param result         Zipped data
+         * @param wbits          Window bits value for libz
+         */
+        virtual void inflate(gourou::ByteArray& data, gourou::ByteArray& result,
+                             int wbits=-15) = 0;
+
+        /**
+         * @brief Deflate algorithm
+         *
+         * @param data           Data to deflate
+         * @param result         Unzipped data
+         * @param wbits          Window bits value for libz
+         * @param compressionLevel Compression level for libz
+         */
+        virtual void deflate(gourou::ByteArray& data, gourou::ByteArray& result,
+                             int wbits=-15, int compressionLevel=8) = 0;
    };

    class DRMProcessorClient: public DigestInterface, public RandomInterface, public HTTPInterface, \
--- a/include/fulfillment_item.h
+++ b/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>

@ -34,8 +34,16 @@ namespace gourou
    class FulfillmentItem
    {
    public:
+        /**
+         * @brief Main constructor. Not to be called by user
+         *
+         * @param doc   Fulfill reply
+         * @param user  User pointer
+         */
        FulfillmentItem(pugi::xml_document& doc, User* user);

+        ~FulfillmentItem();
+
        /**
         * @brief Return metadata value from ACSM metadata section
         *
@ -53,10 +61,23 @@ namespace gourou
         */
        std::string getDownloadURL();

+        /**
+         * @brief Return resource value
+         */
+        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);
    };
--- a/include/libgourou.h
+++ b/include/libgourou.h
@ -27,20 +27,17 @@
 #include "drmprocessorclient.h"

 #include <pugixml.hpp>
+#include <stdint.h>

 #ifndef HOBBES_DEFAULT_VERSION
 #define HOBBES_DEFAULT_VERSION  "10.0.4"
 #endif

-#ifndef DEFAULT_ADEPT_DIR
-#define DEFAULT_ADEPT_DIR       "./.adept"
-#endif
-
 #ifndef ACS_SERVER
 #define ACS_SERVER              "http://adeactivate.adobe.com/adept"
 #endif

-#define LIBGOUROU_VERSION       "0.1"
+#define LIBGOUROU_VERSION       "0.8.8"

 namespace gourou
 {
@ -53,6 +50,7 @@ namespace gourou

        static const std::string VERSION;

+        enum ITEM_TYPE { EPUB=0, PDF };
        /**
         * @brief Main constructor. To be used once all is configured (user has signedIn, device is activated)
         *
@ -69,10 +67,11 @@ namespace gourou
         * @brief Fulfill ACSM file to server in order to retrieve ePub fulfillment item
         *
         * @param ACSMFile       Path of ACSMFile
+         * @param notify         Notify server if requested by response
         *
         * @return a FulfillmentItem if all is OK
         */
-	FulfillmentItem* fulfill(const std::string& ACSMFile);
+        FulfillmentItem* fulfill(const std::string& ACSMFile, bool notify=true);

        /**
         * @brief Once fulfilled, ePub file needs to be downloaded.
@ -80,8 +79,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
         */
-	void 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)
@ -96,6 +98,20 @@ 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
+         * @param notify          Notify server if requested by response
+         */
+        void returnLoan(const std::string& loanID, const std::string& operatorURL, bool notify=true);
+
+        /**
+         * @brief Return default ADEPT directory (ie /home/<user>/.config/adept)
+         */
+        static std::string getDefaultAdeptDir(void);
+
        /**
         * @brief Create a new ADEPT environment (device.xml, devicesalt and activation.xml).
         *
@ -106,7 +122,7 @@ namespace gourou
         * @param ACSServer       Override main ACS server (default adeactivate.adobe.com)
         */
        static DRMProcessor* createDRMProcessor(DRMProcessorClient* client,
-						bool randomSerial=false, const std::string& dirName=std::string(DEFAULT_ADEPT_DIR),
+                                                bool randomSerial=false, std::string dirName=std::string(""),
                                                const std::string& hobbes=std::string(HOBBES_DEFAULT_VERSION),
                                                const std::string& ACSServer=ACS_SERVER);

@ -130,8 +146,13 @@ namespace gourou
         * @param URL             HTTP URL
         * @param POSTData        POST data if needed, if not set, a GET request is done
         * @param contentType     Optional content type of POST Data
+         * @param responseHeaders Optional Response headers of HTTP request
+         * @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);
+        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
@ -158,6 +179,11 @@ namespace gourou
         */
        std::string serializeRSAPrivateKey(void* rsa);

+        /**
+         * @brief Export clear private license key into path
+         */
+        void exportPrivateLicenseKey(std::string path);
+
        /**
         * @brief Get current user
         */
@ -173,6 +199,18 @@ namespace gourou
         */
        DRMProcessorClient* getClient() { return client; }

+        /**
+         * @brief Remove ADEPT DRM
+         * Warning: for PDF format, filenameIn must be different than filenameOut
+         *
+         * @param filenameIn         Input file (with ADEPT DRM)
+         * @param filenameOut        Output file (without ADEPT DRM)
+         * @param type               Type of file (ePub or PDF)
+         * @param encryptionKey      Optional encryption key, do not try to decrypt the one inside input file
+         * @param encryptionKeySize  Size of encryption key (if provided)
+         */
+        void removeDRM(const std::string& filenameIn, const std::string& filenameOut, ITEM_TYPE type, const unsigned char* encryptionKey=0, unsigned encryptionKeySize=0);
+
    private:
        gourou::DRMProcessorClient* client;
        gourou::Device* device;
@ -184,10 +222,30 @@ 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);
+        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);
+        void doOperatorAuth(std::string operatorURL);
+        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);
+        void buildNotifyReq(pugi::xml_document& returnReq, pugi::xml_node& body);
+        void notifyServer(pugi::xml_node& notifyRoot);
+        void notifyServer(pugi::xml_document& fulfillReply);
+        std::string encryptedKeyFirstPass(pugi::xml_document& rightsDoc, const std::string& encryptedKey, const std::string& keyType);
+        void decryptADEPTKey(pugi::xml_document& rightsDoc, unsigned char* decryptedKey, const unsigned char* encryptionKey=0, unsigned encryptionKeySize=0);
+        void removeEPubDRM(const std::string& filenameIn, const std::string& filenameOut, const unsigned char* encryptionKey, unsigned encryptionKeySize);
+        void generatePDFObjectKey(int version,
+                                  const unsigned char* masterKey, unsigned int masterKeyLength,
+                                  int objectId, int objectGenerationNumber,
+                                  unsigned char* keyOut);
+        void removePDFDRM(const std::string& filenameIn, const std::string& filenameOut, const unsigned char* encryptionKey, unsigned encryptionKeySize);
    };
 }

--- a/include/libgourou_common.h
+++ b/include/libgourou_common.h
@ -44,7 +44,7 @@ namespace gourou
     * Some common utilities
     */

-    #define ADOBE_ADEPT_NS  "http://ns.adobe.com/adept"
+#define ADOBE_ADEPT_NS  "http://ns.adobe.com/adept"

    static const int SHA1_LEN           = 20;
    static const int RSA_KEY_SIZE       = 128;
@ -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 {
@ -63,11 +64,13 @@ namespace gourou
        FF_INVALID_ACSM_FILE,
        FF_NO_HMAC_IN_ACSM_FILE,
        FF_NOT_ACTIVATED,
-	FF_NO_OPERATOR_URL
+        FF_NO_OPERATOR_URL,
+        FF_SERVER_INTERNAL_ERROR
    };

    enum DOWNLOAD_ERROR {
        DW_NO_ITEM = 0x1200,
+        DW_NO_EBX_HANDLER,
    };

    enum SIGNIN_ERROR {
@ -91,10 +94,12 @@ namespace gourou
        USER_INVALID_ACTIVATION_FILE,
        USER_NO_AUTHENTICATION_URL,
        USER_NO_PROPERTY,
+        USER_INVALID_INPUT,
    };

    enum FULFILL_ITEM_ERROR {
-	FFI_INVALID_FULFILLMENT_DATA = 0x4000
+        FFI_INVALID_FULFILLMENT_DATA = 0x4000,
+        FFI_INVALID_LOAN_TOKEN
    };

    enum CLIENT_ERROR {
@ -102,15 +107,44 @@ 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,
        CLIENT_BAD_ZIP_FILE,
        CLIENT_ZIP_ERROR,
-	CLIENT_GENERIC_EXCEPTION
-	
+        CLIENT_GENERIC_EXCEPTION,
+        CLIENT_NETWORK_ERROR,
+        CLIENT_INVALID_PKCS8,
+        CLIENT_FILE_ERROR,
+        CLIENT_OSSL_ERROR,
+        CLIENT_CRYPT_ERROR,
+        CLIENT_DIGEST_ERROR,
+        CLIENT_HTTP_ERROR
    };

+    enum DRM_REMOVAL_ERROR {
+        DRM_ERR_ENCRYPTION_KEY = 0x6000,
+        DRM_VERSION_NOT_SUPPORTED,
+        DRM_FILE_ERROR,
+        DRM_FORMAT_NOT_SUPPORTED,
+        DRM_IN_OUT_EQUALS,
+        DRM_MISSING_PARAMETER,
+        DRM_INVALID_KEY_SIZE,
+        DRM_ERR_ENCRYPTION_KEY_FP,
+        DRM_INVALID_USER
+    };
+
+#ifndef _NOEXCEPT
+#if __STDC_VERSION__ >= 201112L
+#  define _NOEXCEPT noexcept
+#  define _NOEXCEPT_(x) noexcept(x)
+#else
+#  define _NOEXCEPT throw()
+#  define _NOEXCEPT_(x)
+#endif
+#endif /* !_NOEXCEPT */
+
    /**
     * Generic exception class
     */
@ -123,12 +157,20 @@ 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());
        }

-	~Exception()
+        Exception(const Exception& other)
+        {
+            this->code = other.code;
+            this->line = other.line;
+            this->file = other.file;
+            this->fullmessage = strdup(other.fullmessage);
+        }
+
+        ~Exception() _NOEXCEPT
        {
            free(fullmessage);
        }
@ -139,7 +181,7 @@ namespace gourou

    private:
        int code, line;
-	const char* message, *file;
+        const char* file;
        char* fullmessage;
    };

@ -194,24 +236,32 @@ namespace gourou
        return ltrim(rtrim(s, t), t);
    }

-    /**
-     * @brief Extract text node from tag in document
-     * 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 pugi::xml_node getNode(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)
        {
            if (throwOnNull)
                EXCEPTION(GOUROU_TAG_NOT_FOUND, "Tag " << tagName << " not found");

-            return "";
+            return pugi::xml_node();
        }

-	pugi::xml_node node = xpath_node.node().first_child();
+        return xpath_node.node();
+
+    }
+
+    /**
+     * @brief Extract text node from tag in document
+     * It can throw an exception if tag does not exists
+     * or just return an empty value
+     */
+    static inline std::string extractTextElem(const pugi::xml_node& root, const char* tagName, bool throwOnNull=true)
+    {
+        pugi::xml_node node = getNode(root, tagName, throwOnNull);
+
+        node = node.first_child();

        if (!node)
        {
@ -225,6 +275,53 @@ namespace gourou
        return trim(res);
    }

+    /**
+     * @brief Set text node of a tag in document
+     * It can throw an exception if tag does not exists
+     */
+    static inline void setTextElem(const pugi::xml_node& root, const char* tagName,
+                                   const std::string& value, bool throwOnNull=true)
+    {
+        pugi::xml_node node = getNode(root, tagName, throwOnNull);
+
+        if (!node)
+        {
+            if (throwOnNull)
+                EXCEPTION(GOUROU_TAG_NOT_FOUND, "Text element for tag " << tagName << " not found");
+            return;
+        }
+
+        node = node.first_child();
+
+        if (!node)
+            node.append_child(pugi::node_pcdata).set_value(value.c_str());
+        else
+            node.set_value(value.c_str());
+    }
+
+    /**
+     * @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::xml_node node = getNode(root, tagName, throwOnNull);
+
+        pugi::xml_attribute attr = node.attribute(attributeName);
+
+        if (!attr)
+        {
+            if (throwOnNull)
+                EXCEPTION(GOUROU_TAG_NOT_FOUND, "Attribute element " << attributeName << " for tag " << tagName << " not found");
+
+            return "";
+        }
+
+        std::string res = attr.value();
+        return trim(res);
+    }
+
    /**
     * @brief Append an element to root with a sub text element
     *
@ -238,15 +335,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);
@ -345,6 +483,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
--- a/include/libgourou_log.h
+++ b/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__)

    /**
--- a/include/loan_token.h
+++ b/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
--- a/include/user.h
+++ b/include/user.h
@ -21,6 +21,8 @@
 #define _USER_H_

 #include <string>
+#include <map>
+
 #include "bytearray.h"

 #include <pugixml.hpp>
@ -46,7 +48,7 @@ namespace gourou
        std::string& getDeviceFingerprint();
        std::string& getUsername();
        std::string& getLoginMethod();
-	std::string& getCertificate();
+        std::string  getLicenseServiceCertificate(std::string url);
        std::string& getAuthenticationCertificate();
        std::string& getPrivateLicenseKey();

@ -70,6 +72,11 @@ namespace gourou
         */
        std::string getProperty(const std::string property);

+        /**
+         * @brief Get all nodes with property name
+         */
+        pugi::xpath_node_set getProperties(const std::string property);
+
        /**
         * @brief Create activation.xml and devicesalt files if they did not exists
         *
@ -90,7 +97,7 @@ namespace gourou
        std::string deviceFingerprint;
        std::string username;
        std::string loginMethod;
-	std::string certificate;
+        std::map<std::string,std::string> licenseServiceCertificates;
        std::string authenticationCertificate;
        std::string privateLicenseKey;

--- a/scripts/setup.sh
+++ b/scripts/setup.sh
@ -1,10 +1,9 @@
 #!/bin/bash

-# Pugixml
-git clone https://github.com/zeux/pugixml.git lib/pugixml
-pushd lib/pugixml
-git checkout latest
-popd
-
-# Base64
-git clone https://gist.github.com/f0fd86b6c73063283afe550bc5d77594.git lib/base64
+# uPDFParser
+if [ ! -d lib/updfparser ] ; then
+    git clone https://forge.soutade.fr/soutade/uPDFParser.git lib/updfparser
+    pushd lib/updfparser
+    make BUILD_STATIC=1 BUILD_SHARED=0
+    popd
+fi
--- a/scripts/update_lib.sh
+++ b/scripts/update_lib.sh
@ -0,0 +1,13 @@
+#!/bin/bash
+
+if [ ! -d lib/updfparser ] ; then
+    echo "Some libraries are missing"
+    echo "You must run this script at the top of libgourou working direcotry."
+    echo "./scripts/setup.sh must be called first (make all)"
+    exit 1
+fi
+
+# uPDFParser
+pushd lib/updfparser
+git pull origin master
+make clean all BUILD_STATIC=1 BUILD_SHARED=0
--- a/src/bytearray.cpp
+++ b/src/bytearray.cpp
@ -17,40 +17,56 @@
  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>

 namespace gourou
 {
-    std::map<const unsigned char*, int> ByteArray::refCounter;
+    std::map<unsigned char*, int> ByteArray::refCounter;

-    ByteArray::ByteArray():_data(0), _length(0)
+    ByteArray::ByteArray(bool useMalloc):_useMalloc(useMalloc), _data(0), _length(0)
    {}

-    ByteArray::ByteArray(const unsigned char* data, unsigned int length)
+    ByteArray::ByteArray(unsigned int length, bool useMalloc):
+        _useMalloc(useMalloc)
+    {
+        initData(0, length);
+    }
+
+    ByteArray::ByteArray(const unsigned char* data, unsigned int length):
+        _useMalloc(false)
    {
        initData(data, length);
    }

-    ByteArray::ByteArray(const char* data, int length)
+    ByteArray::ByteArray(const char* data, int length):
+        _useMalloc(false)
    {
        if (length == -1)
-	    length = strlen(data) + 1;
+            length = strlen(data);

-	initData((const unsigned char*)data, (unsigned int) length);
+        initData((unsigned char*)data, (unsigned int) length);
    }

-    ByteArray::ByteArray(const std::string& str)
+    ByteArray::ByteArray(const std::string& str):
+        _useMalloc(false)
    {
-	initData((unsigned char*)str.c_str(), (unsigned int)str.length() + 1);
+        initData((unsigned char*)str.c_str(), (unsigned int)str.length());
    }

    void ByteArray::initData(const unsigned char* data, unsigned int length)
    {
+        if (_useMalloc)
+            _data = (unsigned char*)malloc(length);
+        else
            _data = new unsigned char[length];
+
+        if (data)
            memcpy((void*)_data, data, length);
+
        _length = length;

        addRef();
@ -58,6 +74,7 @@ namespace gourou

    ByteArray::ByteArray(const ByteArray& other)
    {
+        this->_useMalloc = other._useMalloc;
        this->_data = other._data;
        this->_length = other._length;

@ -68,6 +85,7 @@ namespace gourou
    {
        delRef();

+        this->_useMalloc = other._useMalloc;
        this->_data = other._data;
        this->_length = other._length;

@ -97,6 +115,9 @@ namespace gourou

        if (refCounter[_data] == 1)
        {
+            if (_useMalloc)
+                free(_data);
+            else
                delete[] _data;
            refCounter.erase(_data);
        }
@ -135,12 +156,53 @@ 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];

        for(int i=0; i<(int)_length; i++)
-	    sprintf(&tmp[i*2], "%02x", _data[i]);
+            snprintf(&tmp[i*2], (_length-i)*2+1, "%02x", _data[i]);

        tmp[_length*2] = 0;

@ -152,22 +214,44 @@ namespace gourou

    void ByteArray::append(const unsigned char* data, unsigned int length)
    {
-	const unsigned char* oldData = _data;
-	unsigned char* newData = new unsigned char[_length+length];
+        if (!length)
+            return;

-	memcpy(newData, oldData, _length);
+        unsigned int oldLength = _length;

-	delRef();
+        resize(_length+length, true);

-	memcpy(&newData[_length], data, length);
-	_length += length;
-	
-	_data = newData;
-	
-	addRef();
+        memcpy(&_data[oldLength], data, length);
    }

    void ByteArray::append(unsigned char c) { append(&c, 1);}
    void ByteArray::append(const char* str) { append((const unsigned char*)str, strlen(str));}
    void ByteArray::append(const std::string& str) { append((const unsigned char*)str.c_str(), str.length()); }
+
+    void ByteArray::resize(unsigned length, bool keepData)
+    {
+        if (length == _length)
+            return;
+        else if (length < _length)
+            _length = length ; // Don't touch data
+        else // New size >
+        {
+            unsigned char* newData;
+
+            if (_useMalloc)
+                newData = (unsigned char*)malloc(_length+length);
+            else
+                newData = new unsigned char[_length+length];
+
+            if (keepData)
+                memcpy(newData, _data, _length);
+
+            delRef();
+
+            _length = length;
+            _data = newData;
+
+            addRef();
+        }
+    }
 }
--- a/src/device.cpp
+++ b/src/device.cpp
@ -29,13 +29,23 @@
 #include <libgourou_log.h>
 #include <device.h>

-// From https://stackoverflow.com/questions/1779715/how-to-get-mac-address-of-your-machine-using-a-c-program/35242525
+#include <string.h>
+#if defined(__linux__) || defined(linux) || defined(__linux)
 #include <sys/ioctl.h>
 #include <net/if.h>
 #include <unistd.h>
 #include <netinet/in.h>
-#include <string.h>
+#elif (defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) \
+       || defined(__bsdi__) || defined(__DragonFly__) || defined(__APPLE__))
+#include <ifaddrs.h>
+#include <sys/socket.h>
+#include <net/if_dl.h>

+#define BSD_HEADERS 1
+#endif
+
+#if defined(__linux__) || defined(linux) || defined(__linux)
+// From https://stackoverflow.com/questions/1779715/how-to-get-mac-address-of-your-machine-using-a-c-program/35242525
 int get_mac_address(unsigned char* mac_address)
 {
    struct ifreq ifr;
@ -74,6 +84,43 @@ int get_mac_address(unsigned char* mac_address)

    return 1;
 }
+#elif BSD_HEADERS
+// https://stackoverflow.com/a/3978293
+int get_mac_address(unsigned char* mac_address, const char* if_name = "en0")
+{
+    ifaddrs* iflist;
+    int found = 0;
+    if (getifaddrs(&iflist) == 0) {
+        for (ifaddrs* cur = iflist; cur; cur = cur->ifa_next) {
+            if ((cur->ifa_addr->sa_family == AF_LINK) &&
+                (strcmp(cur->ifa_name, if_name) == 0) &&
+                cur->ifa_addr) {
+                sockaddr_dl* sdl = (sockaddr_dl*)cur->ifa_addr;
+                memcpy(mac_address, LLADDR(sdl), sdl->sdl_alen);
+                found = 1;
+                break;
+            }
+        }
+
+        freeifaddrs(iflist);
+    }
+    return found;
+}
+#else
+int get_mac_address(unsigned char* mac_address)
+{
+    GOUROU_LOG(INFO, "get_mac_address() not implemented for your platform, using a static address");
+
+    mac_address[0] = 0x8D;
+    mac_address[1] = 0x70;
+    mac_address[2] = 0x13;
+    mac_address[3] = 0x8D;
+    mac_address[4] = 0x43;
+    mac_address[5] = 0x27;
+
+    return 1;
+}
+#endif /* defined(__linux__) || defined(linux) || defined(__linux) */


 namespace gourou
--- a/src/fulfillment_item.cpp
+++ b/src/fulfillment_item.cpp
@ -17,6 +17,7 @@
  along with libgourou. If not, see <http://www.gnu.org/licenses/>.
 */

+#include <cctype>
 #include <fulfillment_item.h>
 #include <libgourou_common.h>
 #include "user.h"
@ -24,8 +25,10 @@
 namespace gourou
 {
    FulfillmentItem::FulfillmentItem(pugi::xml_document& doc, User* user)
+        : fulfillDoc(), loanToken(0)
    {
-	metadatas = doc.select_node("//metadata").node();
+        fulfillDoc.reset(doc); /* We must keep a copy */
+        metadatas = fulfillDoc.select_node("//metadata").node();

        if (!metadatas)
            EXCEPTION(FFI_INVALID_FULFILLMENT_DATA, "No metadata tag in document");
@ -36,12 +39,35 @@ namespace gourou
        if (downloadURL == "")
            EXCEPTION(FFI_INVALID_FULFILLMENT_DATA, "No download URL in document");

+        node = doc.select_node("/envelope/fulfillmentResult/resourceItemInfo/resource").node();
+        resource = node.first_child().value();
+
+        if (resource == "")
+            EXCEPTION(FFI_INVALID_FULFILLMENT_DATA, "No resource in document");
+
        pugi::xml_node licenseToken = doc.select_node("/envelope/fulfillmentResult/resourceItemInfo/licenseToken").node();

        if (!licenseToken)
            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)
@ -56,18 +82,24 @@ namespace gourou
        if (!newLicenseToken.attribute("xmlns"))
            newLicenseToken.append_attribute("xmlns") = ADOBE_ADEPT_NS;

-	pugi::xml_node licenseServiceInfo = root.append_child("licenseServiceInfo");
-	licenseServiceInfo.append_attribute("xmlns") = ADOBE_ADEPT_NS;
-	licenseServiceInfo.append_copy(licenseToken.select_node("licenseURL").node());
-	pugi::xml_node certificate = licenseServiceInfo.append_child("certificate");
-	certificate.append_child(pugi::node_pcdata).set_value(user->getCertificate().c_str());
+        pugi::xml_node licenseServiceInfo = root.append_child("adept:licenseServiceInfo");
+        pugi::xml_node licenseURL = licenseToken.select_node("licenseURL").node();
+        licenseURL.set_name("adept:licenseURL");
+        licenseServiceInfo.append_copy(licenseURL);
+        pugi::xml_node certificate = licenseServiceInfo.append_child("adept:certificate");
+        std::string certificateValue = user->getLicenseServiceCertificate(licenseURL.first_child().value());
+        certificate.append_child(pugi::node_pcdata).set_value(certificateValue.c_str());
    }

    std::string FulfillmentItem::getMetadata(std::string name)
    {
        // https://stackoverflow.com/questions/313970/how-to-convert-an-instance-of-stdstring-to-lower-case
+#if __STDC_VERSION__ >= 201112L
        std::transform(name.begin(), name.end(), name.begin(),
                       [](unsigned char c){ return std::tolower(c); });
+#else
+        std::transform(name.begin(), name.end(), name.begin(), tolower);
+#endif
        name = std::string("dc:") + name;
        pugi::xpath_node path = metadatas.select_node(name.c_str());

@ -88,4 +120,14 @@ namespace gourou
    {
        return downloadURL;
    }
+
+    std::string FulfillmentItem::getResource()
+    {
+        return resource;
+    }
+
+    LoanToken* FulfillmentItem::getLoanToken()
+    {
+        return loanToken;
+    }
 }
--- a/src/libgourou.cpp
+++ b/src/libgourou.cpp
--- a/src/loan_token.cpp
+++ b/src/loan_token.cpp
@ -0,0 +1,80 @@
+/*
+  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/fulfillmentResult/fulfillment").node();
+
+        if (node)
+            properties["id"] = node.first_child().value();
+        else
+        {
+            EXCEPTION(FFI_INVALID_LOAN_TOKEN, "No fulfillment 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);
+    }
+}
--- a/src/pugixml.cpp
+++ b/src/pugixml.cpp
@ -1 +0,0 @@
-../lib/pugixml/src/pugixml.cpp
--- a/src/user.cpp
+++ b/src/user.cpp
@ -48,10 +48,8 @@ namespace gourou {
            uuid        = gourou::extractTextElem(activationDoc, "//adept:user", throwOnNull);
            deviceUUID  = gourou::extractTextElem(activationDoc, "//device", throwOnNull);
            deviceFingerprint = gourou::extractTextElem(activationDoc, "//fingerprint", throwOnNull);
-	    certificate = gourou::extractTextElem(activationDoc, "//adept:certificate", throwOnNull);
            authenticationCertificate = gourou::extractTextElem(activationDoc, "//adept:authenticationCertificate", throwOnNull);
            privateLicenseKey = gourou::extractTextElem(activationDoc, "//adept:privateLicenseKey", throwOnNull);
-	    username    = gourou::extractTextElem(activationDoc, "//adept:username", throwOnNull);

            pugi::xpath_node xpath_node = activationDoc.select_node("//adept:username");
            if (xpath_node)
@ -61,6 +59,20 @@ namespace gourou {
                if (throwOnNull)
                    EXCEPTION(USER_INVALID_ACTIVATION_FILE, "Invalid activation file");
            }
+
+            if (loginMethod == "anonymous")
+                username = "anonymous";
+            else
+                username    = gourou::extractTextElem(activationDoc, "//adept:username", throwOnNull);
+
+            pugi::xpath_node_set nodeSet = activationDoc.select_nodes("//adept:licenseServices/adept:licenseServiceInfo");
+            for (pugi::xpath_node_set::const_iterator it = nodeSet.begin();
+                 it != nodeSet.end(); ++it)
+            {
+                std::string url = gourou::extractTextElem(it->node(), "adept:licenseURL");
+                std::string certificate = gourou::extractTextElem(it->node(), "adept:certificate");
+                licenseServiceCertificates[url] = certificate;
+            }
        }
        catch(gourou::Exception& e)
        {
@ -74,7 +86,6 @@ namespace gourou {
    std::string& User::getDeviceFingerprint() { return deviceFingerprint; }
    std::string& User::getUsername()          { return username; }
    std::string& User::getLoginMethod()       { return loginMethod; }
-    std::string& User::getCertificate()       { return certificate; }
    std::string& User::getAuthenticationCertificate() { return authenticationCertificate; }
    std::string& User::getPrivateLicenseKey() { return privateLicenseKey; }

@ -110,6 +121,11 @@ namespace gourou {
        return trim(res);
    }

+    pugi::xpath_node_set User::getProperties(const std::string property)
+    {
+        return activationDoc.select_nodes(property.c_str());
+    }
+
    User* User::createUser(DRMProcessor* processor, const std::string& dirName, const std::string& ACSServer)
    {
        struct stat _stat;
@ -195,4 +211,13 @@ namespace gourou {

        return user;
    }
+
+    std::string User::getLicenseServiceCertificate(std::string url)
+    {
+        if (licenseServiceCertificates.count(trim(url)))
+            return licenseServiceCertificates[trim(url)];
+
+        return "";
+    }
+
 }
--- a/utils/Makefile
+++ b/utils/Makefile
@ -1,28 +1,57 @@
+BINDIR ?= /bin
+MANDIR ?= /share/man

-TARGETS=acsmdownloader activate
+TARGET_BINARIES=acsmdownloader adept_activate adept_remove adept_loan_mgt
+TARGETS=$(TARGET_BINARIES) launcher
+
+MAN_PAGES=acsmdownloader adept_activate adept_remove adept_loan_mgt
+
+CXXFLAGS=-Wall -fPIC -I$(ROOT)/include -fmacro-prefix-map=$(ROOT)/= -fdata-sections -ffunction-sections
+
+STATIC_DEP=
+# LDFLAGS += -Wl,--gc-sections
+LDFLAGS += -L$(ROOT) -lcrypto -lzip -lz -lcurl -lpugixml

-CXXFLAGS=-Wall `pkg-config --cflags Qt5Core Qt5Network` -fPIC -I$(ROOT)/include -I$(ROOT)/lib/pugixml/src/
 ifneq ($(STATIC_UTILS),)
-LDFLAGS=`pkg-config --libs Qt5Core Qt5Network` -L$(ROOT) $(ROOT)/libgourou.a -lcrypto -lzip
+STATIC_DEP = $(ROOT)/libgourou.a
 else
-LDFLAGS=`pkg-config --libs Qt5Core Qt5Network` -L$(ROOT) -lgourou -lcrypto -lzip
+LDFLAGS += -lgourou
 endif

 ifneq ($(DEBUG),)
-CXXFLAGS += -ggdb -O0
+CXXFLAGS += -ggdb -O0 -DDEBUG
 else
 CXXFLAGS += -O2
 endif

+
+COMMON_DEPS = drmprocessorclientimpl.cpp utils_common.cpp
+COMMON_OBJECTS = $(COMMON_DEPS:.cpp=.o)
+COMMON_LIB  = utils.a
+
 all: $(TARGETS)

-acsmdownloader: drmprocessorclientimpl.cpp acsmdownloader.cpp 
-	$(CXX) $(CXXFLAGS) $^ $(LDFLAGS) -o $@
+${COMMON_LIB}: $(COMMON_DEPS)
+	$(CXX) $(CXXFLAGS) $(COMMON_DEPS) -c
+	$(AR) crs $@ $(COMMON_OBJECTS)

-activate: drmprocessorclientimpl.cpp activate.cpp 
-	$(CXX) $(CXXFLAGS) $^ $(LDFLAGS) -o $@
+%: %.cpp $(COMMON_LIB) $(STATIC_DEP)
+	$(CXX) $(CXXFLAGS) $^ $(STATIC_DEP) $(LDFLAGS) -o $@
+
+install: $(TARGET_BINARIES)
+	install -d $(DESTDIR)$(PREFIX)/$(BINDIR)
+	install -m 755 $(TARGET_BINARIES) $(DESTDIR)$(PREFIX)/$(BINDIR)
+	install -d $(DESTDIR)$(PREFIX)/$(MANDIR)/man1
+	install -m 644 man/*.1 $(DESTDIR)$(PREFIX)/$(MANDIR)/man1
+
+uninstall:
+	cd $(DESTDIR)$(PREFIX)/$(BINDIR)
+	rm -f $(TARGET_BINARIES)
+	cd -
+	cd $(DESTDIR)$(PREFIX)/$(MANDIR)/man1
+	rm -f $(addsuffix .1,$(TARGET_BINARIES)

 clean:
-	rm -f $(TARGETS)
+	rm -f $(TARGETS) $(COMMON_LIB)

 ultraclean: clean
--- a/utils/acsmdownloader.cpp
+++ b/utils/acsmdownloader.cpp
@ -26,130 +26,184 @@
  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";
 static const char* devicekeyFile  = "devicesalt";
 static const char* acsmFile       = 0;
+static       bool  exportPrivateKey = false;
 static const char* outputFile     = 0;
 static const char* outputDir      = 0;
-static const char* defaultDirs[]  = {
-    ".adept/",
-    "./adobe-digital-editions/",
-    "./.adobe-digital-editions/"
-};
+static       bool  resume         = false;
+static       bool  notify         = true;


-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();
    
-	    gourou::FulfillmentItem* item = processor.fulfill(acsmFile);
-
-	    std::string filename;
-	    if (!outputFile)
+            if (exportPrivateKey)
            {
-		filename = item->getMetadata("title");
-		if (filename == "")
-		    filename = "output.epub";
+                std::string filename;
+                if (outputFile)
+                    filename = outputFile;
                else
-		    filename += ".epub";
-	    }
+                {
+                    filename = std::string("Adobe_PrivateLicenseKey--") + user->getUsername() + ".der";

                    if (outputDir)
-	    {
-		QDir dir(outputDir);
-		if (!dir.exists(outputDir))
-		    dir.mkpath(outputDir);
-
                        filename = std::string(outputDir) + "/" + filename;
                }

-	    processor.download(item, filename);
+                createPath(filename.c_str());
+                
+                processor.exportPrivateLicenseKey(filename);
+
+                std::cout << "Private license key exported to " << filename << std::endl;
+            }
+            else
+            {
+                gourou::FulfillmentItem* item = processor.fulfill(acsmFile, notify);
+
+                std::string filename;
+                if (outputFile)
+                    filename = outputFile;
+                else
+                {
+                    filename = item->getMetadata("title");
+                    if (filename == "")
+                        filename = "output";
+                    else
+                    {
+                        // Remove invalid characters
+                        std::replace(filename.begin(), filename.end(), '/', '_');
+                    }
+
+                    if (outputDir)
+                        filename = std::string(outputDir) + "/" + filename;
+                }
+    
+                createPath(filename.c_str());
+
+                gourou::DRMProcessor::ITEM_TYPE type = processor.download(item, filename, resume);
+
+                if (!outputFile)
+                {
+                    std::string finalName = filename;
+                    if (type == gourou::DRMProcessor::ITEM_TYPE::PDF)
+                        finalName += ".pdf";
+                    else
+                        finalName += ".epub";
+                    rename(filename.c_str(), finalName.c_str());
+                    filename = finalName;
+                }
                std::cout << "Created " << filename << std::endl;
+
+                serializeLoanToken(item);
+            }
        } catch(std::exception& e)
        {
            std::cout << e.what() << std::endl;
-	    this->app->exit(1);
+            ret = 1;
        }

-	this->app->exit(0);
+        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] [(-s|--device-key-file) devicesalt] [(-O|--output-dir) dir] [(-o|--output-file) output.epub] [(-v|--verbose)] [(-h|--help)] (-f|--acsm-file) file.acsm" << std::endl << std::endl;
-    
-    std::cout << "  " << "-d|--device-file"     << "\t"   << "device.xml file from eReader" << std::endl;
-    std::cout << "  " << "-a|--activation-file" << "\t"   << "activation.xml file from eReader" << std::endl;
-    std::cout << "  " << "-k|--device-key-file" << "\t"   << "private device key file (eg devicesalt/devkey.bin) from eReader" << std::endl;
-    std::cout << "  " << "-O|--output-dir"      << "\t"   << "Optional output directory were to put result (default ./)" << std::endl;
-    std::cout << "  " << "-o|--output-file"     << "\t"   << "Optional output epub filename (default <title.epub>)" << std::endl;
-    std::cout << "  " << "-f|--acsm-file"       << "\t"   << "ACSM request file for epub download" << std::endl;
+    std::cout << basename((char*)cmd) << " download EPUB file from ACSM request file" << std::endl << std::endl;
+    std::cout << "Usage: " << basename((char*)cmd) << " [OPTIONS] file.acsm" << std::endl << std::endl;
+    std::cout << "Global Options:" << std::endl;
+    std::cout << "  " << "-O|--output-dir"      << "\t"   << "Optional output directory were to put result (default ./) (not compatible with -o)" << std::endl;
+    std::cout << "  " << "-o|--output-file"     << "\t"   << "Optional output filename (default <title.(epub|pdf|der)>) (not compatible with -O)" << std::endl;
+    std::cout << "  " << "-f|--acsm-file"       << "\t"   << "Backward compatibility: 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 << "  " << "-N|--no-notify"       << "\t\t" << "Don't notify server, even if requested" << 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 << "ADEPT Options:" << std::endl;
+    std::cout << "  " << "-D|--adept-directory" << "\t"   << ".adept directory that must contains device.xml, activation.xml and devicesalt" << std::endl;
+    std::cout << "  " << "-d|--device-file"     << "\t"   << "device.xml file from eReader" << std::endl;
+    std::cout << "  " << "-a|--activation-file" << "\t"   << "activation.xml file from eReader" << std::endl;
+    std::cout << "  " << "-k|--device-key-file" << "\t"   << "private device key file (eg devicesalt/devkey.bin) from eReader" << std::endl;
+
    std::cout << std::endl;
-    std::cout << "Device file, activation file and device key file are optionals. If not set, they are looked into :" << std::endl;
+
+    std::cout << "Environment:" << std::endl;
+    std::cout << "Device file, activation file and device key file are optionals. If not set, they are looked into :" << std::endl << std::endl;
+    std::cout << "  * $ADEPT_DIR environment variable" << std::endl;
+    std::cout << "  * /home/<user>/.config/adept" << std::endl;
    std::cout << "  * Current directory" << std::endl;
    std::cout << "  * .adept" << std::endl;
    std::cout << "  * adobe-digital-editions directory" << std::endl;
@ -159,6 +213,7 @@ static void usage(const char* cmd)
 int main(int argc, char** argv)
 {
    int c, ret = -1;
+    std::string _deviceFile, _activationFile, _devicekeyFile;

    const char** files[] = {&devicekeyFile, &deviceFile, &activationFile};
    int verbose = gourou::DRMProcessor::getLogLevel();
@ -166,24 +221,36 @@ int main(int argc, char** argv)
    while (1) {
        int option_index = 0;
        static struct option long_options[] = {
+            {"adept-directory",  required_argument, 0,  'D' },
            {"device-file",      required_argument, 0,  'd' },
            {"activation-file",  required_argument, 0,  'a' },
            {"device-key-file",  required_argument, 0,  'k' },
            {"output-dir",       required_argument, 0,  'O' },
            {"output-file",      required_argument, 0,  'o' },
            {"acsm-file",        required_argument, 0,  'f' },
+            {"export-private-key",no_argument,      0,  'e' },
+            {"resume",           no_argument,       0,  'r' },
+            {"no-notify",        no_argument,       0,  'N' },
            {"verbose",          no_argument,       0,  'v' },
            {"version",          no_argument,       0,  'V' },
            {"help",             no_argument,       0,  'h' },
            {0,                  0,                 0,  0 }
        };

-	c = getopt_long(argc, argv, "d:a:k:O:o:f:vVh",
+        c = getopt_long(argc, argv, "D:d:a:k:O:o:f:erNvVh",
                        long_options, &option_index);
        if (c == -1)
            break;

        switch (c) {
+        case 'D':
+            _deviceFile = std::string(optarg) + "/device.xml";
+            _activationFile = std::string(optarg) + "/activation.xml";
+            _devicekeyFile = std::string(optarg) + "/devicesalt";
+            deviceFile = _deviceFile.c_str();
+            activationFile = _activationFile.c_str();
+            devicekeyFile = _devicekeyFile.c_str();
+            break;
        case 'd':
            deviceFile = optarg;
            break;
@ -202,6 +269,15 @@ int main(int argc, char** argv)
        case 'o':
            outputFile = optarg;
            break;
+        case 'e':
+            exportPrivateKey = true;
+            break;
+        case 'r':
+            resume = true;
+            break;
+        case 'N':
+            notify = false;
+            break;
        case 'v':
            verbose++;
            break;
@ -219,39 +295,61 @@ int main(int argc, char** argv)

    gourou::DRMProcessor::setLogLevel(verbose);

-    if (!acsmFile || (outputDir && !outputDir[0]) ||
+    if (optind == argc-1)
+        acsmFile = argv[optind];
+
+    if ((!acsmFile && !exportPrivateKey) || (outputDir && !outputDir[0]) ||
        (outputFile && !outputFile[0]))
    {
        usage(argv[0]);
        return -1;
    }

-    QCoreApplication app(argc, argv);
-    ACSMDownloader downloader(&app);
+    if (outputDir && outputFile)
+    {
+        std::cout << "Error : you cannot use both -o and -O" << std::endl;
+        return -1;
+    }
+
+    ACSMDownloader downloader;

    int i;
+    bool hasErrors = false;
+    const char* orig;
    for (i=0; i<(int)ARRAY_SIZE(files); i++)
    {
+        orig = *files[i];
        *files[i] = findFile(*files[i]);
        if (!*files[i])
        {
-	    std::cout << "Error : " << *files[i] << " doesn't exists" << std::endl;
+            std::cout << "Error : " << orig << " doesn't exists, did you activate your device ?" << std::endl;
            ret = -1;
-	    goto end;
+            hasErrors = true;
        }
    }

-    QFile file(acsmFile);
-    if (!file.exists())
+    if (hasErrors)
+        goto end;
+
+    if (exportPrivateKey)
+    {
+        if (acsmFile)
+        {
+            usage(argv[0]);
+            return -1;
+        }
+    }
+    else
+    {
+        if (!pathExists(acsmFile))
        {
            std::cout << "Error : " << acsmFile << " doesn't exists" << std::endl;
            ret = -1;
            goto end;
        }
+    }

-    QThreadPool::globalInstance()->start(&downloader);
-
-    ret = app.exec();
+    ret = downloader.run();

 end:
    for (i=0; i<(int)ARRAY_SIZE(files); i++)
--- a/utils/activate.cpp
+++ b/utils/activate.cpp
@ -1,272 +0,0 @@
-/*
-  Copyright (c) 2021, 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 <unistd.h>
-#include <getopt.h>
-#include <stdlib.h>
-#include <termios.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]))
-
-static const char* username      = 0;
-static const char* password      = 0;
-static const char* outputDir     = 0;
-static const char* hobbesVersion = HOBBES_DEFAULT_VERSION;
-static bool        randomSerial  = false;
-
-// From http://www.cplusplus.com/articles/E6vU7k9E/
-static int getch() {
-    int ch;
-    struct termios t_old, t_new;
-
-    tcgetattr(STDIN_FILENO, &t_old);
-    t_new = t_old;
-    t_new.c_lflag &= ~(ICANON | ECHO);
-    tcsetattr(STDIN_FILENO, TCSANOW, &t_new);
-
-    ch = getchar();
-
-    tcsetattr(STDIN_FILENO, TCSANOW, &t_old);
-    return ch;
-}
-
-static std::string getpass(const char *prompt, bool show_asterisk=false)
-{
-  const char BACKSPACE=127;
-  const char RETURN=10;
-
-  std::string password;
-  unsigned char ch=0;
-
-  std::cout <<prompt;
-
-  while((ch=getch())!= RETURN)
-    {
-	if(ch==BACKSPACE)
-         {
-            if(password.length()!=0)
-              {
-                 if(show_asterisk)
-                 std::cout <<"\b \b";
-                 password.resize(password.length()-1);
-              }
-         }
-       else
-         {
-             password+=ch;
-             if(show_asterisk)
-                 std::cout <<'*';
-         }
-    }
-  std::cout <<std::endl;
-  return password;
-}
-
-
-class Activate: public QRunnable
-{
-public:
-    Activate(QCoreApplication* app):
-	app(app)
-    {
-	setAutoDelete(false);
-    }
-   
-    void run()
-    {
-	try
-	{
-	    DRMProcessorClientImpl client;
-	    gourou::DRMProcessor* processor = gourou::DRMProcessor::createDRMProcessor(
-		&client, randomSerial, outputDir, hobbesVersion);
-
-	    processor->signIn(username, password);
-	    processor->activateDevice();
-
-	    std::cout << username << " fully signed and device activated in " << outputDir << std::endl;
-	} catch(std::exception& e)
-	{
-	    std::cout << e.what() << std::endl;
-	    this->app->exit(1);
-	}
-
-	this->app->exit(0);
-    }
-
-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 << " (-u|--username) username [(-p|--password) password] [(-O|--output-dir) dir] [(-r|--random-serial)] [(-v|--verbose)] [(-h|--help)]" << std::endl << std::endl;
-    
-    std::cout << "  " << "-u|--username"   << "\t\t" << "AdobeID username (ie adobe.com email account)" << std::endl;
-    std::cout << "  " << "-p|--password"   << "\t\t" << "AdobeID password (asked if not set via command line) " << std::endl;
-    std::cout << "  " << "-O|--output-dir" << "\t"   << "Optional output directory were to put result (default ./.adept). This directory must not already exists" << std::endl;
-    std::cout << "  " << "-H|--hobbes-version" << "\t"<< "Force RMSDK version to a specific value (default: version of current librmsdk)" << std::endl;
-    std::cout << "  " << "-r|--random-serial" << "\t"<< "Generate a random device serial (if not set, it will be dependent of your current configuration)" << 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;
-}
-
-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());
-
-    free((void*)root);
-
-    return res;
-}
-
-int main(int argc, char** argv)
-{
-    int c, ret = -1;
-    const char* _outputDir = outputDir;
-    int verbose = gourou::DRMProcessor::getLogLevel();
-    
-    while (1) {
-	int option_index = 0;
-	static struct option long_options[] = {
-	    {"username",      required_argument, 0,  'u' },
-	    {"password",      required_argument, 0,  'p' },
-	    {"output-dir",    required_argument, 0,  'O' },
-	    {"hobbes-version",required_argument, 0,  'H' },
-	    {"random-serial", 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, "u:p:O:H:rvVh",
-                        long_options, &option_index);
-	if (c == -1)
-	    break;
-
-	switch (c) {
-	case 'u':
-	    username = optarg;
-	    break;
-	case 'p':
-	    password = optarg;
-	    break;
-	case 'O':
-	    _outputDir = optarg;
-	    break;
-	case 'H':
-	    hobbesVersion = optarg;
-	    break;
-	case 'v':
-	    verbose++;
-	    break;
-	case 'V':
-	    version();
-	    return 0;
-	case 'h':
-	    usage(argv[0]);
-	    return 0;
-	case 'r':
-	    randomSerial = true;
-	    break;
-	default:
-	    usage(argv[0]);
-	    return -1;
-	}
-    }
-   
-    gourou::DRMProcessor::setLogLevel(verbose);
-
-    if (!username)
-    {
-	usage(argv[0]);
-	return -1;
-    }
-   
-    if (!_outputDir || _outputDir[0] == 0)
-    {
-	outputDir = abspath(DEFAULT_ADEPT_DIR);
-    }
-    else
-    {
-	// Relative path
-	if (_outputDir[0] == '.' || _outputDir[0] != '/')
-	{
-	    QFile file(_outputDir);
-	    // realpath doesn't works if file/dir doesn't exists
-	    if (file.exists())
-		outputDir = realpath(_outputDir, 0);
-	    else
-		outputDir = abspath(_outputDir);
-	}
-	else
-	    outputDir = strdup(_outputDir);
-    }
-
-    if (!password)
-    {
-	char prompt[128];
-	std::snprintf(prompt, sizeof(prompt), "Enter password for <%s> : ", username);
-	std::string pass = getpass((const char*)prompt, false);
-	password = pass.c_str();
-    }
-    
-    QCoreApplication app(argc, argv);
-    
-    Activate activate(&app);
-    QThreadPool::globalInstance()->start(&activate);
-
-    ret = app.exec();
-
-    free((void*)outputDir);
-    return ret;
-}
--- a/utils/adept_activate.cpp
+++ b/utils/adept_activate.cpp
@ -0,0 +1,288 @@
+/*
+  Copyright (c) 2021, 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 <unistd.h>
+#include <getopt.h>
+#include <termios.h>
+#include <string.h>
+#include <limits.h>
+#include <libgen.h>
+
+#include <iostream>
+#include <ostream>
+
+#include <libgourou.h>
+#include "drmprocessorclientimpl.h"
+#include "utils_common.h"
+
+static const char* username      = 0;
+static const char* password      = 0;
+static const char* outputDir     = 0;
+static const char* hobbesVersion = HOBBES_DEFAULT_VERSION;
+static bool        randomSerial  = false;
+
+// From http://www.cplusplus.com/articles/E6vU7k9E/
+static int getch() {
+    int ch;
+    struct termios t_old, t_new;
+
+    tcgetattr(STDIN_FILENO, &t_old);
+    t_new = t_old;
+    t_new.c_lflag &= ~(ICANON | ECHO);
+    tcsetattr(STDIN_FILENO, TCSANOW, &t_new);
+
+    ch = getchar();
+
+    tcsetattr(STDIN_FILENO, TCSANOW, &t_old);
+    return ch;
+}
+
+static std::string getpass(const char *prompt, bool show_asterisk=false)
+{
+    const char BACKSPACE=127;
+    const char RETURN=10;
+
+    std::string password;
+    unsigned char ch=0;
+
+    std::cout <<prompt;
+
+    while((ch=getch())!= RETURN)
+    {
+        if(ch==BACKSPACE)
+        {
+            if(password.length()!=0)
+            {
+                if(show_asterisk)
+                    std::cout <<"\b \b";
+                password.resize(password.length()-1);
+            }
+        }
+        else
+        {
+            password+=ch;
+            if(show_asterisk)
+                std::cout <<'*';
+        }
+    }
+    std::cout <<std::endl;
+    return password;
+}
+
+
+class ADEPTActivate
+{
+public:
+
+    int run()
+    {
+        int ret = 0;
+        try
+        {
+            DRMProcessorClientImpl client;
+            gourou::DRMProcessor* processor = gourou::DRMProcessor::createDRMProcessor(
+                &client, randomSerial, outputDir, hobbesVersion);
+
+            processor->signIn(username, password);
+            processor->activateDevice();
+
+            std::cout << username << " fully signed and device activated in " << outputDir << std::endl;
+        } catch(std::exception& e)
+        {
+            std::cout << e.what() << std::endl;
+            ret = 1;
+        }
+
+        return ret;
+    }
+};    
+
+
+static void usage(const char* cmd)
+{
+    std::cout << basename((char*)cmd) << " create new device files used by ADEPT DRM" << std::endl << std::endl;
+
+    std::cout << "Usage: " << basename((char*)cmd) << " OPTIONS" << std::endl << std::endl;
+
+    std::cout << "Global Options:" << 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;
+    std::cout << "  " << "-p|--password"   << "\t\t" << "AdobeID password (asked if not set via command line) " << std::endl;
+    std::cout << "  " << "-O|--output-dir" << "\t"   << "Optional output directory were to put result (default ./.adept). This directory must not already exists" << std::endl;
+    std::cout << "  " << "-H|--hobbes-version" << "\t"<< "Force RMSDK version to a specific value (default: version of current librmsdk)" << std::endl;
+    std::cout << "  " << "-r|--random-serial" << "\t"<< "Generate a random device serial (if not set, it will be dependent of your current configuration)" << 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;
+}
+
+static const char* abspath(const char* filename)
+{
+    const char* root = getcwd(0, PATH_MAX);
+    std::string fullPath = std::string(root) + std::string("/") + filename;
+    const char* res = strdup(fullPath.c_str());
+
+    free((void*)root);
+
+    return res;
+}
+
+int main(int argc, char** argv)
+{
+    int c, ret = -1;
+    const char* _outputDir = outputDir;
+    int verbose = gourou::DRMProcessor::getLogLevel();
+    bool anonymous = false;
+
+    while (1) {
+        int option_index = 0;
+        static struct option long_options[] = {
+            {"anonymous",     no_argument      , 0,  'a' },
+            {"username",      required_argument, 0,  'u' },
+            {"password",      required_argument, 0,  'p' },
+            {"output-dir",    required_argument, 0,  'O' },
+            {"hobbes-version",required_argument, 0,  'H' },
+            {"random-serial", 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, "au:p:O:H:rvVh",
+                        long_options, &option_index);
+        if (c == -1)
+            break;
+
+        switch (c) {
+        case 'a':
+            anonymous = true;
+            break;
+        case 'u':
+            username = optarg;
+            break;
+        case 'p':
+            password = optarg;
+            break;
+        case 'O':
+            _outputDir = optarg;
+            break;
+        case 'H':
+            hobbesVersion = optarg;
+            break;
+        case 'v':
+            verbose++;
+            break;
+        case 'V':
+            version();
+            return 0;
+        case 'h':
+            usage(argv[0]);
+            return 0;
+        case 'r':
+            randomSerial = true;
+            break;
+        default:
+            usage(argv[0]);
+            return -1;
+        }
+    }
+
+    gourou::DRMProcessor::setLogLevel(verbose);
+
+    if ((!username && !anonymous) ||
+        (username && anonymous))
+    {
+        usage(argv[0]);
+        return -1;
+    }
+
+    if (anonymous)
+    {
+        username = "anonymous";
+        password = "";
+    }
+
+    if (!_outputDir || _outputDir[0] == 0)
+    {
+        outputDir = strdup(gourou::DRMProcessor::getDefaultAdeptDir().c_str());
+    }
+    else
+    {
+        // Relative path
+        if (_outputDir[0] == '.' || _outputDir[0] != '/')
+        {
+            // realpath doesn't works if file/dir doesn't exists
+            if (pathExists(_outputDir))
+                outputDir = strdup(realpath(_outputDir, 0));
+            else
+                outputDir = strdup(abspath(_outputDir));
+        }
+        else
+            outputDir = strdup(_outputDir);
+    }
+
+    std::string pass;
+    if (pathExists(outputDir))
+    {
+        int key;
+    
+        while (true)
+        {
+            std::cout << "!! Warning !! : " << outputDir << " already exists." << std::endl;
+            std::cout << "All your data will be overwrite. Would you like to continue ? [y/N] " << std::flush ;
+            key = getchar();
+            if (key == 'n' || key == 'N' || key == '\n' || key == '\r')
+                goto end;
+            if (key == 'y' || key == 'Y')
+                break;
+        }
+
+        // Clean STDIN buf
+        while ((key = getchar()) != '\n')
+            ;
+    }
+
+    if (!password)
+    {
+        char prompt[128];
+        std::snprintf(prompt, sizeof(prompt), "Enter password for <%s> : ", username);
+        pass = getpass((const char*)prompt, false);
+        password = pass.c_str();
+    }
+
+    ADEPTActivate activate;
+
+    ret = activate.run();
+
+end:
+    free((void*)outputDir);
+    return ret;
+}
--- a/utils/adept_loan_mgt.cpp
+++ b/utils/adept_loan_mgt.cpp
@ -0,0 +1,503 @@
+/*
+  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* adeptDir       = 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;
+static       bool  notify         = true;
+
+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(adeptDir) + std::string("/") + LOANS_DIR;
+
+        if (!pathExists(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;
+#ifdef __ANDROID__
+            res = strptime(loan->validity.c_str(), "%Y-%m-%dT%H:%M:%S%z", &tm);
+#else
+            res = strptime(loan->validity.c_str(), "%Y-%m-%dT%H:%M:%S%Z", &tm);
+#endif
+    
+            if (res != NULL && *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 << "No books 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();
+        }
+
+        /* Manage empty names */
+        if (maxSizeBookName == 0)
+            maxSizeBookName = sizeof("No name ")-1;
+        else if (maxSizeBookName < 4)
+            maxSizeBookName = 4;
+        else 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 << "Expiration";
+        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() == 0)
+                bookName = std::string("No name ");
+            else 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, notify);
+    
+        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 << basename((char*)cmd) << " manage loaned books" << std::endl << std::endl;
+
+    std::cout << "Usage: " << basename((char*)cmd) << " [OPTIONS]" << std::endl << std::endl;
+
+    std::cout << "Global Options:" << 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 << "  " << "-N|--no-notify"       << "\t\t" << "Don't notify server, even if requested" << 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 << "ADEPT Options:" << std::endl;
+    std::cout << "  " << "-D|--adept-directory" << "\t"   << ".adept directory that must contains device.xml, activation.xml and devicesalt" << std::endl;
+    std::cout << std::endl;
+
+    std::cout << "Environment:" << std::endl;
+    std::cout << "ADEPT directory is optional. If not set, it's looked into :" << std::endl;
+    std::cout << "  * $ADEPT_DIR environment variable" << std::endl;
+    std::cout << "  * /home/<user>/.config/adept" << 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[] = {
+            {"adept-directory",  required_argument, 0,  'D' },
+            {"list",             no_argument,       0,  'l' },
+            {"return",           no_argument,       0,  'r' },
+            {"delete",           no_argument,       0,  'd' },
+            {"no-notify",        no_argument,       0,  'N' },
+            {"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':
+            adeptDir = optarg;
+            break;
+        case 'l':
+            list = true;
+            actions++;
+            break;
+        case 'r':
+            returnID = optarg;
+            actions++;
+            break;
+        case 'd':
+            deleteID = optarg;
+            actions++;
+            break;
+        case 'N':
+            notify = false;
+            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 (adeptDir)
+        {
+            std::string path = std::string(adeptDir) + 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 adept dir was provided by user
+        adeptDir = 0;
+        goto end;
+    }
+
+    if (adeptDir)
+        adeptDir = strdup(adeptDir); // For below free
+    else
+    {
+        adeptDir = strdup(deviceFile);
+        adeptDir = dirname(adeptDir);
+    }
+
+    ret = loanMGT.run();
+
+end:
+    for (i=0; i<(int)ARRAY_SIZE(files); i++)
+    {
+        if (*files[i])
+            free((void*)*files[i]);
+    }
+
+    if (adeptDir)
+        free(adeptDir);
+
+    return ret;
+}
--- a/utils/adept_remove.cpp
+++ b/utils/adept_remove.cpp
@ -0,0 +1,326 @@
+/*
+  Copyright (c) 2021, 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 <libgen.h>
+
+#include <iostream>
+
+#include <libgourou.h>
+#include <libgourou_common.h>
+
+#include "drmprocessorclientimpl.h"
+#include "utils_common.h"
+
+static const char* deviceFile     = "device.xml";
+static const char* activationFile = "activation.xml";
+static const char* devicekeyFile  = "devicesalt";
+static const char* inputFile      = 0;
+static const char* outputFile     = 0;
+static const char* outputDir      = 0;
+
+static char*          encryptionKeyUser  = 0;
+static unsigned char* encryptionKey      = 0;
+static unsigned       encryptionKeySize  = 0;
+
+static inline unsigned char htoi(unsigned char c)
+{
+    if (c >= '0' && c <= '9')
+        c -= '0';
+    else if (c >= 'a' && c <= 'f')
+        c -= 'a' - 10;
+    else if (c >= 'A' && c <= 'F')
+        c -= 'A' - 10;
+    else
+        EXCEPTION(gourou::USER_INVALID_INPUT, "Invalid character " << c << " in encryption key");
+
+    return c;
+}
+
+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:
+
+    int run()
+    {
+        int ret = 0;
+        try
+        {
+            gourou::DRMProcessor::ITEM_TYPE type;
+            DRMProcessorClientImpl client;
+            gourou::DRMProcessor processor(&client, deviceFile, activationFile, devicekeyFile);
+    
+            std::string filename;
+            if (outputFile)
+                filename = outputFile;
+            else
+            {
+                filename = std::string(inputFile);
+
+                if (outputDir)
+                    filename = std::string(outputDir) + "/" + filename;
+            }
+            
+            if (endsWith(filename, ".epub"))
+                type = gourou::DRMProcessor::ITEM_TYPE::EPUB;
+            else if (endsWith(filename, ".pdf"))
+                type = gourou::DRMProcessor::ITEM_TYPE::PDF;
+            else
+            {
+                EXCEPTION(gourou::DRM_FORMAT_NOT_SUPPORTED, "Unsupported file format of " << filename);
+            }
+
+            createPath(filename.c_str());
+
+            if (inputFile != 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;
+            }
+            else
+            {
+                // Use temp file for PDF
+                if (type == gourou::DRMProcessor::ITEM_TYPE::PDF)
+                {
+                    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... */
+                    unlink(filename.c_str());
+                    if (rename(tempFile.c_str(), filename.c_str()))
+                    {
+                        EXCEPTION(gourou::DRM_FILE_ERROR, "Unable to copy " << tempFile << " into " << filename);
+                    }
+                }
+                else
+                    processor.removeDRM(inputFile, filename, type, encryptionKey, encryptionKeySize);
+                std::cout << "DRM removed from " << filename << std::endl;
+            }
+        } catch(std::exception& e)
+        {
+            std::cout << e.what() << std::endl;
+            ret = 1;
+        }
+
+        return ret;
+    }
+};    
+
+static void usage(const char* cmd)
+{
+    std::cout << basename((char*)cmd) << " remove ADEPT DRM (from Adobe) of EPUB/PDF file" << std::endl << std::endl;
+
+    std::cout << "Usage: " << basename((char*)cmd) << " [OPTIONS] file(.epub|pdf)" << std::endl << std::endl;
+
+    std::cout << "Global Options:" << std::endl;
+    std::cout << "  " << "-O|--output-dir"      << "\t"   << "Optional output directory were to put result (default ./) (not compatible with -o)" << std::endl;
+    std::cout << "  " << "-o|--output-file"     << "\t"   << "Optional output filename (default inplace DRM removal>) (not compatible with -O)" << std::endl;
+    std::cout << "  " << "-f|--input-file"      << "\t"   << "Backward compatibility: EPUB/PDF file to process" << 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 << "ADEPT Options:" << std::endl;
+    std::cout << "  " << "-D|--adept-directory" << "\t"   << ".adept directory that must contains device.xml, activation.xml and devicesalt" << std::endl;
+    std::cout << "  " << "-d|--device-file"     << "\t"   << "device.xml file from eReader" << std::endl;
+    std::cout << "  " << "-a|--activation-file" << "\t"   << "activation.xml file from eReader" << std::endl;
+    std::cout << "  " << "-k|--device-key-file" << "\t"   << "private device key file (eg devicesalt/devkey.bin) from eReader" << std::endl;
+
+    std::cout << std::endl;
+
+    std::cout << "Environment:" << std::endl;
+    std::cout << "Device file, activation file and device key file are optionals. If not set, they are looked into :" << std::endl;
+    std::cout << "  * $ADEPT_DIR environment variable" << std::endl;
+    std::cout << "  * /home/<user>/.config/adept" << 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();
+    std::string _deviceFile, _activationFile, _devicekeyFile;
+
+    while (1) {
+        int option_index = 0;
+        static struct option long_options[] = {
+            {"adept-directory",  required_argument, 0,  'D' },
+            {"device-file",      required_argument, 0,  'd' },
+            {"activation-file",  required_argument, 0,  'a' },
+            {"device-key-file",  required_argument, 0,  'k' },
+            {"output-dir",       required_argument, 0,  'O' },
+            {"output-file",      required_argument, 0,  'o' },
+            {"input-file",       required_argument, 0,  'f' },
+            {"encryption-key",   required_argument, 0,  'K' }, // Private option
+            {"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:d:a:k:O:o:f:K:vVh",
+                        long_options, &option_index);
+        if (c == -1)
+            break;
+
+        switch (c) {
+        case 'D':
+            _deviceFile = std::string(optarg) + "/device.xml";
+            _activationFile = std::string(optarg) + "/activation.xml";
+            _devicekeyFile = std::string(optarg) + "/devicesalt";
+            deviceFile = _deviceFile.c_str();
+            activationFile = _activationFile.c_str();
+            devicekeyFile = _devicekeyFile.c_str();
+            break;
+        case 'd':
+            deviceFile = optarg;
+            break;
+        case 'a':
+            activationFile = optarg;
+            break;
+        case 'k':
+            devicekeyFile = optarg;
+            break;
+        case 'f':
+            inputFile = optarg;
+            break;
+        case 'O':
+            outputDir = optarg;
+            break;
+        case 'o':
+            outputFile = optarg;
+            break;
+        case 'K':
+            encryptionKeyUser = optarg;
+            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);
+
+    if (optind == argc-1)
+        inputFile = argv[optind];
+
+    if (!inputFile || (outputDir && !outputDir[0]) ||
+        (outputFile && !outputFile[0]))
+    {
+        usage(argv[0]);
+        return -1;
+    }
+
+    if (outputDir && outputFile)
+    {
+        std::cout << "Error : you cannot use both -o and -O" << std::endl;
+        return -1;
+    }
+    
+    ADEPTRemove remover;
+
+    int i;
+    bool hasErrors = false;
+    const char* orig;
+    for (i=0; i<(int)ARRAY_SIZE(files); i++)
+    {
+        orig = *files[i];
+        *files[i] = findFile(*files[i]);
+        if (!*files[i])
+        {
+            std::cout << "Error : " << orig << " doesn't exists, did you activate your device ?" << std::endl;
+            ret = -1;
+            hasErrors = true;
+        }
+    }
+
+    if (encryptionKeyUser)
+    {
+        int size = std::string(encryptionKeyUser).size();
+        if ((size % 2))
+        {
+            std::cout << "Error : Encryption key must be odd length" << std::endl;
+            goto end;
+        }
+
+        if (encryptionKeyUser[0] == '0' && encryptionKeyUser[1] == 'x')
+        {
+            encryptionKeyUser += 2;
+            size -= 2;
+        }
+
+        encryptionKey = new unsigned char[size/2];
+
+        for(i=0; i<size; i+=2)
+        {
+            encryptionKey[i/2]  = htoi(encryptionKeyUser[i]) << 4;
+            encryptionKey[i/2] |= htoi(encryptionKeyUser[i+1]);
+        }
+
+        encryptionKeySize = size/2;
+    }
+
+    if (hasErrors)
+        goto end;
+
+    ret = remover.run();
+
+end:
+    for (i=0; i<(int)ARRAY_SIZE(files); i++)
+    {
+        if (*files[i])
+            free((void*)*files[i]);
+    }
+
+    if (encryptionKey)
+        free(encryptionKey);
+
+    return ret;
+}
--- a/utils/drmprocessorclientimpl.cpp
+++ b/utils/drmprocessorclientimpl.cpp
--- a/utils/drmprocessorclientimpl.h
+++ b/utils/drmprocessorclientimpl.h
@ -31,28 +31,40 @@

 #include <string>

+#if OPENSSL_VERSION_MAJOR >= 3
+#include <openssl/provider.h>
+#endif
+
 #include <drmprocessorclient.h>

 class DRMProcessorClientImpl : public gourou::DRMProcessorClient
 {
-    public:
+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(""));
+    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,
                                   const unsigned char* data, unsigned dataLength,
                                   unsigned char* res);
            
+    virtual void RSAPrivateDecrypt(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);
+
    virtual void RSAPublicEncrypt(const unsigned char* RSAKey, unsigned int RSAKeyLength,
                                  const RSA_KEY_TYPE keyType,
                                  const unsigned char* data, unsigned dataLength,
@ -63,48 +75,71 @@ class DRMProcessorClientImpl : public gourou::DRMProcessorClient

    virtual void extractRSAPublicKey(void* RSAKeyHandler, unsigned char** keyOut, unsigned int* keyOutLength);
    virtual void extractRSAPrivateKey(void* RSAKeyHandler, unsigned char** keyOut, unsigned int* keyOutLength);
+    virtual void extractCertificate(const unsigned char* RSAKey, unsigned int RSAKeyLength,
+                                    const RSA_KEY_TYPE keyType, const std::string& password,
+                                    unsigned char** certOut, unsigned int* certOutLength);
                
    /* Crypto interface */
-    virtual void AESEncrypt(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* AESEncryptInit(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 AESEncryptUpdate(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 AESEncryptFinalize(void* handler, unsigned char* dataOut, unsigned int* dataOutLength);
+    virtual void encryptFinalize(void* handler, unsigned char* dataOut, unsigned int* dataOutLength);

-    virtual void AESDecrypt(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* AESDecryptInit(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 AESDecryptUpdate(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 AESDecryptFinalize(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);

-    virtual std::string zipReadFile(void* handler, const std::string& path);
+    virtual void zipReadFile(void* handler, const std::string& path, gourou::ByteArray& result, bool decompress=true);

-    virtual void zipWriteFile(void* handler, const std::string& path, const std::string& content);
+    virtual void zipWriteFile(void* handler, const std::string& path, gourou::ByteArray& content);

    virtual void zipDeleteFile(void* handler, const std::string& path);

    virtual void zipClose(void* handler);

+    virtual void inflate(gourou::ByteArray& data, gourou::ByteArray& result,
+                         int wbits=-15);
+    
+    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);
+    void padWithPKCS1Type2(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
+
+    char cookiejar[64];
 };

 #endif
--- a/utils/launcher.cpp
+++ b/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" || !pathExists(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;
+}
--- a/utils/man/acsmdownloader.1
+++ b/utils/man/acsmdownloader.1
@ -0,0 +1,61 @@
+.\" DO NOT MODIFY THIS FILE!  It was generated by help2man 1.49.3.
+.TH ACSMDOWNLOADER "1" "January 2023" "acsmdownloader download EPUB file from ACSM request file" "User Commands"
+.SH NAME
+acsmdownloader \- download EPUB file from ACSM request file
+.SH SYNOPSIS
+.B acsmdownloader
+[\fI\,OPTIONS\/\fR] \fI\,file.acsm\/\fR
+.SH DESCRIPTION
+Download EPUB file from ACSM request file
+.SS "Global Options:"
+.TP
+\fB\-O\fR|\-\-output\-dir
+Optional output directory were to put result (default ./)
+.TP
+\fB\-o\fR|\-\-output\-file
+Optional output filename (default <title.(epub|pdf|der)>)
+.TP
+\fB\-f\fR|\-\-acsm\-file
+Backward compatibility: ACSM request file for epub download
+.TP
+\fB\-e\fR|\-\-export\-private\-key
+Export private key in DER format
+.TP
+\fB\-r\fR|\-\-resume
+Try to resume download (in case of previous failure)
+.TP
+\fB\-v\fR|\-\-verbose
+Increase verbosity, can be set multiple times
+.TP
+\fB\-V\fR|\-\-version
+Display libgourou version
+.TP
+\fB\-h\fR|\-\-help
+This help
+.SS "ADEPT Options:"
+.TP
+\fB\-D\fR|\-\-adept\-directory
+\&.adept directory that must contains device.xml, activation.xml and devicesalt
+.TP
+\fB\-d\fR|\-\-device\-file
+device.xml file from eReader
+.TP
+\fB\-a\fR|\-\-activation\-file
+activation.xml file from eReader
+.TP
+\fB\-k\fR|\-\-device\-key\-file
+private device key file (eg devicesalt/devkey.bin) from eReader
+.SH ENVIRONMENT
+Device file, activation file and device key file are optionals. If not set, they are looked into :
+.IP
+* $ADEPT_DIR environment variable
+.IP
+* /home/<user>/.config/adept
+.IP
+* Current directory
+.IP
+* .adept
+.IP
+* adobe\-digital\-editions directory
+.IP
+* .adobe\-digital\-editions directory
--- a/utils/man/adept_activate.1
+++ b/utils/man/adept_activate.1
@ -0,0 +1,67 @@
+.\" DO NOT MODIFY THIS FILE!  It was generated by help2man 1.49.3.
+.TH ADEPT_ACTIVATE "1" "January 2023" "adept_activate create new device files used by ADEPT DRM" "User Commands"
+.SH NAME
+adept_activate create new device files used by ADEPT DRM
+.SH SYNOPSIS
+.B adept_activate
+\fI\,OPTIONS\/\fR
+.SH DESCRIPTION
+Create new device files used by ADEPT DRM
+.SS "Global Options:"
+.TP
+\fB\-a\fR|\-\-anonymous
+Anonymous account, no need for username/password (Use it only with a DRM removal software)
+.TP
+\fB\-u\fR|\-\-username
+AdobeID username (ie adobe.com email account)
+.TP
+\fB\-p\fR|\-\-password
+AdobeID password (asked if not set via command line)
+.TP
+\fB\-O\fR|\-\-output\-dir
+Optional output directory were to put result (default ./.adept). This directory must not already exists
+.TP
+\fB\-H\fR|\-\-hobbes\-version
+Force RMSDK version to a specific value (default: version of current librmsdk)
+.TP
+\fB\-r\fR|\-\-random\-serial
+Generate a random device serial (if not set, it will be dependent of your current configuration)
+.TP
+\fB\-v\fR|\-\-verbose
+Increase verbosity, can be set multiple times
+.TP
+\fB\-V\fR|\-\-version
+Display libgourou version
+.TP
+\fB\-h\fR|\-\-help
+This help
+.PP
+Usage: adept_activate OPTIONS
+.SS "Global Options:"
+.TP
+\fB\-a\fR|\-\-anonymous
+Anonymous account, no need for username/password (Use it only with a DRM removal software)
+.TP
+\fB\-u\fR|\-\-username
+AdobeID username (ie adobe.com email account)
+.TP
+\fB\-p\fR|\-\-password
+AdobeID password (asked if not set via command line)
+.TP
+\fB\-O\fR|\-\-output\-dir
+Optional output directory were to put result (default ./.adept). This directory must not already exists
+.TP
+\fB\-H\fR|\-\-hobbes\-version
+Force RMSDK version to a specific value (default: version of current librmsdk)
+.TP
+\fB\-r\fR|\-\-random\-serial
+Generate a random device serial (if not set, it will be dependent of your current configuration)
+.TP
+\fB\-v\fR|\-\-verbose
+Increase verbosity, can be set multiple times
+.TP
+\fB\-V\fR|\-\-version
+Display libgourou version
+.TP
+\fB\-h\fR|\-\-help
+This help
--- a/utils/man/adept_loan_mgt.1
+++ b/utils/man/adept_loan_mgt.1
@ -0,0 +1,46 @@
+.\" DO NOT MODIFY THIS FILE!  It was generated by help2man 1.49.3.
+.TH ADEPT_LOAN_MGT "1" "January 2023" "adept_loan_mgt manage loaned books" "User Commands"
+.SH NAME
+adept_loan_mgt manage loaned books
+.SH SYNOPSIS
+.B adept_loan_mgt
+[\fI\,OPTIONS\/\fR]
+.SH DESCRIPTION
+Manage ADEPT loaned books
+.SS "Global Options:"
+.TP
+\fB\-l\fR|\-\-list
+List all loaned books
+.TP
+\fB\-r\fR|\-\-return
+Return a loaned book
+.TP
+\fB\-d\fR|\-\-delete
+Delete a loan entry without returning it
+.TP
+\fB\-v\fR|\-\-verbose
+Increase verbosity, can be set multiple times
+.TP
+\fB\-V\fR|\-\-version
+Display libgourou version
+.TP
+\fB\-h\fR|\-\-help
+This help
+.SS "ADEPT Options:"
+.TP
+\fB\-D\fR|\-\-adept\-directory
+\&.adept directory that must contains device.xml, activation.xml and devicesalt
+.SH ENVIRONMENT
+.SS "ADEPT directory is optional. If not set, it's looked into :"
+.IP
+* $ADEPT_DIR environment variable
+.IP
+* /home/<user>/.config/adept
+.IP
+* Current directory
+.IP
+* .adept
+.IP
+* adobe\-digital\-editions directory
+.IP
+* .adobe\-digital\-editions directory
--- a/utils/man/adept_remove.1
+++ b/utils/man/adept_remove.1
@ -0,0 +1,55 @@
+.\" DO NOT MODIFY THIS FILE!  It was generated by help2man 1.49.3.
+.TH ADEPT_REMOVE "1" "January 2023" "adept_remove remove ADEPT DRM (from Adobe) of EPUB/PDF file" "User Commands"
+.SH NAME
+adept_remove remove ADEPT DRM (from Adobe) of EPUB/PDF file
+.SH SYNOPSIS
+.B adept_remove
+[\fI\,OPTIONS\/\fR] \fI\,file(.epub|pdf)\/\fR
+.SH DESCRIPTION
+Remove ADEPT DRM (from Adobe) of EPUB/PDF file
+.SS "Global Options:"
+.TP
+\fB\-O\fR|\-\-output\-dir
+Optional output directory were to put result (default ./)
+.TP
+\fB\-o\fR|\-\-output\-file
+Optional output filename (default inplace DRM removal>)
+.TP
+\fB\-f\fR|\-\-input\-file
+Backward compatibility: EPUB/PDF file to process
+.TP
+\fB\-v\fR|\-\-verbose
+Increase verbosity, can be set multiple times
+.TP
+\fB\-V\fR|\-\-version
+Display libgourou version
+.TP
+\fB\-h\fR|\-\-help
+This help
+.SS "ADEPT Options:"
+.TP
+\fB\-D\fR|\-\-adept\-directory
+\&.adept directory that must contains device.xml, activation.xml and devicesalt
+.TP
+\fB\-d\fR|\-\-device\-file
+device.xml file from eReader
+.TP
+\fB\-a\fR|\-\-activation\-file
+activation.xml file from eReader
+.TP
+\fB\-k\fR|\-\-device\-key\-file
+private device key file (eg devicesalt/devkey.bin) from eReader
+.SH ENVIRONMENT
+.SS "Device file, activation file and device key file are optionals. If not set, they are looked into :"
+.IP
+* $ADEPT_DIR environment variable
+.IP
+* /home/<user>/.config/adept
+.IP
+* Current directory
+.IP
+* .adept
+.IP
+* adobe\-digital\-editions directory
+.IP
+* .adobe\-digital\-editions directory
--- a/utils/utils_common.cpp
+++ b/utils/utils_common.cpp
@ -0,0 +1,164 @@
+/*
+  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 <libgen.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 pathExists(const char* path)
+{
+    struct stat _stat;
+    int ret = stat(path, &_stat);
+
+    return (ret == 0);
+}
+
+const char* findFile(const char* filename, bool inDefaultDirs)
+{
+    std::string path;
+
+    const char* adeptDir = getenv("ADEPT_DIR");
+    if (adeptDir && adeptDir[0])
+    {
+        path = adeptDir + std::string("/") + filename;
+        if (pathExists(path.c_str()))
+            return strdup(path.c_str());
+    }
+
+    path = gourou::DRMProcessor::getDefaultAdeptDir() + filename;
+    if (pathExists(path.c_str()))
+        return strdup(path.c_str());
+
+    if (pathExists(filename))
+        return strdup(filename);
+
+    if (!inDefaultDirs) return 0;
+
+    for (int i=0; i<(int)ARRAY_SIZE(defaultDirs); i++)
+    {
+        path = std::string(defaultDirs[i]) + filename;
+        if (pathExists(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], *_buffer;
+    int ret, ret2, 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;
+        do
+        {
+            _buffer = buffer;
+            ret2 = ::write(fdOut, _buffer, ret);
+            if (ret2 >= 0)
+            {
+                ret -= ret2;
+                _buffer += ret2;
+            }
+            else
+            {
+                EXCEPTION(gourou::CLIENT_FILE_ERROR, "Error writing " << out);
+            }
+        } while (ret);
+    }
+
+    close (fdIn);
+    close (fdOut);
+}
+
+void createPath(const char* filename)
+{
+    char* basepath = strdup(filename);
+    char* outputDir = dirname(basepath);
+    if (outputDir && !pathExists(outputDir))
+        mkpath(outputDir);
+    free(basepath);
+}
--- a/utils/utils_common.h
+++ b/utils/utils_common.h
@ -0,0 +1,72 @@
+/*
+  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 pathExists(const char* path);
+
+/**
+ * @brief Recursively created dir
+ */
+void mkpath(const char *dir);
+
+/**
+ * @brief Copy file in into file out
+ */
+void fileCopy(const char* in, const char* out);
+
+/**
+ * @brief Create intermediate directories if it does not exists
+ */
+void createPath(const char* filename);
+
+#endif
Author	SHA1	Message	Date
Radon Rosborough	d7bd98e719	Use -fmacro-prefix-map for utils The __FILE__ macro is used in the EXCEPTION macro to report the file name alongside error messages. This macro reports the file name exactly as it is passed to the compiler. For most source files in libgourou this is a nice relative path such as "src/libgourou.cpp". However, for EXCEPTION instances in libgourou_common.h, the compiler flag is "-I$(ROOT)/include", where $(ROOT) is an absolute path passed from the higher Makefile. This results in an absolute path to the build directory being hardcoded into the utils shared library and binaries, and reported in error messages. Besides being less readable than the more common relative paths, this triggers warnings from packaging tools that detect inadvertent references to temporary build directories that end up in compiled binaries and might indicate a bug. There is a GCC feature -fmacro-prefix-map which allows to perform substition on the values that are used for __FILE__. Use that option to strip out the absolute path component, without changing any functionality. The feature was added to GCC on 2018-01-18 and released in GCC 8.1.0. `7365279fca`	2026-03-14 13:51:40 +01:00
Grégory Soutadé	72cb22ad2a	Refresh curl download percent only when updated	2026-02-17 20:07:57 +01:00
Grégory Soutadé	b44b988966	Fix bug in utils with -o and -O options	2026-02-01 08:56:27 +01:00
Grégory Soutadé	76cab18667	Delete all referenced objects deleted by libgourou during PDF DRM removal	2026-01-31 20:31:44 +01:00
Jake Waksbaum	2387dff2cb	Add darwin support to Makefile	2026-01-25 10:15:35 +01:00
Jake Waksbaum	a7cfd3ef89	Replace sprintf with snprintf	2026-01-19 15:35:24 -05:00
Jake Waksbaum	772abdd2f9	Remove unused message field	2026-01-19 14:46:49 -05:00
Jake Waksbaum	1605656c73	Exception: fix constructor	2026-01-19 14:45:59 -05:00
Grégory Soutadé	8f0341d0bd	Some code formating	2026-01-18 15:44:20 +01:00
Grégory Soutadé	8061681705	Add a warning when ACSM file is expired	2026-01-18 15:22:02 +01:00
Grégory Soutadé	724961566c	Update version	2026-01-18 14:35:18 +01:00
Grégory Soutadé	98c511d0ca	Fix mkstemp unused result warning	2026-01-18 14:31:52 +01:00
Grégory Soutadé	db3e2179a9	Add PKCS1 Type 2 padding for Signing request	2026-01-18 14:31:52 +01:00
Grégory Soutadé	28aefba6d6	Update README.md	2025-11-17 22:29:35 +01:00
Grégory Soutadé	e0e2bc7430	Update uPDFParser git address	2025-08-25 20:37:52 +02:00
Grégory Soutadé	d3c90f03bb	Update README.md	2025-04-21 08:59:51 +02:00
Grégory Soutadé	469d378f9a	Update version to 0.8.7	2025-02-16 21:32:51 +01:00
Philipp Pagel	98b531a232	Fix setup.sh fix path for updfparser	2025-02-11 18:12:36 +01:00
Grégory Soutadé	956bad3068	Update README.md	2024-12-31 13:21:14 +01:00
Ismail Dönmez	d9a920b062	Use $HOME variable if it exists Signed-off-by: Ismail Dönmez <ismail@i10z.com>	2024-09-22 10:55:54 +02:00
Grégory Soutadé	204500117d	Typo fix	2024-09-19 08:41:15 +02:00
Grégory Soutadé	ce2cf4192a	Update README.md	2024-08-31 08:27:53 +02:00
Grégory Soutadé	68bf48df27	Update README.md	2024-08-27 21:48:39 +02:00
Grégory Soutadé	81faf1f9be	adept_loan_mgt: manage cases were name is empty	2024-04-15 07:37:28 +02:00
nicokosi	f60abf04d8	Fix typos in README.md	2024-04-11 06:05:23 +02:00
Grégory Soutadé	0d77cf55e1	Update version	2024-03-28 21:58:07 +01:00
Grégory Soutadé	86a79cc381	Remove whole EBX objects for PDF when removing DRM	2024-03-28 21:54:23 +01:00
Grégory Soutadé	68bf982b6f	Fix use after free in DRMProcessorClientImpl::sendHTTPRequest()	2024-01-24 19:13:22 +01:00
Grégory Soutadé	ef8c2644ca	Update version	2024-01-16 11:09:31 +01:00
Grégory Soutadé	e05639c09d	Support HTTP error codes != 200 (exception) and cookies in drmprocessorclientimpl	2024-01-06 09:25:11 +01:00
Grégory Soutadé	69865e005b	Register operatorURL only when certificate from operator is fetched	2024-01-06 09:23:03 +01:00
Grégory Soutadé	fd38e84da6	Fix for Android for adept_loan_mgt.cpp (strptime format)	2024-01-06 09:22:11 +01:00
Grégory Soutadé	92a67312bd	Update README.md	2023-09-06 21:21:43 +02:00
Grégory Soutadé	29d298b373	Update libgourou version	2023-09-06 21:17:06 +02:00
Grégory Soutadé	40dcb7a041	Add --no-notify option to utils	2023-09-06 21:17:06 +02:00
Grégory Soutadé	e0bb1bd4f8	Add notify server feature	2023-09-06 21:17:06 +02:00
Grégory Soutadé	9388d82138	Loan ID must be Fullfilment ID, not <loan> value(s)	2023-09-04 18:28:47 +02:00
Grégory Soutadé	c19279397f	Update README.md	2023-08-09 20:58:06 +02:00
Grégory Soutadé	bb5349d710	Update version	2023-08-08 20:14:23 +02:00
Grégory Soutadé	9a75213b49	Fix misuse of DESTDIR and PREFIX in Makefile	2023-08-08 20:13:03 +02:00
Grégory Soutadé	e06d20a392	DRM removal: Forgot to decrypt HexaString objects	2023-08-05 14:43:48 +02:00
Grégory Soutadé	a0f6324999	Try to fix GCC 13 compilation errors	2023-05-03 21:15:31 +02:00
Grégory Soutadé	c259cbd5a3	Add missing libgen.h in utils for basename() call	2023-03-28 20:32:05 +02:00
Grégory Soutadé	46afe771c7	Remove old pugixml include in utils Makefile	2023-01-15 09:51:00 +01:00
Grégory Soutadé	cad2189fc2	Typo fix	2023-01-14 18:21:06 +01:00
Grégory Soutadé	50bc16079f	Fix static build	2023-01-14 12:56:06 +01:00
Grégory Soutadé	1213b34250	Fix ADEPT path creation within adept_activate	2023-01-11 19:57:47 +01:00
Grégory Soutadé	a66dcb959c	Work on Makefile	2023-01-11 19:57:47 +01:00
Grégory Soutadé	84b01a5de3	Use system version of pugixml, not a checkouted one	2023-01-08 21:15:33 +01:00
Grégory Soutadé	be78d24236	Add man pages for utils	2023-01-08 21:05:22 +01:00
Grégory Soutadé	8aec5be244	Update Makefile to be more GNU/Linux style	2023-01-08 21:05:04 +01:00
Grégory Soutadé	3a0ab4b438	Update --help for utils and README.md	2023-01-08 21:04:23 +01:00
Grégory Soutadé	891ed05926	We can now specify directly file path for acsmdownloader and adept_remove (-f stille keeped for compatibility)	2023-01-08 20:58:41 +01:00
Grégory Soutadé	fc839e671a	Manage ACSM files that contains server internal error	2023-01-06 21:17:57 +01:00
Grégory Soutadé	ab5afa5003	Add new default ADEPT directories : /home/<user>/.config/adept and $ADEPT_DIR environment variable	2023-01-05 21:29:55 +01:00
Grégory Soutadé	937c27fc23	Fix some warnings	2023-01-05 21:27:50 +01:00
Grégory Soutadé	34216d1b6e	Check for target user before trying to decrypt a file	2023-01-05 21:26:05 +01:00
Berwyn	ffd2004cbb	Correct 'any book loaned' message	2023-01-04 20:23:57 +01:00
Grégory Soutadé	c41dd46ca7	Check for potential write error (or not buffer fully consumed)	2022-12-23 17:51:51 +01:00
Grégory Soutadé	e4bd73c03d	Add global option -D to utils, allowing to specify .adept directory instead of every single files. WARNING : -D has been changed by -d in adept_loan_mgt !	2022-12-21 21:23:42 +01:00
Grégory Soutadé	f65e8cd9eb	Check for target user before trying to decrypt a file	2022-12-21 21:06:03 +01:00
Grégory Soutadé	24bae89095	Factorize decryptADEPTKey() for ePub and PDF	2022-12-21 20:58:49 +01:00
Grégory Soutadé	afab1c0012	Fix over encrypted RSA key decryption algorithm	2022-12-21 20:15:11 +01:00
Grégory Soutadé	7878f91cdd	Add support for MacOS and old compilers (not supporting C++11). Main patch is from Samuel Marks.	2022-11-21 17:56:29 +01:00
Grégory Soutadé	6e3958f09e	Compute over encrypted key also for PDF files	2022-09-04 09:25:06 +02:00
Grégory Soutadé	2dbd4cc343	Update version	2022-08-29 15:19:23 +02:00
Grégory Soutadé	e28dc39a68	Make DRMProcessorClient API more consistent	2022-08-29 15:19:23 +02:00
Grégory Soutadé	7b8c7acbad	Compute first pass for encryptedKey if keyType attribute is set	2022-08-29 11:57:33 +02:00
Grégory Soutadé	56b3231f92	Add dumpBuffer() in libgourou_common	2022-08-29 11:56:47 +02:00
Grégory Soutadé	7084fb7025	Add fromHex() static function to ByteArray	2022-08-29 11:56:47 +02:00
Grégory Soutadé	7f5b787cb9	Add launcher util for AppImage	2022-08-29 11:56:47 +02:00
Grégory Soutadé	086e9b0610	Update version	2022-08-29 11:56:47 +02:00
Grégory Soutadé	600535d52c	Utils: Migration to OpenSSL3	2022-08-29 11:56:47 +02:00
Grégory Soutadé	57c3a58994	Add STATIC_NONCE option for build (developper mode)	2022-08-10 21:34:30 +02:00
Grégory Soutadé	210b265693	Forward DEBUG flag in Makefile	2022-08-10 21:34:30 +02:00
Grégory Soutadé	33bb983283	Change log levels names to avoid collisions	2022-08-10 21:34:30 +02:00
Grégory Soutadé	3c73b8ccb3	Update .gitignore Patch from Nguyễn Gia Phong	2022-07-03 09:22:06 +02:00
Grégory Soutadé	4acf401031	Don't clone base64 repository at first build, use a static version of Base64.h (not modified since many years) Patch from Nguyễn Gia Phong	2022-07-03 09:20:05 +02:00
Grégory Soutadé	7666d2a241	Update README	2022-06-12 15:03:14 +02:00
Grégory Soutadé	201ec69b11	Add scripts/update_lib.sh	2022-06-12 15:03:14 +02:00
Grégory Soutadé	5e018ddbd8	Update version	2022-06-08 12:24:38 +02:00
Grégory Soutadé	81563056e0	Update README	2022-06-08 12:24:38 +02:00
Grégory Soutadé	22880c71c6	Update Makefile to support separated OpenSSL3 compilation	2022-06-08 12:24:38 +02:00
Grégory Soutadé	4f288f4e24	Add support for OpenSSL 3	2022-06-05 15:29:20 +02:00
Grégory Soutadé	3d4e6e3918	Look for <loan> element in <permissions> node in addition to <loanToken> one	2022-06-05 13:51:57 +02:00
Grégory Soutadé	7b6b1471fe	Update version	2022-04-23 17:51:19 +02:00
Grégory Soutadé	4f9b2de5a5	Remove use of tempnam function and fix bug (bad check of rename return)	2022-04-23 17:41:54 +02:00
Grégory Soutadé	f568b5d3a8	Update README.md	2022-04-03 09:47:47 +02:00
Grégory Soutadé	8c413b4f34	Update .gitignore	2022-04-03 09:39:46 +02:00
Grégory Soutadé	8fe8ba2808	Add adept_loan_mgt util	2022-04-03 09:39:46 +02:00
Grégory Soutadé	570ad83747	Manage loan tokens	2022-04-03 09:39:46 +02:00
Grégory Soutadé	2e7e352e35	Utils: use trim functions from libgourou_common.h (avoid code duplication)	2022-04-03 09:29:40 +02:00
Grégory Soutadé	9556fe862f	Optimization : Add signature node into signNode() instead of returing it and be added after	2022-04-03 09:28:19 +02:00
Grégory Soutadé	2f2e4e193e	Add resume option to acsmdownloader	2022-03-23 21:05:56 +01:00
Grégory Soutadé	5d3112bc38	Fix bug in anonymous activation (need to set login method as "anonymous")	2022-03-19 15:19:27 +01:00
Grégory Soutadé	e149af9e17	Handle HTTP request connexion fails and download resuming on lost connection during transfer	2022-03-17 21:56:17 +01:00
Grégory Soutadé	1221b2a95a	Add optional fd parameter to sendHTTPRequest() in order to directly write received data in a buffer and not in an intermediate buffer	2022-03-17 21:55:02 +01:00
Grégory Soutadé	2ce6142596	Remove QtCore and QtNetwork, replace them by libcurl + libc	2022-03-16 22:45:33 +01:00
Grégory Soutadé	0f475423c0	Add a private option into adept_remove to provide encryption key	2022-03-12 23:04:16 +01:00
Grégory Soutadé	9b946a62b4	ADEPT remove : Don't decrypt XRef stream if there is one	2022-03-12 23:02:55 +01:00
Grégory Soutadé	432eb6f6cb	Add uPDFParser as dependency in Makefile	2022-03-12 22:59:27 +01:00
Grégory Soutadé	85b65f8d61	Pad ADEPT_LICENSE before trying to decode it	2022-03-03 21:07:25 +01:00
Grégory Soutadé	25f5049ab9	PDF DRM removing : Try to parse all objects wether they're or not in xref table	2022-03-02 20:38:31 +01:00
Grégory Soutadé	16a13eed89	Update version & README	2022-02-22 21:26:19 +01:00
Grégory Soutadé	479869b7f2	Fix a use after free in adept_activate : pass string destroyed too early	2022-02-22 20:58:40 +01:00
Grégory Soutadé	41f1a1e980	Fix a bug in adept_activate : cannot ask for interactive password if output directory already exists	2022-02-22 20:58:36 +01:00
Grégory Soutadé	9648157bf7	Remove README_package.md	2022-02-22 20:58:34 +01:00
Grégory Soutadé	a97a915bc8	Rework HTTP request loop events (Thanks Milian) and display download progression	2022-02-22 20:58:32 +01:00
Grégory Soutadé	a623a3d796	Skip files with inflate errors during ePub decryption	2022-02-22 20:58:30 +01:00
Grégory Soutadé	7d161133c3	Check for key size before files decryption	2022-02-22 20:58:26 +01:00
Grégory Soutadé	7d93817e49	Add PKCS8 error	2022-02-22 20:58:14 +01:00
Grégory Soutadé	ef62fb921a	Update version	2022-01-04 20:25:18 +01:00
Grégory Soutadé	e4c05bd6b3	Send a warning when libgourou can't handle encryption algorithm during a DRM removal attempt (+ keep encryption.xml in output)	2021-12-23 21:12:03 +01:00
Grégory Soutadé	f33891ef1c	Rework ByteArray::resize() to keep buffer data	2021-12-23 21:11:18 +01:00
Grégory Soutadé	9f62cf3447	Merge branch 'master' of soutade.fr:libgourou	2021-12-18 17:46:56 +01:00
Grégory Soutadé	36553cdd2c	Add support for anonymous accounts	2021-12-18 17:43:47 +01:00
Grégory Soutadé	ad6da2f8ab	Update .gitignore	2021-12-18 17:42:53 +01:00
Grégory Soutadé	b8a4ca222e	Add adept_remove util	2021-12-18 17:42:23 +01:00
Grégory Soutadé	f0ff97f7d7	Add support of DRM removal for PDF	2021-12-18 17:40:24 +01:00
Grégory Soutadé	4fe846f78e	Fix error in inflate() implementation. Update zlib error messages	2021-12-18 17:39:01 +01:00
Grégory Soutadé	19aacf98a2	Make Encryption/Decryption method of DRMProcessorClient generic	2021-12-18 17:37:37 +01:00
Grégory Soutadé	a751327dab	Add DRM removal for ePub only	2021-12-18 17:34:19 +01:00
Grégory Soutadé	a79bdd1e21	Fix copy/paste error	2021-12-08 20:30:02 +01:00
Grégory Soutadé	55ab41613e	Update inflate/deflate with right flag (Z_FINISH, no Z_SYNC_FLUSH)	2021-11-29 15:38:56 +01:00
Grégory Soutadé	8129ec4423	Update version	2021-11-29 09:31:18 +01:00
Grégory Soutadé	9ab66ddba9	Bugfix : rework inflate/deflate that makes produce data	2021-11-29 08:40:12 +01:00
Grégory Soutadé	e5697378e9	Update version	2021-11-27 10:29:22 +01:00
Grégory Soutadé	fd8ce841eb	Fix a nasty bug : fulfill reply data must be copied, not just referenced	2021-11-26 20:01:49 +01:00
Grégory Soutadé	8413b844db	Forgot to add libgourou.a as a dependency in utils Makefile	2021-11-26 20:01:21 +01:00
Grégory Soutadé	dd6001805f	Remove invalid characters from filename before writing a file	2021-11-26 20:00:36 +01:00
Grégory Soutadé	1f6e0ecdc8	Check for application/pdf as a substring and not as a full string for Content-Type and metadata in order to determine downloaded file type	2021-11-26 19:59:57 +01:00
Grégory Soutadé	89a5408c2d	Update README_package.md	2021-11-03 13:54:44 +01:00
Grégory Soutadé	56e4fda760	Utils: Forgot to pass responseHeaders parameters when we have a redirection	2021-11-03 13:54:04 +01:00
Grégory Soutadé	59c801da08	Fix STATIC_BUILD errors	2021-09-28 18:14:41 +02:00
Grégory Soutadé	f01bf9e837	Fix a bug : export key doesn't supports output in a target file	2021-09-28 15:14:18 +02:00
Grégory Soutadé	c57aba8061	Fix an error in utils Makefile : forgot -lz in static build	2021-09-28 15:02:50 +02:00
Grégory Soutadé	33ea9e7d65	Raise an exception if no EBX_HANDLER is found in PDF	2021-09-28 15:01:04 +02:00
Grégory Soutadé	dc15fc7197	Remove implicit handle of final \0 in ByteArray	2021-09-28 14:58:41 +02:00
Grégory Soutadé	47a38b1ebc	Update README	2021-09-09 21:00:43 +02:00
Grégory Soutadé	d8333531d2	Update README_package.md	2021-08-26 08:15:18 +02:00
Grégory Soutadé	cb4a26289e	Fix a bug in utils : bad management of mandatory files	2021-08-26 08:13:02 +02:00
Grégory Soutadé	fb812964e0	Bad repo URL & make command for uPDFParser library	2021-08-25 22:02:48 +02:00
Grégory Soutadé	8a2b22ca9b	Update Makefile and README.md	2021-08-25 21:54:52 +02:00
Grégory Soutadé	2ac917619e	Add "export private key" feature	2021-08-25 21:53:54 +02:00
Grégory Soutadé	3d9e343734	Add support for PDF (needs uPDFParser library)	2021-08-21 21:12:52 +02:00
Grégory Soutadé	8bc346d139	Add fetchLicenseServiceCertificate() because not all signing certificates (to be included into rights.xml) are the same than the one fetched at authentication	2021-08-21 20:46:09 +02:00
Grégory Soutadé	7f5a4900e0	Typo fix	2021-08-21 20:37:07 +02:00
Grégory Soutadé	d8f882a277	Fix a bug : gmtime() should used in place of localtime() to keep date in UTC and not local timezone	2021-08-12 21:11:40 +02:00
Grégory Soutadé	bdaceba2e0	Fix bad utils return value on error. Build network errors with a message and not just an error code.	2021-07-29 21:14:48 +02:00
Grégory Soutadé	b5eb0efd31	Force ACSM files to be parsed using UTF8 locale	2021-07-17 09:34:03 +02:00
Grégory Soutadé	20b4e69c3e	Rename too generic "activate" util in "adept_activate"	2021-07-16 20:44:40 +02:00
Grégory Soutadé	878e4e7453	ACSM data mut be unescaped before parsing Add a copy constructor to Exception Start an authentication when E_ADEPT_DISTRIBUTOR_AUTH error is received during fulfill Don't download external libraries if it already exists	2021-07-16 20:38:32 +02:00
Grégory Soutadé	1eebc88913	Update README.md	2021-07-12 21:26:53 +02:00
Grégory Soutadé	460f452783	Fix an error in hashNode : a tag can define multiple xml namespaces	2021-07-12 14:23:18 +02:00
Grégory Soutadé	8881a58c95	Handle 'Location' header reply in drmprocessorclientimpl	2021-07-10 12:51:36 +02:00
Grégory Soutadé	0e90b89382	v0.2 Fix a lot of things : * add common method signNode() and addNonde() * Try to auth to operator if not already set * Fix an error in ADEPT protocol : attributes must be hashed in alphabetical order, not in reverse one * Update DRMProcessorClient	2021-07-09 21:55:39 +02:00
Grégory Soutadé	7adc6a0fc1	Fix bug : -o option not handled in acsmdownloader	2021-07-08 12:59:56 +02:00
Grégory Soutadé	429fe34e8e	Add README_package.md	2021-07-06 22:16:26 +02:00
Grégory Soutadé	49a74cdd6f	Set default login method to "AdobeID"	2021-07-06 21:04:48 +02:00
Grégory Soutadé	c85db73583	Fix misplaced break into switch	2021-07-06 20:52:43 +02:00