react-native-fs-turbo 0.3.7 → 0.4.0

package/cpp/algorithms/Krypt/functions.cpp

@@ -0,0 +1,137 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2019 SergeyBel
+ * Copyright (c) 2023 Jubal Mordecai Velasco
+ *
+ * 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.
+ */
+
+#ifdef RNFSTURBO_USE_ENCRYPTION
+
+#ifndef KRYPT_FUNCTIONS_CPP
+#define KRYPT_FUNCTIONS_CPP
+
+#include "functions.hpp"
+#include "types.hpp"
+
+// #define USE_AESNI
+
+#if defined(USE_AESNI)
+#include <immintrin.h>
+#else
+
+#endif
+
+// here the DWORDS is formed from 4 continous elements from a starting index of an unsinged char* array or Bytes*.
+// a DWORD or double-word occupies 32-bits in a memory.
+// the term DWORD is usually used to represent bits inside the eax,edx,...r15d parts of an x86_64 cpu register which can
+// contain 32 bits inside.
+
+namespace Krypt {
+    Bytes xtime(Bytes b) // multiply on x
+    {
+        return (b << 1) ^ (((b >> 7) & 1) * 0x1b);
+    }
+
+    void SubDWordBytes(Bytes *a) {
+        a[0] = sbox[a[0]];
+        a[1] = sbox[a[1]];
+        a[2] = sbox[a[2]];
+        a[3] = sbox[a[3]];
+    }
+
+    void RotDWord(Bytes *a) {
+        Bytes c = a[0];
+        a[0] = a[1];
+        a[1] = a[2];
+        a[2] = a[3];
+        a[3] = c;
+    }
+
+    void XorDWords(Bytes *a, Bytes *b, Bytes *dest) {
+        dest[0] = a[0] ^ b[0];
+        dest[1] = a[1] ^ b[1];
+        dest[2] = a[2] ^ b[2];
+        dest[3] = a[3] ^ b[3];
+    }
+
+    void XorBlocks(unsigned char *a, unsigned char *b, unsigned char *dest, unsigned int len) {
+        for (unsigned int i = 0; i < len; i++) {
+            dest[i] = a[i] ^ b[i];
+        }
+    }
+
+    void XorAesBlock(unsigned char *a, unsigned char *b, unsigned char *result) {
+        #if defined(USE_AESNI)
+        __m128i vxor = _mm_xor_si128(
+            _mm_load_si128((__m128i *) a),
+            _mm_load_si128((__m128i *) b)
+        );
+
+        _mm_storeu_si128((__m128i *) (result), vxor);
+        #else
+        uint64_t
+            *A = reinterpret_cast<uint64_t *>(a),
+            *B = reinterpret_cast<uint64_t *>(b),
+            *C = reinterpret_cast<uint64_t *>(result);
+
+        C[0] = A[0] ^ B[0];
+        C[1] = A[1] ^ B[1];
+        #endif
+    }
+
+    void Rcon(Bytes *a, int n) {
+        int i;
+        Bytes c = 1;
+        for (i = 0; i < n - 1; i++) {
+            c = xtime(c);
+        }
+
+        a[0] = c;
+        a[1] = a[2] = a[3] = 0;
+    }
+
+    void printHexArray(unsigned char a[], size_t n) {
+        for (size_t i = 0; i < n; i++) {
+            printf("%02x ", a[i]);
+        }
+        std::cout << "\n";
+    }
+
+    void printHexVector(const std::vector<unsigned char> &a) {
+        for (size_t i = 0; i < a.size(); i++) {
+            printf("%02x ", a[i]);
+        }
+    }
+
+    std::vector<unsigned char> ArrayToVector(std::unique_ptr<unsigned char[]> a, unsigned char len) {
+        return std::vector<unsigned char>(a.get(), a.get() + len);
+    }
+
+    std::unique_ptr<unsigned char[]> VectorToArray(const std::vector<unsigned char>& a) {
+        auto cpy = std::make_unique<unsigned char[]>(a.size());
+        memcpy(cpy.get(), a.data(), a.size());
+        return cpy;
+    }
+} // namespace Krypt
+
+#endif
+
+#endif

package/cpp/algorithms/Krypt/mode.cpp

