Update version

Send a warning when libgourou can't handle encryption algorithm during a DRM removal attempt (+ keep encryption.xml in output)
Rework ByteArray::resize() to keep buffer data
2022-01-04 20:25:18 +01:00 · 2021-12-23 21:12:03 +01:00 · 2021-12-23 21:11:18 +01:00 · 2021-12-18 17:46:56 +01:00 · 2021-12-18 17:43:47 +01:00 · 2021-12-18 17:42:53 +01:00
15 changed files with 1080 additions and 234 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -5,4 +5,5 @@ lib
 *~
 utils/acsmdownloader
 utils/adept_activate
+utils/adept_remove
 .adept
--- a/README.md
+++ b/README.md
@@ -15,6 +15,7 @@ Main fucntions 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()_


 You can import configuration from (at least) :
@@ -26,7 +27,7 @@ Or create a new one. Be careful : there is a limited number of devices that can

 ePub are encrypted using a shared key : one account / multiple devices, so you can create and register a device into your computer and read downloaded (and encrypted) ePub file with your eReader configured using the same AdobeID account.

-For those who wants to remove DRM, you can export your private key and import it within [Calibre](https://calibre-ebook.com/) an its DeDRM plugin.
+For those who wants 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
@@ -65,6 +66,7 @@ BUILD_SHARED build libgourou.so if 1, nothing if 0, can be combined with BUILD_S

 * Default value

+
 Utils
 -----

@@ -85,6 +87,11 @@ To export your private key :
    export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$PWD
    ./utils/acsmdownloader --export-private-key [-o adobekey_1.der]

+To remove ADEPT DRM :
+
+    export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$PWD
+    ./utils/adept_remove -f <encryptedFile>
+

 Copyright
 ---------
--- a/README_package.md
+++ b/README_package.md
@@ -41,12 +41,10 @@ To export your private key :
    export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$PWD
    ./acsmdownloader --export-private-key [-o adobekey_1.der]

+To remove ADEPT DRM :

-Sources
-------
-
-http://indefero.soutade.fr/p/libgourou
-
+    export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$PWD
+    ./adept_remove -f <encryptedFile>


 Copyright
@@ -69,4 +67,3 @@ Special thanks
 --------------

  * _Jens_ for all test samples and utils testing
-  
--- 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
@@ -119,14 +130,38 @@ namespace gourou
 	void append(const std::string& str);

 	/**
-	 * @brief Get internal data. Must bot be modified nor freed
+	 * @brief Get internal data. Must bot 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 +170,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/drmprocessorclient.h
+++ b/include/drmprocessorclient.h
@@ -35,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
 	 */
@@ -128,6 +128,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
 	 *
@@ -196,14 +212,20 @@ namespace gourou
    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
@@ -214,52 +236,53 @@ namespace gourou
 	 * @param dataOut        Encrypted data
 	 * @param dataOutLength  Length of encrypted data
 	 */
-	virtual void AESEncrypt(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;
+	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,
-				     const unsigned char* key, unsigned int keyLength,
-				     const unsigned char* iv=0, unsigned int ivLength=0) = 0;
+	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,
-			 unsigned char* dataOut, unsigned int* dataOutLength) = 0;
+	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 Finalizeencryption (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
@@ -270,47 +293,47 @@ namespace gourou
 	 * @param dataOut        Encrypted data
 	 * @param dataOutLength  Length of encrypted data
 	 */
-	virtual void AESDecrypt(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;
+	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,
-				     const unsigned char* key, unsigned int keyLength,
-				     const unsigned char* iv=0, unsigned int ivLength=0) = 0;
+	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,
-				 unsigned char* dataOut, unsigned int* dataOutLength) = 0;
+	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;
    };


@@ -331,19 +354,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
@@ -367,7 +390,7 @@ namespace gourou
 	 * @param result         Zipped data
 	 * @param wbits          Window bits value for libz
 	 */
-	virtual void inflate(std::string data, gourou::ByteArray& result,
+	virtual void inflate(gourou::ByteArray& data, gourou::ByteArray& result,
 			     int wbits=-15) = 0;
 	
 	/**
@@ -378,7 +401,7 @@ namespace gourou
 	 * @param wbits          Window bits value for libz
 	 * @param compressionLevel Compression level for libz
 	 */
-	virtual void deflate(std::string data, gourou::ByteArray& result,
+	virtual void deflate(gourou::ByteArray& data, gourou::ByteArray& result,
 			     int wbits=-15, int compressionLevel=8) = 0;
    };
    
--- a/include/libgourou.h
+++ b/include/libgourou.h
@@ -40,7 +40,7 @@
 #define ACS_SERVER              "http://adeactivate.adobe.com/adept"
 #endif

-#define LIBGOUROU_VERSION       "0.4.5"
+#define LIBGOUROU_VERSION       "0.5.1"

 namespace gourou
 {
@@ -164,6 +164,9 @@ namespace gourou
 	 */
 	std::string serializeRSAPrivateKey(void* rsa);

+	/**
+	 * @brief Export clear private license key into path
+	 */
 	void exportPrivateLicenseKey(std::string path);
 	
 	/**
@@ -181,6 +184,12 @@ namespace gourou
 	 */
 	DRMProcessorClient* getClient() { return client; }
 		
+	/**
+	 * @brief Remove ADEPT DRM.
+	 * Warning: for PDF format, filenameIn must be different than filenameOut
+	 */
+	void removeDRM(const std::string& filenameIn, const std::string& filenameOut, ITEM_TYPE type);
+	
    private:
 	gourou::DRMProcessorClient* client;
        gourou::Device* device;
@@ -204,6 +213,13 @@ namespace gourou
 	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 decryptADEPTKey(const std::string& encryptedKey, unsigned char* decryptedKey);
+	void removeEPubDRM(const std::string& filenameIn, const std::string& filenameOut);
+	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);
    };
 }

--- a/include/libgourou_common.h
+++ b/include/libgourou_common.h
@@ -112,6 +112,15 @@ namespace gourou
 	CLIENT_NETWORK_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
+    };
+
    /**
     * Generic exception class
     */
--- a/src/bytearray.cpp
+++ b/src/bytearray.cpp
@@ -24,33 +24,48 @@

 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);

