react-native-fs-turbo 0.3.7 → 0.4.1

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/mode.hpp

@@ -0,0 +1,131 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#ifdef RNFSTURBO_USE_ENCRYPTION
+
+#ifndef KRYPT_MODE_OF_ENCRYPTION_HPP
+#define KRYPT_MODE_OF_ENCRYPTION_HPP
+
+#include <iostream>
+#include "blockcipher.hpp"
+#include "bytearray.hpp"
+#include "padding.hpp"
+
+namespace Krypt {
+    namespace Mode {
+        class MODE {
+            public:
+
+            BlockCipher::BASE_BLOCKCIPHER *Encryption;
+            Padding::NoPadding *PaddingScheme;
+
+            MODE() : Encryption(nullptr), PaddingScheme(nullptr) {}
+
+            virtual ByteArray encrypt(Bytes *, size_t, Bytes *) = 0;
+            virtual ByteArray decrypt(Bytes *, size_t, Bytes *) = 0;
+
+            virtual void blockEncrypt(Bytes *, Bytes *, Bytes *) = 0;
+            virtual void blockDecrypt(Bytes *, Bytes *, Bytes *) = 0;
+
+            virtual ~MODE() {
+                delete Encryption;
+                delete PaddingScheme;
+            }
+        };
+
+        /// Electronic Code Blocking.
+        template <typename CIPHER_TYPE, typename PADDING_TYPE>
+        class ECB : public MODE {
+            public:
+
+            ECB(const Bytes *key, size_t keyLen);
+            /// encrypts the whole plain array using ECB mode of encryption with a chosen BlockCipher and Padding.
+            /// @param plain pointer to a Bytes*/unsigned char* array, this is the array you want to encrypt.
+            /// @param plainLen this is the size of the *plain array.
+            /// @param iv for ECB passing an iv will not do anything so there is no need to provide this function an iv
+            /// array.
+            ByteArray encrypt(Bytes *plain, size_t plainLen, Bytes *iv = nullptr) override;
+            /// decrypts the whole cipher array using ECB mode of decryption with a chosen BlockCipher and Padding.
+            /// @param cipher pointer to a Bytes*/unsigned char* array, this is the array you want to decrypt.
+            /// @param cipherLen this is the size of the *cipher array.
+            /// @param iv for ECB passing an iv will not do anything so there is no need to provide this function an iv
+            /// array.
+            ByteArray decrypt(Bytes *cipher, size_t cipherLen, Bytes *iv = nullptr) override;
+
+            void blockEncrypt(Bytes *plain, Bytes *cipher, Bytes *iv = nullptr) override;
+            void blockDecrypt(Bytes *plain, Bytes *cipher, Bytes *iv = nullptr) override;
+        };
+
+        /// Cipher Block Chaining.
+        template <typename CIPHER_TYPE, typename PADDING_TYPE>
+        class CBC : public MODE {
+            public:
+
+            CBC(const Bytes *key, size_t keyLen);
+            /// encrypts the whole plain array using CBC mode of encryption with a chosen BlockCipher and Padding.
+            /// @param plain pointer to a Bytes*/unsigned char* array, this is the array you want to encrypt.
+            /// @param plainLen this is the size of the *plain array.
+            /// @param iv the initial array use for the XOR'ing operations during the CBC encryption.
+            ByteArray encrypt(Bytes *plain, size_t plainLen, Bytes *iv) override;
+            /// decrypts the whole cipher array using CBC mode of decryption with a chosen BlockCipher and Padding.
+            /// @param cipher pointer to a Bytes*/unsigned char* array, this is the array you want to decrypt.
+            /// @param cipherLen this is the size of the *cipher array.
+            /// @param iv the initial array use for the XOR'ing operations during the CBC decryption.
+            ByteArray decrypt(Bytes *cipher, size_t cipherLen, Bytes *iv) override;
+
+            void blockEncrypt(Bytes *plain, Bytes *cipher, Bytes *iv) override;
+            void blockDecrypt(Bytes *plain, Bytes *cipher, Bytes *iv) override;
+        };
+
+        /// Cipher Feedback.
+        template <typename CIPHER_TYPE, typename PADDING_TYPE>
+        class CFB : public MODE {
+            public:
+
+            CFB(const Bytes *key, size_t keyLen);
+            /// encrypts the whole plain array using CFB mode of encryption with a chosen BlockCipher and Padding.
+            /// @param plain pointer to a Bytes*/unsigned char* array, this is the array you want to encrypt.
+            /// @param plainLen this is the size of the *plain array.
+            /// @param iv the initial array use for the XOR'ing operations during the CFB encryption.
+            ByteArray encrypt(Bytes *plain, size_t plainLen, Bytes *iv) override;
+            /// decrypts the whole cipher array using CFB mode of decryption with a chosen BlockCipher and Padding.
+            /// @param cipher pointer to a Bytes*/unsigned char* array, this is the array you want to decrypt.
+            /// @param cipherLen this is the size of the *cipher array.
+            /// @param iv the initial array use for the XOR'ing operations during the CFB decryption.
+            ByteArray decrypt(Bytes *cipher, size_t cipherLen, Bytes *iv) override;
+
+            void blockEncrypt(Bytes *plain, Bytes *cipher, Bytes *iv) override;
+            void blockDecrypt(Bytes *plain, Bytes *cipher, Bytes *iv) override;
+        };
+    } // namespace Mode
+} // namespace Krypt
+
+#include "mode.cpp"
+
+#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