@@ -0,0 +1,203 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2019 SergeyBel
+ * Copyright (c) 2023 Jubal Mordecai Velasco
+ *
+ * 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.
+ */
+
+#ifdef RNFSTURBO_USE_ENCRYPTION
+
+#ifndef KRYPT_MODE_OF_ENCRYPTION_CPP
+#define KRYPT_MODE_OF_ENCRYPTION_CPP
+
+#include "functions.hpp"
+#include "mode.hpp"
+#include "padding.hpp"
+#include "types.hpp"
+
+namespace Krypt {
+    namespace Mode {
+        // CBC
+        template <typename CIPHER_TYPE, typename PADDING_TYPE>
+        CBC<CIPHER_TYPE, PADDING_TYPE>::CBC(const Bytes *key, size_t keyLen) : MODE() {
+            Encryption = new CIPHER_TYPE(key, keyLen);
+            PaddingScheme = new PADDING_TYPE();
+        }
+
+        template <typename CIPHER_TYPE, typename PADDING_TYPE>
+        ByteArray CBC<CIPHER_TYPE, PADDING_TYPE>::encrypt(Bytes *plain, size_t plainLen, Bytes *iv) {
+            ByteArray padded = PaddingScheme->AddPadding(plain, plainLen, Encryption->BLOCK_SIZE);
+            Bytes *tempIV = new Bytes[Encryption->BLOCK_SIZE];
+            Bytes *cipher = new Bytes[padded.length];
+
+            memcpy(tempIV, iv, Encryption->BLOCK_SIZE);
+
+            for (size_t i = 0; i < padded.length; i += Encryption->BLOCK_SIZE) {
+                this->blockEncrypt(padded.array + i, cipher + i, tempIV);
+            }
+
+            delete[] tempIV;
+            return ByteArray(cipher, padded.length);
+        }
+
+        template <typename CIPHER_TYPE, typename PADDING_TYPE>
+        ByteArray CBC<CIPHER_TYPE, PADDING_TYPE>::decrypt(Bytes *cipher, size_t cipherLen, Bytes *iv) {
+            Bytes *recover = new Bytes[cipherLen];
+            Bytes *tempIV = new Bytes[Encryption->BLOCK_SIZE];
+            memcpy(tempIV, iv, Encryption->BLOCK_SIZE);
+
+            for (size_t i = 0; i < cipherLen; i += Encryption->BLOCK_SIZE) {
+                this->blockDecrypt(cipher + i, recover + i, tempIV);
+            }
+
+            ByteArray recoverNoPadding = PaddingScheme->RemovePadding(recover, cipherLen, Encryption->BLOCK_SIZE);
+
+            delete[] tempIV;
+            delete[] recover;
+
+            return recoverNoPadding;
+        }
+
+        template <typename CIPHER_TYPE, typename PADDING_TYPE>
+        void CBC<CIPHER_TYPE, PADDING_TYPE>::blockEncrypt(Bytes *plain, Bytes *cipher, Bytes *iv) {
+            XorAesBlock(iv, plain, iv);
+            Encryption->EncryptBlock(iv, cipher);
+            memcpy(iv, cipher, 16);
+        }
+
+        template <typename CIPHER_TYPE, typename PADDING_TYPE>
+        void CBC<CIPHER_TYPE, PADDING_TYPE>::blockDecrypt(Bytes *cipher, Bytes *recover, Bytes *iv) {
+            Encryption->DecryptBlock(cipher, recover);
+            XorAesBlock(iv, recover, recover);
+            memcpy(iv, cipher, Encryption->BLOCK_SIZE);
+        }
+    
+        // CFB
+        template <typename CIPHER_TYPE, typename PADDING_TYPE>
+        CFB<CIPHER_TYPE, PADDING_TYPE>::CFB(const Bytes *key, size_t keyLen) : MODE() {
+            Encryption = new CIPHER_TYPE(key, keyLen);
+            PaddingScheme = new PADDING_TYPE();
+        }
+
+        template <typename CIPHER_TYPE, typename PADDING_TYPE>
+        ByteArray CFB<CIPHER_TYPE, PADDING_TYPE>::encrypt(Bytes *plain, size_t plainLen, Bytes *iv) {
+            ByteArray padded = PaddingScheme->AddPadding(plain, plainLen, Encryption->BLOCK_SIZE);
+
+            Bytes *tempIV = new Bytes[Encryption->BLOCK_SIZE];
+            Bytes *encIV = new Bytes[Encryption->BLOCK_SIZE];
+            Bytes *cipher = new Bytes[padded.length];
+
+            memcpy(tempIV, iv, Encryption->BLOCK_SIZE);
+
+            for (size_t i = 0; i < padded.length; i += Encryption->BLOCK_SIZE) {
+                blockEncrypt(padded.array + i, cipher + i, tempIV);
+            }
+
+            delete[] tempIV;
+            delete[] encIV;
+
+            return ByteArray(cipher, padded.length);
+        }
+
+        template <typename CIPHER_TYPE, typename PADDING_TYPE>
+        ByteArray CFB<CIPHER_TYPE, PADDING_TYPE>::decrypt(Bytes *cipher, size_t cipherLen, Bytes *iv) {
+            Bytes *recover = new Bytes[cipherLen];
+            Bytes *tempIV = new Bytes[Encryption->BLOCK_SIZE];
+            Bytes *encIV = new Bytes[Encryption->BLOCK_SIZE];
+
+            memcpy(tempIV, iv, Encryption->BLOCK_SIZE);
+
+            for (size_t i = 0; i < cipherLen; i += Encryption->BLOCK_SIZE) {
+                Encryption->EncryptBlock(tempIV, encIV);
+                XorAesBlock(cipher + i, encIV, recover + i);
+                memcpy(tempIV, cipher + i, Encryption->BLOCK_SIZE);
+            }
+
+            ByteArray recoverNoPadding = PaddingScheme->RemovePadding(recover, cipherLen, Encryption->BLOCK_SIZE);
+
+            delete[] recover;
+            delete[] tempIV;
+            delete[] encIV;
+
+            return recoverNoPadding;
+        }
+
+        template <typename CIPHER_TYPE, typename PADDING_TYPE>
+        void CFB<CIPHER_TYPE, PADDING_TYPE>::blockEncrypt(Bytes *plain, Bytes *cipher, Bytes *iv) {
+            Encryption->EncryptBlock(iv, cipher);
+            XorAesBlock(plain, cipher, cipher);
+            memcpy(iv, cipher, Encryption->BLOCK_SIZE);
+        }
+
+        template <typename CIPHER_TYPE, typename PADDING_TYPE>
+        void CFB<CIPHER_TYPE, PADDING_TYPE>::blockDecrypt(Bytes *cipher, Bytes *recover, Bytes *iv) {
+            Encryption->EncryptBlock(iv, recover);
+            XorAesBlock(cipher, recover, recover);
+            memcpy(iv, cipher, Encryption->BLOCK_SIZE);
+        }
+    
+        // ECB
+        template <typename CIPHER_TYPE, typename PADDING_TYPE>
+        ECB<CIPHER_TYPE, PADDING_TYPE>::ECB(const Bytes *key, size_t keyLen) : MODE() {
+            this->Encryption = new CIPHER_TYPE(key, keyLen);
+            this->PaddingScheme = new PADDING_TYPE();
+        }
+
+        template <typename CIPHER_TYPE, typename PADDING_TYPE>
+        ByteArray ECB<CIPHER_TYPE, PADDING_TYPE>::encrypt(Bytes *plain, size_t plainLen, Bytes *) {
+            ByteArray padded = this->PaddingScheme->AddPadding(plain, plainLen, this->Encryption->BLOCK_SIZE);
+
+            Bytes *cipher = new Bytes[padded.length];
+            for (size_t i = 0; i < padded.length; i += this->Encryption->BLOCK_SIZE) {
+                blockEncrypt(padded.array + i, cipher + i);
+            }
+
+            return ByteArray(cipher, padded.length);
+        }
+
+        template <typename CIPHER_TYPE, typename PADDING_TYPE>
+        ByteArray ECB<CIPHER_TYPE, PADDING_TYPE>::decrypt(Bytes *cipher, size_t cipherLen, Bytes *) {
+            ByteArray recovered;
+            recovered.array = new Bytes[cipherLen];
+            recovered.length = cipherLen;
+
+            for (size_t i = 0; i < cipherLen; i += this->Encryption->BLOCK_SIZE) {
+                blockDecrypt(cipher + i, recovered.array + i);
+            }
+
+            return this->PaddingScheme->RemovePadding(recovered.array, recovered.length, this->Encryption->BLOCK_SIZE);
+        }
+
+        template <typename CIPHER_TYPE, typename PADDING_TYPE>
+        void ECB<CIPHER_TYPE, PADDING_TYPE>::blockEncrypt(Bytes *plain, Bytes *cipher, Bytes *) {
+            this->Encryption->EncryptBlock(plain, cipher);
+        }
+
+        template <typename CIPHER_TYPE, typename PADDING_TYPE>
+        void ECB<CIPHER_TYPE, PADDING_TYPE>::blockDecrypt(Bytes *cipher, Bytes *recover, Bytes *) {
+            this->Encryption->DecryptBlock(cipher, recover);
+        }
+    } // namespace Mode
+} // namespace Krypt
+
+#endif
+
+#endif

