react-native-fs-turbo 0.3.7 → 0.4.1

package/cpp/algorithms/Krypt/aes-config.hpp

@@ -0,0 +1,71 @@
+/*
+ * MIT License
+ *
+ * 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 AES_CONFIG_HPP
+#define AES_CONFIG_HPP
+
+// WIP
+
+#if defined(__x86_64) || defined(__x86_64__) || defined(__amd64) || defined(__amd64__)
+#include <immintrin.h>
+#include <xmmintrin.h>
+#define AES_IMPLEMENT_INTEL_AESNI
+#elif defined(__arm64__) || defined(__aarch64__) || defined(_M_ARM)
+#if defined(__GNUC__)
+    #include <stdint.h>
+#endif
+
+#if defined(__ARM_NEON) || defined(_MSC_VER)
+    #include <arm_neon.h>
+#endif
+
+/* GCC and LLVM Clang, but not Apple Clang */
+#if defined(__GNUC__) && !defined(__apple_build_version__)
+    #if defined(__ARM_ACLE) || defined(__ARM_FEATURE_CRYPTO)
+        #include <arm_acle.h>
+    #endif
+#endif
+#define AES_IMPLEMENT_ARM_NEON
+#else
+#define AES_IMPLEMENT_PORTABLE_CPLUSPLUS
+#endif
+
+#if defined(USE_AES_ARM_NEON)
+#undef AES_IMPLEMENT_INTEL_AESNI
+#undef AES_IMPLEMENT_PORTABLE_CPLUSPLUS
+#elif defined(USE_AES_INTEL_AESNI)
+#undef AES_IMPLEMENT_ARM_NEON
+#undef AES_IMPLEMENT_PORTABLE_CPLUSPLUS
+#else
+#undef AES_IMPLEMENT_ARM_NEON
+#undef AES_IMPLEMENT_INTEL_AESNI
+#endif
+
+#endif
+
+#endif

package/cpp/algorithms/Krypt/blockcipher.hpp

@@ -0,0 +1,69 @@
+/*
+ * 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_BLOCKCIPHER_HPP
+#define KRYPT_BLOCKCIPHER_HPP
+
+#include <cstring>
+#include <exception>
+#include <iostream>
+#include "types.hpp"
+
+namespace Krypt {
+    namespace BlockCipher {
+        class BASE_BLOCKCIPHER {
+            public:
+
+            size_t BLOCK_SIZE;
+
+            BASE_BLOCKCIPHER(size_t blockSize) : BLOCK_SIZE(blockSize) {
+            }
+
+            /// encrypts a fixed 16 byte block from `src` into `dest`.
+            /// @param src a pointer to an array of unsigned char*/Bytes* in heap this is
+            /// the array you want to encrypt.
+            /// @param dest another pointer to an array of unsigned char*/Bytes* in heap
+            /// this is the array where the encrypted block will be stored.
+            virtual void EncryptBlock(Bytes *, Bytes *) = 0;
+
+            /// decrypts a fixed 16 byte block from `src` into `dest`.
+            /// @param src a pointer to an array of unsigned char*/Bytes* in heap this is
+            /// the array you want to decrypt.
+            /// @param dest another pointer to an array of unsigned char*/Bytes* in heap
+            /// this is the array where the decrypted block will be stored.
+            virtual void DecryptBlock(Bytes *, Bytes *) = 0;
+
+            virtual ~BASE_BLOCKCIPHER() = default;
+        };
+    } // namespace BlockCipher
+} // namespace Krypt
+
+#endif
+
+#endif

package/cpp/algorithms/Krypt/bytearray.cpp