-	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());
    }

    void ByteArray::initData(const unsigned char* data, unsigned int length)
    {
-	_data = new unsigned char[length];
-	memcpy((void*)_data, data, 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 +73,7 @@ namespace gourou
    
    ByteArray::ByteArray(const ByteArray& other)
    {
+	this->_useMalloc = other._useMalloc;
 	this->_data = other._data;
 	this->_length = other._length;

@@ -68,6 +84,7 @@ namespace gourou
    {
 	delRef();
 	
+	this->_useMalloc = other._useMalloc;
 	this->_data = other._data;
 	this->_length = other._length;

@@ -97,7 +114,10 @@ namespace gourou
 	
 	if (refCounter[_data] == 1)
 	{
-	    delete[] _data;
+	    if (_useMalloc)
+		free(_data);
+	    else
+		delete[] _data;
 	    refCounter.erase(_data);
 	}
 	else
@@ -152,22 +172,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/libgourou.cpp
+++ b/src/libgourou.cpp
@@ -35,7 +35,6 @@
 #define ASN_TEXT        0x04
 #define ASN_ATTRIBUTE   0x05

-
 namespace gourou
 {
    GOUROU_LOG_LEVEL logLevel = WARN;
@@ -597,7 +596,7 @@ namespace gourou

 	GOUROU_LOG(INFO, "Download into " << path);

-	std::string rightsStr = item->getRights();
+	ByteArray rightsStr(item->getRights());

 	if (item->getMetadata("format").find("application/pdf") != std::string::npos)
 	    res = PDF;
@@ -851,10 +850,10 @@ namespace gourou
 	// Generate IV in front
 	client->randBytes(encrypted_data, 16);
 	    
-	client->AESEncrypt(CryptoInterface::CHAIN_CBC,
-			   deviceKey, 16, encrypted_data, 16,
-			   data, len,
-			   encrypted_data+16, &outLen);
+	client->Encrypt(CryptoInterface::ALGO_AES, CryptoInterface::CHAIN_CBC,
+			deviceKey, 16, encrypted_data, 16,
+			data, len,
+			encrypted_data+16, &outLen);

 	ByteArray res(encrypted_data, outLen+16);

@@ -870,10 +869,10 @@ namespace gourou
 	const unsigned char* deviceKey = device->getDeviceKey();
 	unsigned char* decrypted_data = new unsigned char[len-16];

-	client->AESDecrypt(CryptoInterface::CHAIN_CBC,
-			   deviceKey, 16, data, 16,
-			   data+16, len-16,
-			   decrypted_data, &outLen);
+	client->Decrypt(CryptoInterface::ALGO_AES, CryptoInterface::CHAIN_CBC,
+			deviceKey, 16, data, 16,
+			data+16, len-16,
+			decrypted_data, &outLen);

 	ByteArray res(decrypted_data, outLen);

@@ -925,4 +924,302 @@ namespace gourou

    int DRMProcessor::getLogLevel() {return (int)gourou::logLevel;}
    void DRMProcessor::setLogLevel(int logLevel) {gourou::logLevel = (GOUROU_LOG_LEVEL)logLevel;}
+
+    void DRMProcessor::decryptADEPTKey(const std::string& encryptedKey, unsigned char* decryptedKey)
+    {
+	ByteArray arrayEncryptedKey = ByteArray::fromBase64(encryptedKey);
+
+	std::string privateKeyData = user->getPrivateLicenseKey();
+	ByteArray privateRSAKey = ByteArray::fromBase64(privateKeyData);
+
+	ByteArray deviceKey(device->getDeviceKey(), Device::DEVICE_KEY_SIZE);
+	std::string pkcs12 = user->getPKCS12();
+	
+	client->RSAPrivateDecrypt(privateRSAKey.data(), privateRSAKey.length(),
+				  RSAInterface::RSA_KEY_PKCS12, deviceKey.toBase64().data(),
+				  arrayEncryptedKey.data(), arrayEncryptedKey.length(), decryptedKey);
+
+	if (decryptedKey[0] != 0x00 || decryptedKey[1] != 0x02 ||
+	    decryptedKey[RSA_KEY_SIZE-16-1] != 0x00)
+	    EXCEPTION(DRM_ERR_ENCRYPTION_KEY, "Unable to retrieve encryption key");
+    }
+
+    
+    void DRMProcessor::removeEPubDRM(const std::string& filenameIn, const std::string& filenameOut)
+    {
+	ByteArray zipData;
+	bool removeEncryptionXML = true;
+	void* zipHandler = client->zipOpen(filenameOut);
+
+	client->zipReadFile(zipHandler, "META-INF/rights.xml", zipData);
+	pugi::xml_document rightsDoc;
+	rightsDoc.load_string((const char*)zipData.data());
+
+	std::string encryptedKey = extractTextElem(rightsDoc, "/adept:rights/licenseToken/encryptedKey");
+	unsigned char decryptedKey[RSA_KEY_SIZE];
+
+	decryptADEPTKey(encryptedKey, decryptedKey);
+	
+	client->zipReadFile(zipHandler, "META-INF/encryption.xml", zipData);
+	pugi::xml_document encryptionDoc;
+	encryptionDoc.load_string((const char*)zipData.data());
+
+	pugi::xpath_node_set nodeSet = encryptionDoc.select_nodes("//EncryptedData");
+
+	for (pugi::xpath_node_set::const_iterator it = nodeSet.begin();
+	     it != nodeSet.end(); ++it)
+	{
+	    pugi::xml_node encryptionMethod = it->node().child("EncryptionMethod");
+	    pugi::xml_node cipherReference  = it->node().child("CipherData").child("CipherReference");
+
+	    std::string encryptionType = encryptionMethod.attribute("Algorithm").value();
+	    std::string encryptedFile = cipherReference.attribute("URI").value();
+	    
+	    if (encryptionType == "")
+	    {
+		EXCEPTION(DRM_MISSING_PARAMETER, "Missing Algorithm attribute in encryption.xml");
+	    }
+	    else if (encryptionType == "http://www.w3.org/2001/04/xmlenc#aes128-cbc")
+	    {
+		if (encryptedFile == "")
+		{
+		    EXCEPTION(DRM_MISSING_PARAMETER, "Missing URI attribute in encryption.xml");
+		}
+
+		GOUROU_LOG(DEBUG, "Encrypted file " << encryptedFile);
+
+		client->zipReadFile(zipHandler, encryptedFile, zipData, false);
+	    
+		unsigned char* _data = zipData.data();
+		ByteArray clearData(zipData.length()-16+1, true); /* Reserve 1 byte for 'Z' */
+		unsigned char* _clearData = clearData.data();
+		gourou::ByteArray inflateData(true);
+		unsigned int dataOutLength;
+
+		client->Decrypt(CryptoInterface::ALGO_AES, CryptoInterface::CHAIN_CBC,
+				decryptedKey+RSA_KEY_SIZE-16, 16, /* Key */
+				_data, 16, /* IV */
+				&_data[16], zipData.length()-16,
+				_clearData, &dataOutLength);
+
+		// Add 'Z' at the end, done in ineptepub.py
+		_clearData[dataOutLength] = 'Z';
+		clearData.resize(dataOutLength+1);
+
+		client->inflate(clearData, inflateData);
+		
+		client->zipWriteFile(zipHandler, encryptedFile, inflateData);
+
+		it->node().parent().remove_child(it->node());
+	    }
+	    else
+	    {
+		GOUROU_LOG(WARN, "Unsupported encryption algorithm " << encryptionType << ", for file " << encryptedFile);
+		removeEncryptionXML = false;
+	    }
+	}
+	
+	client->zipDeleteFile(zipHandler, "META-INF/rights.xml");
+	if (removeEncryptionXML)
+	    client->zipDeleteFile(zipHandler, "META-INF/encryption.xml");
+	else
+	{
+	    StringXMLWriter xmlWriter;
+	    encryptionDoc.save(xmlWriter, "  ");
+	    std::string xmlStr = xmlWriter.getResult();
+	    ByteArray ba(xmlStr);
+	    client->zipWriteFile(zipHandler, "META-INF/encryption.xml", ba);
+	}
+	
+	client->zipClose(zipHandler);
+    }
+    
+    void DRMProcessor::generatePDFObjectKey(int version,
+					    const unsigned char* masterKey, unsigned int masterKeyLength,
+					    int objectId, int objectGenerationNumber,
+					    unsigned char* keyOut)
+    {
+	switch(version)
+	{
+	case 4:
+	    ByteArray toHash(masterKey, masterKeyLength);
+	    uint32_t _objectId = objectId;
+	    uint32_t _objectGenerationNumber = objectGenerationNumber;
+	    toHash.append((const unsigned char*)&_objectId, 3); // Fill 3 bytes
+	    toHash.append((const unsigned char*)&_objectGenerationNumber, 2); // Fill 2 bytes
+
+	    client->digest("md5", toHash.data(), toHash.length(), keyOut);
+	    break;
+	}
+    }
+    
+    void DRMProcessor::removePDFDRM(const std::string& filenameIn, const std::string& filenameOut)
+    {
+	uPDFParser::Parser parser;
+	bool EBXHandlerFound = false;
+
+	if (filenameIn == filenameOut)
+	{
+	    EXCEPTION(DRM_IN_OUT_EQUALS, "PDF IN must be different of PDF OUT");		    
+	}
+	
+	try
+	{
+	    GOUROU_LOG(DEBUG, "Parse PDF");
+	    parser.parse(filenameIn);
+	}
+	catch(std::invalid_argument& e)
+	{
+	    GOUROU_LOG(ERROR, "Invalid PDF");
+	    return;
+	}
+
+	uPDFParser::Integer* ebxVersion;
+	std::vector<uPDFParser::Object*> objects = parser.objects();
+	std::vector<uPDFParser::Object*>::reverse_iterator it;
+	unsigned char decryptedKey[RSA_KEY_SIZE];
+
+	for(it = objects.rbegin(); it != objects.rend(); it++)
+	{
+	    // Update EBX_HANDLER with rights
+	    if ((*it)->hasKey("Filter") && (**it)["Filter"]->str() == "/EBX_HANDLER")
+	    {
+		EBXHandlerFound = true;
+		uPDFParser::Object* ebx = *it;
+
+		ebxVersion  = (uPDFParser::Integer*)(*ebx)["V"];
+		if (ebxVersion->value() != 4)
+		{
+		    EXCEPTION(DRM_VERSION_NOT_SUPPORTED, "EBX encryption version not supported " << ebxVersion->value());		    
+		}
+
+		if (!(ebx->hasKey("ADEPT_LICENSE")))
+		{
+		    EXCEPTION(DRM_ERR_ENCRYPTION_KEY, "No ADEPT_LICENSE found");
+		}
+
+		uPDFParser::String* licenseObject = (uPDFParser::String*)(*ebx)["ADEPT_LICENSE"];
+
+		ByteArray zippedData = ByteArray::fromBase64(licenseObject->value());
+		ByteArray rightsStr;
+		client->inflate(zippedData, rightsStr);
+
+		pugi::xml_document rightsDoc;
+		rightsDoc.load_string((const char*)rightsStr.data());
+
+		std::string encryptedKey = extractTextElem(rightsDoc, "/adept:rights/licenseToken/encryptedKey");
+
+		decryptADEPTKey(encryptedKey, decryptedKey);
+		break;
+	    }
+	}
+
+	if (!EBXHandlerFound)
+	{
+	    EXCEPTION(DRM_ERR_ENCRYPTION_KEY, "EBX_HANDLER not found");
+	}
+
+	std::vector<uPDFParser::XRefValue> xrefTable = parser.xrefTable();
+	std::vector<uPDFParser::XRefValue>::iterator xrefIt;
+	
+	for(xrefIt = xrefTable.begin(); xrefIt != xrefTable.end(); xrefIt++)
+	{
+	    GOUROU_LOG(DEBUG, "XREF obj " << (*xrefIt).objectId() << " used " << (*xrefIt).used());
+	    
+	    if (!(*xrefIt).used())
+		continue;
+
+	    uPDFParser::Object* object = (*xrefIt).object();
+
+	    if (!object)
+	    {
+		GOUROU_LOG(DEBUG, "No object");
+		continue;
+	    }
+	    
+	    unsigned char tmpKey[16];
+
+	    generatePDFObjectKey(ebxVersion->value(),
+				 decryptedKey+RSA_KEY_SIZE-16, 16,
+				 object->objectId(), object->generationNumber(),
+				 tmpKey);
+
+	    uPDFParser::Dictionary& dictionary = object->dictionary();
+	    std::map<std::string, uPDFParser::DataType*>& dictValues = dictionary.value();
+	    std::map<std::string, uPDFParser::DataType*>::iterator dictIt;
+	    std::map<std::string, uPDFParser::DataType*> decodedStrings;
+	    std::string string;
+	    
+	    /* Parse dictionary */
+	    for (dictIt = dictValues.begin(); dictIt != dictValues.end(); dictIt++)
+	    {
+		uPDFParser::DataType* dictData = dictIt->second;
+		if (dictData->type() == uPDFParser::DataType::STRING)
+		{
+		    string = ((uPDFParser::String*) dictData)->unescapedValue();
+		    
+		    unsigned char* encryptedData = (unsigned char*)string.c_str();
+		    unsigned int dataLength = string.size();
+		    unsigned char* clearData = new unsigned char[dataLength];
+		    unsigned int dataOutLength;
+
+		    GOUROU_LOG(DEBUG, "Decrypt string " << dictIt->first << " " << dataLength);
+
+		    client->Decrypt(CryptoInterface::ALGO_RC4, CryptoInterface::CHAIN_ECB,
+				    tmpKey, 16, /* Key */
+				    NULL, 0, /* IV */
+				    encryptedData, dataLength,
+				    clearData, &dataOutLength);
+
+		    decodedStrings[dictIt->first] = new uPDFParser::String(
+			std::string((const char*)clearData, dataOutLength));
+
+		    delete[] clearData;
+		}
+	    }
+		
+	    for (dictIt = decodedStrings.begin(); dictIt != decodedStrings.end(); dictIt++)
+		dictionary.replace(dictIt->first, dictIt->second);
+	    
+	    std::vector<uPDFParser::DataType*>::iterator datasIt;
+	    std::vector<uPDFParser::DataType*>& datas = (*xrefIt).object()->data();
+	    uPDFParser::Stream* stream;
+	    
+	    for (datasIt = datas.begin(); datasIt != datas.end(); datasIt++)
+	    {
+		if ((*datasIt)->type() != uPDFParser::DataType::STREAM)
+		    continue;
+
+		GOUROU_LOG(DEBUG, "Decrypt stream id " << object->objectId());
+
+		stream = (uPDFParser::Stream*) (*datasIt);
+		unsigned char* encryptedData = stream->data();
+		unsigned int dataLength = stream->dataLength();
+		unsigned char* clearData = new unsigned char[dataLength];
+		unsigned int dataOutLength;
+		
+		client->Decrypt(CryptoInterface::ALGO_RC4, CryptoInterface::CHAIN_ECB,
+				tmpKey, 16, /* Key */
+				NULL, 0, /* IV */
+				encryptedData, dataLength,
+				clearData, &dataOutLength);
+		
+		stream->setData(clearData, dataOutLength, true);
+	    }
+	}
+
+	uPDFParser::Object& trailer = parser.getTrailer();
+	trailer.deleteKey("Encrypt");
+
+	parser.write(filenameOut);
+    }
+    
+    void DRMProcessor::removeDRM(const std::string& filenameIn, const std::string& filenameOut,
+				 ITEM_TYPE type)
+    {
+	if (type == PDF)
+	    removePDFDRM(filenameIn, filenameOut);
+	else
+	    removeEPubDRM(filenameIn, filenameOut);
+    }
 }
--- a/src/user.cpp
+++ b/src/user.cpp
@@ -50,7 +50,6 @@ namespace gourou {
 	    deviceFingerprint = gourou::extractTextElem(activationDoc, "//fingerprint", 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 +60,11 @@ namespace gourou {
 		    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)
--- a/utils/Makefile
+++ b/utils/Makefile
@@ -1,5 +1,5 @@

-TARGETS=acsmdownloader adept_activate
+TARGETS=acsmdownloader adept_activate adept_remove

 CXXFLAGS=-Wall `pkg-config --cflags Qt5Core Qt5Network` -fPIC -I$(ROOT)/include -I$(ROOT)/lib/pugixml/src/

@@ -18,12 +18,17 @@ else
 CXXFLAGS += -O2
 endif

+COMMON_DEPS = drmprocessorclientimpl.cpp $(STATIC_DEP)
+
 all: $(TARGETS)

-acsmdownloader: drmprocessorclientimpl.cpp acsmdownloader.cpp $(STATIC_DEP)
+acsmdownloader: acsmdownloader.cpp $(COMMON_DEPS)
 	$(CXX) $(CXXFLAGS) $^ $(LDFLAGS) -o $@

-adept_activate: drmprocessorclientimpl.cpp adept_activate.cpp $(STATIC_DEP) 
+adept_activate: adept_activate.cpp $(COMMON_DEPS)
+	$(CXX) $(CXXFLAGS) $^ $(LDFLAGS) -o $@
+
+adept_remove: adept_remove.cpp $(COMMON_DEPS)
 	$(CXX) $(CXXFLAGS) $^ $(LDFLAGS) -o $@

 clean:
--- a/utils/adept_activate.cpp
+++ b/utils/adept_activate.cpp
@@ -144,8 +144,9 @@ 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 << "Usage: " << cmd << " (-a|--anonymous) | ( (-u|--username) username [(-p|--password) password] ) [(-O|--output-dir) dir] [(-r|--random-serial)] [(-v|--verbose)] [(-h|--help)]" << std::endl << std::endl;
    
+    std::cout << "  " << "-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;
@@ -174,10 +175,12 @@ 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' },
@@ -189,12 +192,15 @@ int main(int argc, char** argv)
 	    {0,               0,                 0,  0 }
 	};

-	c = getopt_long(argc, argv, "u:p:O:H:rvVh",
+	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;
@@ -227,15 +233,22 @@ int main(int argc, char** argv)
   
    gourou::DRMProcessor::setLogLevel(verbose);

-    if (!username)
+    if ((!username && !anonymous) ||
+	(username && anonymous))
    {
 	usage(argv[0]);
 	return -1;
    }

+    if (anonymous)
+    {
+	username = "anonymous";
+	password = "";
+    }
+    
    if (!_outputDir || _outputDir[0] == 0)
    {
-	outputDir = abspath(DEFAULT_ADEPT_DIR);
+	outputDir = strdup(abspath(DEFAULT_ADEPT_DIR));
    }
    else
    {
@@ -245,14 +258,36 @@ int main(int argc, char** argv)
 	    QFile file(_outputDir);
 	    // realpath doesn't works if file/dir doesn't exists
 	    if (file.exists())
-		outputDir = realpath(_outputDir, 0);
+		outputDir = strdup(realpath(_outputDir, 0));
 	    else
-		outputDir = abspath(_outputDir);
+		outputDir = strdup(abspath(_outputDir));
 	}
 	else
 	    outputDir = strdup(_outputDir);
    }

+    QCoreApplication app(argc, argv);
+
+    QFile file(outputDir);
+    if (file.exists())
+    {
+	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];
@@ -261,13 +296,13 @@ int main(int argc, char** argv)
 	password = pass.c_str();
    }
        
-    QCoreApplication app(argc, argv);
-    
    ADEPTActivate activate(&app);
    QThreadPool::globalInstance()->start(&activate);

    ret = app.exec();

+end:
+    
    free((void*)outputDir);
    return ret;
 }
--- a/utils/adept_remove.cpp
+++ b/utils/adept_remove.cpp
@@ -0,0 +1,304 @@
+/*
+  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 <iostream>
+
+#include <QFile>
+#include <QDir>
+#include <QCoreApplication>
+#include <QRunnable>
+#include <QThreadPool>
+#include <QTemporaryFile>
+
+#include <libgourou.h>
+#include <libgourou_common.h>
+#include "drmprocessorclientimpl.h"
+
+#define ARRAY_SIZE(arr) (sizeof(arr)/sizeof(arr[0]))
+
+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 const char* defaultDirs[]  = {
+    ".adept/",
+    "./adobe-digital-editions/",
+    "./.adobe-digital-editions/"
+};
+
+static inline bool endsWith(const std::string& s, const std::string& suffix)
+{
+    return s.rfind(suffix) == std::abs((int)(s.size()-suffix.size()));
+}
+
+class ADEPTRemove: public QRunnable
+{
+public:
+    ADEPTRemove(QCoreApplication* app):
+	app(app)
+    {
+	setAutoDelete(false);
+    }
+   
+    void 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 = std::string(inputFile);
+	    else
+		filename = outputFile;
+	    
+	    if (outputDir)
+	    {
+		QDir dir(outputDir);
+		if (!dir.exists(outputDir))
+		    dir.mkpath(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);
+	    }
+	    
+	    if (inputFile != filename)
+	    {
+		QFile::remove(filename.c_str());
+		if (!QFile::copy(inputFile, filename.c_str()))
+		{
+		    EXCEPTION(gourou::DRM_FILE_ERROR, "Unable to copy " << inputFile << " into " << filename);
+		}
+		processor.removeDRM(inputFile, filename, type);
+		std::cout << "DRM removed into new file " << filename << std::endl;
+	    }
+	    else
+	    {
+		// Use temp file for PDF
+		if (type == gourou::DRMProcessor::ITEM_TYPE::PDF)
+		{
+		    QTemporaryFile tempFile;
+		    tempFile.open();
+		    tempFile.setAutoRemove(false); // In case of failure
+		    processor.removeDRM(inputFile, tempFile.fileName().toStdString(), type);
+		    /* Original file must be removed before doing a copy... */
+		    QFile origFile(inputFile);
+		    origFile.remove();
+		    if (!QFile::copy(tempFile.fileName(), filename.c_str()))
+		    {
+			EXCEPTION(gourou::DRM_FILE_ERROR, "Unable to copy " << tempFile.fileName().toStdString() << " into " << filename);
+		    }
+		    tempFile.setAutoRemove(true);
+		}
+		else
+		    processor.removeDRM(inputFile, filename, type);
+		std::cout << "DRM removed from " << filename << std::endl;
+	    }
+	} catch(std::exception& e)
+	{
+	    std::cout << e.what() << std::endl;
+	    ret = 1;
+	}
+
+	this->app->exit(ret);
+    }
+
+private:
+    QCoreApplication* app;
+};	      
+
+static const char* findFile(const char* filename, bool inDefaultDirs=true)
+{
+    QFile file(filename);
+
+    if (file.exists())
+	return strdup(filename);
+
+    if (!inDefaultDirs) return 0;
+    
+    for (int i=0; i<(int)ARRAY_SIZE(defaultDirs); i++)
+    {
+	QString path = QString(defaultDirs[i]) + QString(filename);
+	file.setFileName(path);
+	if (file.exists())
+	    return strdup(path.toStdString().c_str());
+    }
+    
+    return 0;
+}
+
+static void version(void)
+{
+    std::cout << "Current libgourou version : " << gourou::DRMProcessor::VERSION << std::endl ;
+}
+
+static void usage(const char* cmd)
+{
+    std::cout << "Remove ADEPT DRM (from Adobe) of EPUB/PDF file" << std::endl;
+    
+    std::cout << "Usage: " << cmd << " [(-d|--device-file) device.xml] [(-a|--activation-file) activation.xml] [(-k|--device-key-file) devicesalt] [(-O|--output-dir) dir] [(-o|--output-file) output(.epub|.pdf|.der)] [(-v|--verbose)] [(-h|--help)] (-f|--input-file) file(.epub|pdf)" << std::endl << std::endl;
+    
+    std::cout << "  " << "-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 filename (default inplace DRM removal>)" << std::endl;
+    std::cout << "  " << "-f|--input-file"      << "\t"   << "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 << 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 << "  * 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();
+
+    while (1) {
+	int option_index = 0;
+	static struct option long_options[] = {
+	    {"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' },
+	    {"export-private-key",no_argument,      0,  'e' },
+	    {"verbose",          no_argument,       0,  'v' },
+	    {"version",          no_argument,       0,  'V' },
+	    {"help",             no_argument,       0,  'h' },
+	    {0,                  0,                 0,  0 }
+	};
+
+	c = getopt_long(argc, argv, "d:a:k:O:o:f:evVh",
+                        long_options, &option_index);
+	if (c == -1)
+	    break;
+
+	switch (c) {
+	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 '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 (!inputFile || (outputDir && !outputDir[0]) ||
+	(outputFile && !outputFile[0]))
+    {
+	usage(argv[0]);
+	return -1;
+    }
+
+    QCoreApplication app(argc, argv);
+    ADEPTRemove remover(&app);
+
+    int i;
+    bool hasErrors = false;
+    const char* orig;
+    for (i=0; i<(int)ARRAY_SIZE(files); i++)
+    {
+	orig = *files[i];
+	*files[i] = findFile(*files[i]);
+	if (!*files[i])
+	{
+	    std::cout << "Error : " << orig << " doesn't exists, did you activate your device ?" << std::endl;
+	    ret = -1;
+	    hasErrors = true;
+	}
+    }
+
+    if (hasErrors)
+	goto end;
+       
+    QThreadPool::globalInstance()->start(&remover);
+
+    ret = app.exec();
+
+end:
+    for (i=0; i<(int)ARRAY_SIZE(files); i++)
+    {
+	if (*files[i])
+	    free((void*)*files[i]);
+    }
+
+    return ret;
+}
--- a/utils/drmprocessorclientimpl.cpp
+++ b/utils/drmprocessorclientimpl.cpp
@@ -37,8 +37,8 @@
 #include <QNetworkAccessManager>
 #include <QFile>

-#include <zip.h>
 #include <zlib.h>
+#include <zip.h>

 #include <libgourou_common.h>
 #include <libgourou_log.h>
@@ -47,23 +47,28 @@
 /* Digest interface */
 void* DRMProcessorClientImpl::createDigest(const std::string& digestName)
 {
-    EVP_MD_CTX *sha_ctx = EVP_MD_CTX_new();
+    EVP_MD_CTX *md_ctx = EVP_MD_CTX_new();
    const EVP_MD* md = EVP_get_digestbyname(digestName.c_str());
-    EVP_DigestInit(sha_ctx, md);

-    return sha_ctx;
+    if (EVP_DigestInit(md_ctx, md) != 1)
+    {
+	EVP_MD_CTX_free(md_ctx);
+	return 0;
+    }
+
+    return md_ctx;
 }

 int DRMProcessorClientImpl::digestUpdate(void* handler, unsigned char* data, unsigned int length)
 {
-    return EVP_DigestUpdate((EVP_MD_CTX *)handler, data, length);
+    return (EVP_DigestUpdate((EVP_MD_CTX *)handler, data, length)) ? 0 : -1;
 }

 int DRMProcessorClientImpl::digestFinalize(void* handler, unsigned char* digestOut)
 {
    int res = EVP_DigestFinal((EVP_MD_CTX *)handler, digestOut, NULL);
    EVP_MD_CTX_free((EVP_MD_CTX *)handler);
-    return res;
+    return (res == 1) ? 0 : -1;
 }

 int DRMProcessorClientImpl::digest(const std::string& digestName, unsigned char* data, unsigned int length, unsigned char* digestOut)
@@ -163,8 +168,39 @@ void DRMProcessorClientImpl::RSAPrivateEncrypt(const unsigned char* RSAKey, unsi

    if (gourou::logLevel >= gourou::DEBUG)
    {
-	printf("Sig : ");
-	for(int i=0; i<(int)sizeof(res); i++)
+	printf("Encrypted : ");
+	for(int i=0; i<ret; i++)
+	    printf("%02x ", res[i]);
+	printf("\n");
+    }
+}
+			    
+void DRMProcessorClientImpl::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)
+{
+    BIO* mem=BIO_new_mem_buf(RSAKey, RSAKeyLength);
+    PKCS8_PRIV_KEY_INFO* p8inf = d2i_PKCS8_PRIV_KEY_INFO_bio(mem, NULL);
+
+    if (!p8inf)
+	EXCEPTION(gourou::CLIENT_INVALID_PKCS12, ERR_error_string(ERR_get_error(), NULL));
+
+    EVP_PKEY* pkey = EVP_PKCS82PKEY(p8inf);
+    RSA * rsa;
+    int ret;
+
+    rsa = EVP_PKEY_get1_RSA(pkey);
+
+    ret = RSA_private_decrypt(dataLength, data, res, rsa, RSA_NO_PADDING);
+
+    if (ret < 0)
+	EXCEPTION(gourou::CLIENT_RSA_ERROR, ERR_error_string(ERR_get_error(), NULL));
+
+    if (gourou::logLevel >= gourou::DEBUG)
+    {
+	printf("Decrypted : ");
+	for(int i=0; i<ret; i++)
 	    printf("%02x ", res[i]);
 	printf("\n");
    }
@@ -252,83 +288,106 @@ void DRMProcessorClientImpl::extractCertificate(const unsigned char* RSAKey, uns
 }

 /* Crypto interface */
-void DRMProcessorClientImpl::AESEncrypt(CHAINING_MODE chaining,
-					const unsigned char* key, unsigned int keyLength,
-					const unsigned char* iv, unsigned int ivLength,
-					const unsigned char* dataIn, unsigned int dataInLength,
-					unsigned char* dataOut, unsigned int* dataOutLength)
+void DRMProcessorClientImpl::Encrypt(CRYPTO_ALGO algo, CHAINING_MODE chaining,
+				     const unsigned char* key, unsigned int keyLength,
+				     const unsigned char* iv, unsigned int ivLength,
+				     const unsigned char* dataIn, unsigned int dataInLength,
+				     unsigned char* dataOut, unsigned int* dataOutLength)
 {
-    void* handler = AESEncryptInit(chaining, key, keyLength, iv, ivLength);
-    AESEncryptUpdate(handler, dataIn, dataInLength, dataOut, dataOutLength);
-    AESEncryptFinalize(handler, dataOut+*dataOutLength, dataOutLength);
+    void* handler = EncryptInit(algo, chaining, key, keyLength, iv, ivLength);
+    EncryptUpdate(handler, dataIn, dataInLength, dataOut, dataOutLength);
+    EncryptFinalize(handler, dataOut+*dataOutLength, dataOutLength);
 }

-void* DRMProcessorClientImpl::AESEncryptInit(CHAINING_MODE chaining,
+void* DRMProcessorClientImpl::EncryptInit(CRYPTO_ALGO algo, CHAINING_MODE chaining,
+					  const unsigned char* key, unsigned int keyLength,
+					  const unsigned char* iv, unsigned int ivLength)
+{
+    EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();
+
+    if (algo == ALGO_AES)
+    {
+	switch(keyLength)
+	{
+	case 16:
+	    switch(chaining)
+	    {
+	    case CHAIN_ECB:
+		EVP_EncryptInit(ctx, EVP_aes_128_ecb(), key, iv);
+		break;
+	    case CHAIN_CBC:
+		EVP_EncryptInit(ctx, EVP_aes_128_cbc(), key, iv);
+		break;
+	    default:
+		EXCEPTION(gourou::CLIENT_BAD_CHAINING, "Unknown chaining mode " << chaining);
+	    }
+	    break;
+	default:
+	    EVP_CIPHER_CTX_free(ctx);
+	    EXCEPTION(gourou::CLIENT_BAD_KEY_SIZE, "Invalid key size " << keyLength);
+	}
+    }
+    else if (algo == ALGO_RC4)
+    {
+	if (keyLength != 16)
+	{
+	    EVP_CIPHER_CTX_free(ctx);
+	    EXCEPTION(gourou::CLIENT_BAD_KEY_SIZE, "Invalid key size " << keyLength);
+	}
+	EVP_DecryptInit(ctx, EVP_rc4(), key, iv);
+    }
+    return ctx;
+}
+
+void* DRMProcessorClientImpl::DecryptInit(CRYPTO_ALGO algo, CHAINING_MODE chaining,
 					     const unsigned char* key, unsigned int keyLength,
 					     const unsigned char* iv, unsigned int ivLength)
 {
    EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();

-    switch(keyLength)
+    if (algo == ALGO_AES)
    {
-    case 16:
-	switch(chaining)
+	switch(keyLength)
 	{
-	case CHAIN_ECB:
-	    EVP_EncryptInit_ex(ctx, EVP_aes_128_ecb(), NULL, key, iv);
-	    break;
-	case CHAIN_CBC:
-	    EVP_EncryptInit_ex(ctx, EVP_aes_128_cbc(), NULL, key, iv);
+	case 16:
+	    switch(chaining)
+	    {
+	    case CHAIN_ECB:
+		EVP_DecryptInit(ctx, EVP_aes_128_ecb(), key, iv);
+		break;
+	    case CHAIN_CBC:
+		EVP_DecryptInit(ctx, EVP_aes_128_cbc(), key, iv);
+		break;
+	    default:
+		EXCEPTION(gourou::CLIENT_BAD_CHAINING, "Unknown chaining mode " << chaining);
+	    }
 	    break;
 	default:
-	    EXCEPTION(gourou::CLIENT_BAD_CHAINING, "Unknown chaining mode " << chaining);
+	    EVP_CIPHER_CTX_free(ctx);
+	    EXCEPTION(gourou::CLIENT_BAD_KEY_SIZE, "Invalid key size " << keyLength);
 	}
-	break;
-    default:
-	EVP_CIPHER_CTX_free(ctx);
-	EXCEPTION(gourou::CLIENT_BAD_KEY_SIZE, "Invalid key size " << keyLength);
+    }
+    else if (algo == ALGO_RC4)
+    {
+	if (keyLength != 16)
+	{
+	    EVP_CIPHER_CTX_free(ctx);
+	    EXCEPTION(gourou::CLIENT_BAD_KEY_SIZE, "Invalid key size " << keyLength);
+	}
+	EVP_DecryptInit(ctx, EVP_rc4(), key, iv);
    }
    
    return ctx;
 }

-void* DRMProcessorClientImpl::AESDecryptInit(CHAINING_MODE chaining,
-					     const unsigned char* key, unsigned int keyLength,
-					     const unsigned char* iv, unsigned int ivLength)
-{
-    EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new();
-
-    switch(keyLength)
-    {
-    case 16:
-	switch(chaining)
-	{
-	case CHAIN_ECB:
-	    EVP_DecryptInit_ex(ctx, EVP_aes_128_ecb(), NULL, key, iv);
-	    break;
-	case CHAIN_CBC:
-	    EVP_DecryptInit_ex(ctx, EVP_aes_128_cbc(), NULL, key, iv);
-	    break;
-	default:
-	    EXCEPTION(gourou::CLIENT_BAD_CHAINING, "Unknown chaining mode " << chaining);
-	}
-	break;
-    default:
-	EVP_CIPHER_CTX_free(ctx);
-	EXCEPTION(gourou::CLIENT_BAD_KEY_SIZE, "Invalid key size " << keyLength);
-    }
-
-    return ctx;
-}
-
-void DRMProcessorClientImpl::AESEncryptUpdate(void* handler, const unsigned char* dataIn, unsigned int dataInLength,
-		 unsigned char* dataOut, unsigned int* dataOutLength)
+void DRMProcessorClientImpl::EncryptUpdate(void* handler, const unsigned char* dataIn, unsigned int dataInLength,
+					   unsigned char* dataOut, unsigned int* dataOutLength)
 {
    EVP_EncryptUpdate((EVP_CIPHER_CTX*)handler, dataOut, (int*)dataOutLength, dataIn, dataInLength);
 }

-void DRMProcessorClientImpl::AESEncryptFinalize(void* handler,
-						unsigned char* dataOut, unsigned int* dataOutLength)
+void DRMProcessorClientImpl::EncryptFinalize(void* handler,
+					     unsigned char* dataOut, unsigned int* dataOutLength)
 {
    int len;
    EVP_EncryptFinal_ex((EVP_CIPHER_CTX*)handler, dataOut, &len);
@@ -336,24 +395,24 @@ void DRMProcessorClientImpl::AESEncryptFinalize(void* handler,
    EVP_CIPHER_CTX_free((EVP_CIPHER_CTX*)handler);
 }

-void DRMProcessorClientImpl::AESDecrypt(CHAINING_MODE chaining,
-					const unsigned char* key, unsigned int keyLength,
-					const unsigned char* iv, unsigned int ivLength,
-					const unsigned char* dataIn, unsigned int dataInLength,
-					unsigned char* dataOut, unsigned int* dataOutLength)
+void DRMProcessorClientImpl::Decrypt(CRYPTO_ALGO algo, CHAINING_MODE chaining,
+				     const unsigned char* key, unsigned int keyLength,
+				     const unsigned char* iv, unsigned int ivLength,
+				     const unsigned char* dataIn, unsigned int dataInLength,
+				     unsigned char* dataOut, unsigned int* dataOutLength)
 {
-    void* handler = AESDecryptInit(chaining, key, keyLength, iv, ivLength);
-    AESDecryptUpdate(handler, dataIn, dataInLength, dataOut, dataOutLength);
-    AESDecryptFinalize(handler, dataOut+*dataOutLength, dataOutLength);
+    void* handler = DecryptInit(algo, chaining, key, keyLength, iv, ivLength);
+    DecryptUpdate(handler, dataIn, dataInLength, dataOut, dataOutLength);
+    DecryptFinalize(handler, dataOut+*dataOutLength, dataOutLength);
 }

-void DRMProcessorClientImpl::AESDecryptUpdate(void* handler, const unsigned char* dataIn, unsigned int dataInLength,
-					       unsigned char* dataOut, unsigned int* dataOutLength)
+void DRMProcessorClientImpl::DecryptUpdate(void* handler, const unsigned char* dataIn, unsigned int dataInLength,
+					   unsigned char* dataOut, unsigned int* dataOutLength)
 {
    EVP_DecryptUpdate((EVP_CIPHER_CTX*)handler, dataOut, (int*)dataOutLength, dataIn, dataInLength);
 }

-void DRMProcessorClientImpl::AESDecryptFinalize(void* handler, unsigned char* dataOut, unsigned int* dataOutLength)
+void DRMProcessorClientImpl::DecryptFinalize(void* handler, unsigned char* dataOut, unsigned int* dataOutLength)
 {
    int len;
    EVP_DecryptFinal_ex((EVP_CIPHER_CTX*)handler, dataOut, &len);
@@ -371,35 +430,39 @@ void* DRMProcessorClientImpl::zipOpen(const std::string& path)
    return handler;
 }

-std::string DRMProcessorClientImpl::zipReadFile(void* handler, const std::string& path)
+void DRMProcessorClientImpl::zipReadFile(void* handler, const std::string& path, gourou::ByteArray& result, bool decompress)
 {
    std::string res;
-    unsigned char* buffer;
    zip_stat_t sb;
    
    if (zip_stat((zip_t *)handler, path.c_str(), 0, &sb) < 0)
-	EXCEPTION(gourou::CLIENT_ZIP_ERROR, "Zip error " << zip_strerror((zip_t *)handler));
+	EXCEPTION(gourou::CLIENT_ZIP_ERROR, "Zip error, no file " << path << ", " << zip_strerror((zip_t *)handler));

    if (!(sb.valid & (ZIP_STAT_INDEX|ZIP_STAT_SIZE)))
 	EXCEPTION(gourou::CLIENT_ZIP_ERROR, "Required fields missing");

-    buffer = new unsigned char[sb.size];
+    result.resize(sb.size);
    
-    zip_file_t *f = zip_fopen_index((zip_t *)handler, sb.index, ZIP_FL_COMPRESSED);
-
-    zip_fread(f, buffer, sb.size);
+    zip_file_t *f = zip_fopen_index((zip_t *)handler, sb.index, (decompress)?0:ZIP_FL_COMPRESSED);
+    zip_fread(f, result.data(), sb.size);
    zip_fclose(f);
-
-    res = std::string((char*)buffer, sb.size);
-    delete[] buffer;
-    
-    return res;
 }

-void DRMProcessorClientImpl::zipWriteFile(void* handler, const std::string& path, const std::string& content)
+void DRMProcessorClientImpl::zipWriteFile(void* handler, const std::string& path, gourou::ByteArray& content)
 {
-    zip_source_t* s = zip_source_buffer((zip_t*)handler, content.c_str(), content.length(), 0);
-    if (zip_file_add((zip_t*)handler, path.c_str(), s, ZIP_FL_OVERWRITE|ZIP_FL_ENC_UTF_8) < 0)
+    zip_int64_t ret;
+    
+    zip_source_t* s = zip_source_buffer((zip_t*)handler, content.takeShadowData(), content.length(), 1);
+
+    zip_int64_t idx = zip_name_locate((zip_t*)handler, path.c_str(), 0);
+
+    // File doesn't exists
+    if (idx == -1)
+	ret = zip_file_add((zip_t*)handler, path.c_str(), s, 0);
+    else
+	ret = zip_file_replace((zip_t*)handler, idx, s, ZIP_FL_OVERWRITE);
+
+    if (ret < 0)
    {
 	zip_source_free(s);
 	EXCEPTION(gourou::CLIENT_ZIP_ERROR, "Zip error " << zip_strerror((zip_t *)handler));
@@ -422,7 +485,7 @@ void DRMProcessorClientImpl::zipClose(void* handler)
    zip_close((zip_t*)handler);
 }

-void DRMProcessorClientImpl::inflate(std::string data, gourou::ByteArray& result,
+void DRMProcessorClientImpl::inflate(gourou::ByteArray& data, gourou::ByteArray& result,
 				     int wbits)
 {
    unsigned int dataSize = data.size()*2;
@@ -435,17 +498,17 @@ void DRMProcessorClientImpl::inflate(std::string data, gourou::ByteArray& result
    infstream.opaque = Z_NULL;

    infstream.avail_in  = (uInt)data.size();
-    infstream.next_in   = (Bytef *)data.c_str(); // input char array
+    infstream.next_in   = (Bytef *)data.data(); // input char array
    infstream.avail_out = (uInt)dataSize; // size of output
    infstream.next_out  = (Bytef *)buffer; // output char array

    int ret = inflateInit2(&infstream, wbits);

    if (ret != Z_OK)
-	EXCEPTION(gourou::CLIENT_ZIP_ERROR, infstream.msg);
+	EXCEPTION(gourou::CLIENT_ZIP_ERROR, "Inflate error, code " << zError(ret) << ", msg " << infstream.msg);

    ret = ::inflate(&infstream, Z_FINISH);
-    while (ret == Z_OK || ret == Z_STREAM_END)
+    while (ret == Z_OK || ret == Z_STREAM_END || ret == Z_BUF_ERROR)
    {
 	result.append(buffer, dataSize-infstream.avail_out);
 	if ((ret == Z_OK && infstream.avail_out != 0) || ret == Z_STREAM_END)
@@ -455,16 +518,17 @@ void DRMProcessorClientImpl::inflate(std::string data, gourou::ByteArray& result
 	ret = ::inflate(&infstream, Z_FINISH);
    }

+
    if (ret == Z_STREAM_END)
 	ret = inflateEnd(&infstream);

    delete[] buffer;

    if (ret != Z_OK && ret != Z_STREAM_END)
-	EXCEPTION(gourou::CLIENT_ZIP_ERROR, zError(ret));
+	EXCEPTION(gourou::CLIENT_ZIP_ERROR, "Inflate error, code " << zError(ret) << ", msg " << infstream.msg);
 }
 	
-void DRMProcessorClientImpl::deflate(std::string data, gourou::ByteArray& result,
+void DRMProcessorClientImpl::deflate(gourou::ByteArray& data, gourou::ByteArray& result,
 				     int wbits, int compressionLevel)
 {
    unsigned int dataSize = data.size();
@@ -476,8 +540,8 @@ void DRMProcessorClientImpl::deflate(std::string data, gourou::ByteArray& result
    defstream.zfree  = Z_NULL;
    defstream.opaque = Z_NULL;

-    defstream.avail_in  = (uInt)data.size();
-    defstream.next_in   = (Bytef *)data.c_str(); // input char array
+    defstream.avail_in  = (uInt)dataSize;
+    defstream.next_in   = (Bytef *)data.data(); // input char array
    defstream.avail_out = (uInt)dataSize; // size of output
    defstream.next_out  = (Bytef *)buffer; // output char array

@@ -485,7 +549,7 @@ void DRMProcessorClientImpl::deflate(std::string data, gourou::ByteArray& result
 			   compressionLevel, Z_DEFAULT_STRATEGY);

    if (ret != Z_OK)
-	EXCEPTION(gourou::CLIENT_ZIP_ERROR, defstream.msg);
+	EXCEPTION(gourou::CLIENT_ZIP_ERROR, "Deflate error, code " << zError(ret) << ", msg " << defstream.msg);
    
    ret = ::deflate(&defstream, Z_FINISH);
    while (ret == Z_OK || ret == Z_STREAM_END)
@@ -504,5 +568,5 @@ void DRMProcessorClientImpl::deflate(std::string data, gourou::ByteArray& result
    delete[] buffer;

    if (ret != Z_OK && ret != Z_STREAM_END)
-	EXCEPTION(gourou::CLIENT_ZIP_ERROR, zError(ret));
+	EXCEPTION(gourou::CLIENT_ZIP_ERROR, "Deflate error, code " << zError(ret) << ", msg " << defstream.msg);
 }
--- a/utils/drmprocessorclientimpl.h
+++ b/utils/drmprocessorclientimpl.h
@@ -35,7 +35,7 @@

 class DRMProcessorClientImpl : public gourou::DRMProcessorClient
 {
-    public:
+public:
    /* Digest interface */
    virtual void* createDigest(const std::string& digestName);
    virtual int digestUpdate(void* handler, unsigned char* data, unsigned int length);
@@ -53,6 +53,11 @@ class DRMProcessorClientImpl : public gourou::DRMProcessorClient
 				   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,
@@ -68,49 +73,50 @@ class DRMProcessorClientImpl : public gourou::DRMProcessorClient
 				    unsigned char** certOut, unsigned int* certOutLength);
 				 
    /* Crypto interface */
-    virtual void AESEncrypt(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 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,
-				 const unsigned char* key, unsigned int keyLength,
-				 const unsigned char* iv=0, unsigned int ivLength=0);
+    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,
-			    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 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,
-				 const unsigned char* key, unsigned int keyLength,
-				 const unsigned char* iv=0, unsigned int ivLength=0);
+    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,
-				   unsigned char* dataOut, unsigned int* dataOutLength);
-    virtual void AESDecryptFinalize(void* handler, unsigned char* dataOut, unsigned int* dataOutLength);
+    virtual void DecryptUpdate(void* handler, const unsigned char* dataIn, unsigned int dataInLength,
+			       unsigned char* dataOut, unsigned int* dataOutLength);
+    virtual void DecryptFinalize(void* handler, unsigned char* dataOut, unsigned int* dataOutLength);

    /* 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(std::string data, gourou::ByteArray& result, int wbits=-15);
+    virtual void inflate(gourou::ByteArray& data, gourou::ByteArray& result,
+			 int wbits=-15);
 	
-    virtual void deflate(std::string data, gourou::ByteArray& result,
+    virtual void deflate(gourou::ByteArray& data, gourou::ByteArray& result,
 			 int wbits=-15, int compressionLevel=8);
 };
Author	SHA1	Message	Date
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