package/cpp/algorithms/Krypt/padding.cpp

@@ -0,0 +1,219 @@
+/*
+ * MIT License
+ *
+ * Copyright (c) 2019 SergeyBel
+ * Copyright (c) 2023 Jubal Mordecai Velasco
+ *
+ * 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.
+ */
+
+#ifdef RNFSTURBO_USE_ENCRYPTION
+
+#ifndef KRYPT_PADDING_CPP
+#define KRYPT_PADDING_CPP
+
+#import "padding.hpp"
+
+namespace Krypt {
+    namespace Padding {
+        // ANSI_X9_23
+        ByteArray ANSI_X9_23::AddPadding(Bytes *src, size_t len, size_t BLOCKSIZE) {
+            size_t paddings = BLOCKSIZE - (len % BLOCKSIZE);
+            size_t paddedLen = paddings + len;
+            Bytes *paddedBlock = new Bytes[paddedLen];
+
+            memcpy(paddedBlock, src, len);
+            memset(paddedBlock + len, 0x00, paddings);
+            paddedBlock[paddedLen - 1] = static_cast<Bytes>(paddings);
+
+            return ByteArray(paddedBlock, paddedLen);
+        }
+
+        ByteArray ANSI_X9_23::RemovePadding(Bytes *src, size_t len, size_t BLOCKSIZE) {
+#ifndef PADDING_CHECK_DISABLE
+            if (len < BLOCKSIZE || len % BLOCKSIZE != 0) {
+                std::cerr << "\nA padded `src` should have a `len` greater than and divisible by the `BLOCKSIZE`\n";
+                throw InvalidPaddedLength("ANSI_X9_23: src's `len` indicates that it was not padded or is corrupted");
+            }
+#endif
+
+            size_t paddings = src[len - 1];
+            size_t noPaddingLength = len - paddings;
+
+#ifndef PADDING_CHECK_DISABLE
+            for (size_t i = 1; i < paddings; ++i) {
+                if (src[len - 1 - i] != 0x00) {
+                    throw InvalidPadding("ANSI_X9_23: does not match the padding scheme used in `src`");
+                }
+            }
+#endif
+
+            Bytes *NoPadding = new Bytes[noPaddingLength];
+            memcpy(NoPadding, src, noPaddingLength);
+
+            return ByteArray(NoPadding, noPaddingLength);
+        }
+    
+        // ISO_IEC_7816_4
+        ByteArray ISO_IEC_7816_4::AddPadding(Bytes *src, size_t originalSrcLen, size_t BLOCKSIZE) {
+            size_t paddings = BLOCKSIZE - (originalSrcLen % BLOCKSIZE);
+            size_t paddedLen = paddings + originalSrcLen;
+            Bytes *paddedBlock = new Bytes[paddedLen];
+
+            memcpy(paddedBlock, src, originalSrcLen);
+            memset(paddedBlock + originalSrcLen, 0x00, paddings);
+            paddedBlock[originalSrcLen] = 0x80;
+
+            return ByteArray(paddedBlock, paddedLen);
+        }
+
+        ByteArray ISO_IEC_7816_4::RemovePadding(Bytes *src, size_t len, size_t BLOCKSIZE) {
+#ifndef PADDING_CHECK_DISABLE
+            if (len < BLOCKSIZE || len % BLOCKSIZE != 0) {
+                std::cerr << "\nA padded `src` should have a `len` greater than and divisible by the `BLOCKSIZE`\n";
+                throw InvalidPaddedLength("ISO_IEC_7816_4: src's `len` indicates that it was not padded or is corrupted"
+                );
+            }
+#endif
+
+            size_t i;
+
+#ifndef PADDING_CHECK_DISABLE
+            for (i = 1; i < BLOCKSIZE; ++i) {
+                if (src[len - i] == 0x80) {
+                    break;
+                }
+
+                if (src[len - i] != 0x00) {
+                    throw InvalidPadding("ISO_IEC_7816_4: does not match the padding scheme used in `src`");
+                }
+            }
+#endif
+
+            size_t noPaddingLength = len - i;
+            Bytes *NoPadding = new Bytes[noPaddingLength];
+            memcpy(NoPadding, src, noPaddingLength);
+
+            return ByteArray(NoPadding, noPaddingLength);
+        }
+    
+        // NoPadding
+        const char *InvalidPadding::what() const throw() {
+            return msg;
+        }
+        const char *InvalidPaddedLength::what() const throw() {
+            return msg;
+        }
+
+        ByteArray NoPadding::AddPadding(Bytes *src, size_t len, size_t) {
+            Bytes *Copy = new Bytes[len];
+            memcpy(Copy, src, len);
+            return ByteArray(Copy, len);
+        }
+
+        ByteArray NoPadding::RemovePadding(Bytes *src, size_t len, size_t) {
+            Bytes *Copy = new Bytes[len];
+            memcpy(Copy, src, len);
+            return ByteArray(Copy, len);
+        }
+    
+        // PKCS_5_7
+        ByteArray PKCS_5_7::AddPadding(Bytes *src, size_t len, size_t BLOCKSIZE) {
+            size_t paddings = BLOCKSIZE - (len % BLOCKSIZE);
+            size_t paddedLen = paddings + len;
+            Bytes *paddedBlock = new Bytes[paddedLen];
+
+            memcpy(paddedBlock, src, len);
+            memset(paddedBlock + len, static_cast<Bytes>(paddings), paddings);
+
+            return ByteArray(paddedBlock, paddedLen);
+        }
+
+        ByteArray PKCS_5_7::RemovePadding(Bytes *src, size_t len, size_t BLOCKSIZE) {
+#ifndef PADDING_CHECK_DISABLE
+            if (len < BLOCKSIZE || len % BLOCKSIZE != 0) {
+                std::cerr << "\nA padded `src` should have a `len` greater than and divisible by the `BLOCKSIZE`\n";
+                throw InvalidPaddedLength("PKCS_5_7: src's `len` indicates that it was not padded or is corrupted");
+            }
+#endif
+
+            size_t paddings = src[len - 1];
+            size_t noPaddingLength = len - paddings;
+
+#ifndef PADDING_CHECK_DISABLE
+            Bytes checkchar = static_cast<Bytes>(paddings);
+            for (size_t i = 1; i < paddings; ++i) {
+                if (src[len - 1 - i] != checkchar) {
+                    throw InvalidPadding("PKCS_5_7: does not match the padding scheme used in `src`");
+                }
+            }
+#endif
+
+            Bytes *NoPadding = new Bytes[noPaddingLength];
+            memcpy(NoPadding, src, noPaddingLength);
+
+            return ByteArray(NoPadding, noPaddingLength);
+        }
+    
+        // ZeroNulls
+        ByteArray ZeroNulls::AddPadding(Bytes *src, size_t len, size_t BLOCKSIZE) {
+            size_t paddings = BLOCKSIZE - (len % BLOCKSIZE);
+            size_t paddedLen = paddings + len;
+            Bytes *paddedBlock = new Bytes[paddedLen];
+
+            memcpy(paddedBlock, src, len);
+            memset(paddedBlock + len, 0x00, paddings);
+
+            return ByteArray(paddedBlock, paddedLen);
+        }
+
+        ByteArray ZeroNulls::RemovePadding(Bytes *src, size_t len, size_t BLOCKSIZE) {
+#ifndef PADDING_CHECK_DISABLE
+            if (len < BLOCKSIZE || len % BLOCKSIZE != 0) {
+                std::cerr << "\nA padded `src` should have a `len` greater than and divisible by the `BLOCKSIZE`\n";
+                throw InvalidPaddedLength("ZeroNulls: src's `len` indicates that it was not padded or is corrupted");
+            }
+#endif
+
+#ifndef PADDING_CHECK_DISABLE
+            if (src[len - 1] != 0x00) {
+                throw InvalidPadding("ZeroNulls: does not match the padding scheme used in `src`");
+            }
+#endif
+
+            size_t paddings = 0, noPaddingLength = 0;
+            for (size_t i = 0; i < BLOCKSIZE; ++i)
+                if (src[len - 1 - i] == 0x00) {
+                    paddings++;
+                } else {
+                    break;
+                }
+
+            noPaddingLength = len - paddings;
+            Bytes *NoPadding = new Bytes[noPaddingLength];
+            memcpy(NoPadding, src, noPaddingLength);
+
+            return ByteArray(NoPadding, noPaddingLength);
+        }
+    } // namespace Padding
+} // namespace Krypt
+
+#endif
+
+#endif