@@ -0,0 +1,158 @@
+/*
+ * 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_BYTEARRAY_CPP
+#define KRYPT_BYTEARRAY_CPP
+
+#include "bytearray.hpp"
+
+namespace Krypt {
+    // returns the pointer array, leaving the .array() equal to NULL, and .length() equal to zero
+    Bytes *ByteArray::detach() {
+        Bytes *ptr = array;
+        array = NULL;
+        length = 0;
+        return ptr;
+    }
+
+    const Bytes &ByteArray::operator[](size_t i) const {
+#ifndef INDEX_CHECK_DISABLE
+        if (length == 0) {
+            throw std::underflow_error(
+                "Krypt::ByteArray[] :"
+                "       accessing an empty byte array"
+            );
+        }
+
+        if (i >= length) {
+            throw std::overflow_error(
+                "Krypt::ByteArray[] :"
+                "       index given for operator[] is greater-than ByteArray.length()-1"
+            );
+        }
+#endif
+        return array[i];
+    }
+
+    Bytes &ByteArray::operator[](size_t i) {
+#ifndef INDEX_CHECK_DISABLE
+        if (length == 0) {
+            throw std::underflow_error(
+                "Krypt::ByteArray[] :"
+                "       accessing an empty byte array"
+            );
+        }
+
+        if (i >= length) {
+            throw std::overflow_error(
+                "Krypt::ByteArray[] :"
+                "       index given for operator[] is greater-than ByteArray.length()-1"
+            );
+        }
+#endif
+        return array[i];
+    }
+
+    ByteArray::ByteArray() {
+        array = NULL;
+        length = 0;
+    }
+
+    ByteArray::ByteArray(Bytes *heap_obj, size_t length) {
+        array = heap_obj;
+        this->length = length;
+    }
+
+    // copy constructor
+    ByteArray::ByteArray(const ByteArray &other) : array(new Bytes[other.length]), length(other.length) {
+        memcpy(array, other.array, other.length);
+    }
+
+    // move constructor
+    ByteArray::ByteArray(ByteArray &&other) noexcept : array(other.array), length(other.length) {
+        other.array = NULL;
+        other.length = 0;
+    }
+
+    // copy assignment
+    ByteArray &ByteArray::operator=(const ByteArray &other) {
+        if (this != &other) {
+            if (array != NULL) {
+                memset((Bytes *) array, 0x00, length);
+                delete[] array;
+            }
+
+            array = new Bytes[other.length];
+            length = other.length;
+            memcpy(array, other.array, other.length);
+        }
+        return *this;
+    }
+
+    // move assingment
+    ByteArray &ByteArray::operator=(ByteArray &&other) noexcept {
+        if (this != &other) {
+            if (array != NULL) {
+                memset((Bytes *) array, 0x00, length);
+                delete[] array;
+            }
+
+            array = other.array;
+            length = other.length;
+
+            other.array = NULL;
+            other.length = 0;
+        }
+        return *this;
+    }
+
+    ByteArray::~ByteArray() {
+        if (array != NULL) {
+            memset((Bytes *) array, 0x00, length);
+            delete[] array;
+        }
+        length = 0;
+    }
+
+    std::ostream &operator<<(std::ostream &outputStream, const ByteArray &instance) {
+        for (size_t i = 0; i < instance.length; ++i) {
+            outputStream << instance.array[i];
+        }
+        return outputStream;
+    }
+
+    std::istream &operator>>(std::istream &inputStream, ByteArray &instance) {
+        for (size_t i = 0; i < instance.length; ++i) {
+            inputStream >> instance.array[i];
+        }
+        return inputStream;
+    }
+} // namespace  Krypt
+
+#endif
+
+#endif

package/cpp/algorithms/Krypt/bytearray.hpp

@@ -0,0 +1,80 @@
+/*
+ * 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_BYTEARRAY_HPP
+#define KRYPT_BYTEARRAY_HPP
+
+#include <iostream>
+#include <utility>
+#include "types.hpp"
+
+namespace Krypt {
+    class ByteArray {
+        public:
+
+        /// this is the Bytes* or unsigned char* that contains the elements of the array
+        Bytes *array;
+
+        /// the total element of the in the array
+        size_t length;
+
+        /// detach the heap allocated pointer inside of the ByteArray class instance.
+        /// @return raw pointer of unsigned char* or Bytes*.
+        Bytes *detach();
+
+        Bytes &operator[](size_t i);
+        const Bytes &operator[](size_t i) const;
+
+        ByteArray();
+
+        ByteArray(Bytes *heap_obj, size_t length);
+
+        // copy constructor
+        ByteArray(const ByteArray &other);
+
+        // move constructor
+        ByteArray(ByteArray &&other) noexcept;
+
+        // copy assignment
+        ByteArray &operator=(const ByteArray &other);
+
+        // move assingment
+        ByteArray &operator=(ByteArray &&other) noexcept;
+
+        ~ByteArray();
+    };
+
+    std::ostream &operator<<(std::ostream &outputStream, const ByteArray &instance);
+
+    std::istream &operator>>(std::istream &inputStream, ByteArray &instance);
+} // namespace Krypt
+
+#endif
+
+#endif

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

@@ -0,0 +1,54 @@
+/*
+ * 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_FUNCTIONS_HPP
+#define KRYPT_FUNCTIONS_HPP
+
+#include <iostream>
+#include "types.hpp"
+
+namespace Krypt {
+    Bytes xtime(Bytes b); // multiply on x
+    void SubDWordBytes(Bytes *a);
+    void RotDWord(Bytes *a);
+    void XorDWords(Bytes *a, Bytes *b, Bytes *dest);
+    void XorBlocks(unsigned char *a, unsigned char *b, unsigned char *c, unsigned int len);
+    void XorAesBlock(unsigned char *a, unsigned char *b, unsigned char *result);
+
+    void Rcon(Bytes *a, int n);
+    void printHexArray(unsigned char a[], size_t n);
+    void printHexVector(const std::vector<unsigned char> &a);
+
+    std::vector<unsigned char> ArrayToVector(std::unique_ptr<unsigned char[]> a, unsigned char len);
+    std::unique_ptr<unsigned char[]> VectorToArray(const std::vector<unsigned char>& a);
+} // namespace Krypt
+
+#endif
+
+#endif