react-native-mmkv-dz 2.5.1

package/MMKV/Core/KeyValueHolder.cpp

@@ -0,0 +1,236 @@
+/*
+ * Tencent is pleased to support the open source community by making
+ * MMKV available.
+ *
+ * Copyright (C) 2020 THL A29 Limited, a Tencent company.
+ * All rights reserved.
+ *
+ * Licensed under the BSD 3-Clause License (the "License"); you may not use
+ * this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ *       https://opensource.org/licenses/BSD-3-Clause
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "KeyValueHolder.h"
+#include "PBUtility.h"
+#include "aes/AESCrypt.h"
+#include <cerrno>
+#include <cstring>
+#include <stdexcept>
+
+namespace mmkv {
+
+KeyValueHolder::KeyValueHolder(uint32_t keyLength, uint32_t valueLength, uint32_t off)
+    : keySize(static_cast<uint16_t>(keyLength)), valueSize(valueLength), offset(off) {
+    computedKVSize = keySize + static_cast<uint16_t>(pbRawVarint32Size(keySize));
+    computedKVSize += static_cast<uint16_t>(pbRawVarint32Size(valueSize));
+}
+
+MMBuffer KeyValueHolder::toMMBuffer(const void *basePtr) const {
+    auto realPtr = (uint8_t *) basePtr + offset;
+    realPtr += computedKVSize;
+    return MMBuffer(realPtr, valueSize, MMBufferNoCopy);
+}
+
+#ifndef MMKV_DISABLE_CRYPT
+
+KeyValueHolderCrypt::KeyValueHolderCrypt(const void *src, size_t length) {
+    if (length <= SmallBufferSize()) {
+        type = KeyValueHolderType_Direct;
+        paddedSize = static_cast<uint8_t>(length);
+        memcpy(paddedValue, src, length);
+    } else {
+        type = KeyValueHolderType_Memory;
+        memSize = static_cast<uint32_t>(length);
+        memPtr = malloc(length);
+        if (!memPtr) {
+            throw std::runtime_error(strerror(errno));
+        }
+        memcpy(memPtr, src, memSize);
+    }
+}
+
+KeyValueHolderCrypt::KeyValueHolderCrypt(MMBuffer &&data) {
+    if (data.type == MMBuffer::MMBufferType_Small) {
+        static_assert(SmallBufferSize() >= MMBuffer::SmallBufferSize(), "KeyValueHolderCrypt can't hold MMBuffer");
+
+        type = KeyValueHolderType_Direct;
+        paddedSize = static_cast<uint8_t>(data.length());
+        memcpy(paddedValue, data.getPtr(), data.length());
+    } else {
+        type = KeyValueHolderType_Memory;
+        memSize = static_cast<uint32_t>(data.length());
+#    ifdef MMKV_APPLE
+        if (data.m_data != nil) {
+            memPtr = malloc(memSize);
+            if (!memPtr) {
+                throw std::runtime_error(strerror(errno));
+            }
+            memcpy(memPtr, data.getPtr(), memSize);
+            return;
+        }
+#    endif
+        memPtr = data.getPtr();
+        data.detach();
+    }
+}
+
+KeyValueHolderCrypt::KeyValueHolderCrypt(uint32_t keyLength, uint32_t valueLength, uint32_t off)
+    : type(KeyValueHolderType_Offset), keySize(static_cast<uint16_t>(keyLength)), valueSize(valueLength), offset(off) {
+
+    pbKeyValueSize = static_cast<uint8_t>(pbRawVarint32Size(keySize) + pbRawVarint32Size(valueSize));
+}
+
+KeyValueHolderCrypt::KeyValueHolderCrypt(KeyValueHolderCrypt &&other) noexcept {
+    this->move(std::move(other));
+}
+
+KeyValueHolderCrypt &KeyValueHolderCrypt::operator=(KeyValueHolderCrypt &&other) noexcept {
+    if (type == KeyValueHolderType_Memory && memPtr) {
+        free(memPtr);
+    }
+    this->move(std::move(other));
+    return *this;
+}
+
+void KeyValueHolderCrypt::move(KeyValueHolderCrypt &&other) noexcept {
+    if (other.type == KeyValueHolderType_Direct || other.type == KeyValueHolderType_Offset) {
+        memcpy(this, &other, sizeof(other));
+    } else if (other.type == KeyValueHolderType_Memory) {
+        type = KeyValueHolderType_Memory;
+        memSize = other.memSize;
+        memPtr = other.memPtr;
+        other.memPtr = nullptr;
+    }
+}
+
+KeyValueHolderCrypt::~KeyValueHolderCrypt() {
+    if (type == KeyValueHolderType_Memory && memPtr) {
+        free(memPtr);
+    }
+}
+
+uint32_t KeyValueHolderCrypt::realValueSize() const {
+    switch (type) {
+        case KeyValueHolderType_Direct:
+            return paddedSize;
+        case KeyValueHolderType_Offset:
+            return valueSize;
+        case KeyValueHolderType_Memory:
+            return memSize;
+    }
+    return 0;
+}
+
+// get decrypt data with [position, -1)
+static MMBuffer decryptBuffer(AESCrypt &crypter, const MMBuffer &inputBuffer, size_t position) {
+    static size_t smallBuffer[16 / sizeof(size_t)];
+    auto basePtr = (uint8_t *) inputBuffer.getPtr();
+    auto ptr = basePtr;
+    for (size_t index = sizeof(smallBuffer); index < position; index += sizeof(smallBuffer)) {
+        crypter.decrypt(ptr, smallBuffer, sizeof(smallBuffer));
+        ptr += sizeof(smallBuffer);
+    }
+    if (ptr < basePtr + position) {
+        crypter.decrypt(ptr, smallBuffer, static_cast<size_t>(basePtr + position - ptr));
+        ptr = basePtr + position;
+    }
+    size_t length = inputBuffer.length() - position;
+    MMBuffer tmp(length);
+
+    auto input = ptr;
+    auto output = tmp.getPtr();
+    crypter.decrypt(input, output, length);
+
+    return tmp;
+}
+
+MMBuffer KeyValueHolderCrypt::toMMBuffer(const void *basePtr, const AESCrypt *crypter) const {
+    if (type == KeyValueHolderType_Direct) {
+        return MMBuffer((void *) paddedValue, paddedSize, MMBufferNoCopy);
+    } else if (type == KeyValueHolderType_Memory) {
+        return MMBuffer(memPtr, memSize, MMBufferNoCopy);
+    } else {
+        auto realPtr = (uint8_t *) basePtr + offset;
+        auto position = static_cast<uint32_t>(pbKeyValueSize + keySize);
+        auto realSize = position + valueSize;
+        auto kvBuffer = MMBuffer(realPtr, realSize, MMBufferNoCopy);
+        auto decrypter = crypter->cloneWithStatus(cryptStatus);
+        return decryptBuffer(decrypter, kvBuffer, position);
+    }
+}
+
+#endif // MMKV_DISABLE_CRYPT
+
+} // namespace mmkv
+
+#if !defined(MMKV_DISABLE_CRYPT) && defined(MMKV_DEBUG)
+#    include "CodedInputData.h"
+#    include "CodedOutputData.h"
+#    include "MMKVLog.h"
+#    include <ctime>
+
+using namespace std;
+
+namespace mmkv {
+
+void KeyValueHolderCrypt::testAESToMMBuffer() {
+    const uint8_t plainText[] = "Hello, OpenSSL-mmkv::KeyValueHolderCrypt::testAESToMMBuffer() with AES CFB 128.";
+    constexpr size_t textLength = sizeof(plainText) - 1;
+
+    const uint8_t key[] = "TheAESKey";
+    constexpr size_t keyLength = sizeof(key) - 1;
+
+    uint8_t iv[AES_KEY_LEN];
+    srand((unsigned) time(nullptr));
+    for (uint32_t i = 0; i < AES_KEY_LEN; i++) {
+        iv[i] = (uint8_t) rand();
+    }
+    AESCrypt crypt1(key, keyLength, iv, sizeof(iv));
+
+    auto encryptText = new uint8_t[DEFAULT_MMAP_SIZE];
+    memset(encryptText, 0, DEFAULT_MMAP_SIZE);
+    CodedOutputData output(encryptText, DEFAULT_MMAP_SIZE);
+    output.writeData(MMBuffer((void *) key, keyLength, MMBufferNoCopy));
+    auto lengthOfValue = textLength + pbRawVarint32Size((uint32_t) textLength);
+    output.writeRawVarint32((int32_t) lengthOfValue);
+    output.writeData(MMBuffer((void *) plainText, textLength, MMBufferNoCopy));
+    crypt1.encrypt(encryptText, encryptText, (size_t)(output.curWritePointer() - encryptText));
+
+    AESCrypt decrypt(key, keyLength, iv, sizeof(iv));
+    uint8_t smallBuffer[32];
+    decrypt.decrypt(encryptText, smallBuffer, 5);
+    auto keySize = CodedInputData(smallBuffer, 5).readUInt32();
+    auto sizeOfKeySize = pbRawVarint32Size(keySize);
+    auto position = sizeOfKeySize;
+    decrypt.decrypt(encryptText + 5, smallBuffer + 5, static_cast<size_t>(sizeOfKeySize + keySize - 5));
+    position += keySize;
+    decrypt.decrypt(encryptText + position, smallBuffer + position, 5);
+    auto valueSize = CodedInputData(smallBuffer + position, 5).readUInt32();
+    // auto sizeOfValueSize = pbRawVarint32Size(valueSize);
+    KeyValueHolderCrypt kvHolder(keySize, valueSize, 0);
+    auto rollbackSize = position + 5;
+    decrypt.statusBeforeDecrypt(encryptText + rollbackSize, smallBuffer + rollbackSize, rollbackSize,
+                                kvHolder.cryptStatus);
+    auto value = kvHolder.toMMBuffer(encryptText, &decrypt);
+#    ifdef MMKV_APPLE
+    MMKVInfo("testAESToMMBuffer: %@", CodedInputData((char *) value.getPtr(), value.length()).readString());
+#    else
+    MMKVInfo("testAESToMMBuffer: %s", CodedInputData((char *) value.getPtr(), value.length()).readString().c_str());
+#    endif
+    MMKVInfo("MMBuffer::SmallBufferSize() = %u, KeyValueHolderCrypt::SmallBufferSize() = %u",
+             MMBuffer::SmallBufferSize(), KeyValueHolderCrypt::SmallBufferSize());
+
+    delete[] encryptText;
+}
+
+} // namespace mmkv
+
+#endif

package/MMKV/Core/KeyValueHolder.h

@@ -0,0 +1,118 @@
+/*
+ * Tencent is pleased to support the open source community by making
+ * MMKV available.
+ *
+ * Copyright (C) 2020 THL A29 Limited, a Tencent company.
+ * All rights reserved.
+ *
+ * Licensed under the BSD 3-Clause License (the "License"); you may not use
+ * this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ *       https://opensource.org/licenses/BSD-3-Clause
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef KeyValueHolder_hpp
+#define KeyValueHolder_hpp
+#ifdef __cplusplus
+
+#include "MMBuffer.h"
+#include "aes/AESCrypt.h"
+
+namespace mmkv {
+
+#pragma pack(push, 1)
+
+struct KeyValueHolder {
+    uint16_t computedKVSize; // internal use only
+    uint16_t keySize;
+    uint32_t valueSize;
+    uint32_t offset;
+
+    KeyValueHolder() = default;
+    KeyValueHolder(uint32_t keyLength, uint32_t valueLength, uint32_t offset);
+
+    MMBuffer toMMBuffer(const void *basePtr) const;
+};
+
+#ifndef MMKV_DISABLE_CRYPT
+
+enum KeyValueHolderType : uint8_t {
+    KeyValueHolderType_Direct, // store value directly
+    KeyValueHolderType_Memory, // store value in the heap memory
+    KeyValueHolderType_Offset, // store value by offset
+};
+
+// kv holder for encrypted mmkv
+struct KeyValueHolderCrypt {
+    KeyValueHolderType type = KeyValueHolderType_Direct;
+
+    union {
+        // store value by offset
+        struct {
+            uint8_t pbKeyValueSize; // size needed to encode keySize & valueSize
+            uint16_t keySize;
+            uint32_t valueSize;
+            uint32_t offset;
+            AESCryptStatus cryptStatus;
+        };
+        // store value directly
+        struct {
+            uint8_t paddedSize;
+            uint8_t paddedValue[1];
+        };
+        // store value in the heap memory
+        struct {
+            uint32_t memSize;
+            void *memPtr;
+        };
+    };
+
+    static constexpr size_t SmallBufferSize() {
+        return sizeof(KeyValueHolderCrypt) - offsetof(KeyValueHolderCrypt, paddedValue);
+    }
+
+    static bool isValueStoredAsOffset(size_t valueSize) { return valueSize >= 256; }
+
+    KeyValueHolderCrypt() = default;
+    KeyValueHolderCrypt(const void *valuePtr, size_t valueLength);
+    explicit KeyValueHolderCrypt(MMBuffer &&data);
+    KeyValueHolderCrypt(uint32_t keyLength, uint32_t valueLength, uint32_t offset);
+
+    KeyValueHolderCrypt(KeyValueHolderCrypt &&other) noexcept;
+    KeyValueHolderCrypt &operator=(KeyValueHolderCrypt &&other) noexcept;
+    void move(KeyValueHolderCrypt &&other) noexcept;
+
+    ~KeyValueHolderCrypt();
+
+    uint32_t realValueSize() const;
+
+    MMBuffer toMMBuffer(const void *basePtr, const AESCrypt *crypter) const;
+
+    std::tuple<uint32_t, uint32_t, AESCryptStatus *> toTuple() {
+        return std::make_tuple(offset, pbKeyValueSize + keySize + valueSize, &cryptStatus);
+    }
+
+    // those are expensive, just forbid it for possibly misuse
+    explicit KeyValueHolderCrypt(const KeyValueHolderCrypt &other) = delete;
+    KeyValueHolderCrypt &operator=(const KeyValueHolderCrypt &other) = delete;
+
+#ifdef MMKV_DEBUG
+    static void testAESToMMBuffer();
+#endif
+};
+
+#endif // MMKV_DISABLE_CRYPT
+
+#pragma pack(pop)
+
+} // namespace mmkv
+
+#endif
+#endif /* KeyValueHolder_hpp */

package/MMKV/Core/MMBuffer.cpp

@@ -0,0 +1,185 @@
+/*
+ * Tencent is pleased to support the open source community by making
+ * MMKV available.
+ *
+ * Copyright (C) 2018 THL A29 Limited, a Tencent company.
+ * All rights reserved.
+ *
+ * Licensed under the BSD 3-Clause License (the "License"); you may not use
+ * this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ *       https://opensource.org/licenses/BSD-3-Clause
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "MMBuffer.h"
+#include <cerrno>
+#include <cstdlib>
+#include <cstring>
+#include <utility>
+#include <stdexcept>
+
+#ifdef MMKV_APPLE
+#    if __has_feature(objc_arc)
+#        error This file must be compiled with MRC. Use -fno-objc-arc flag.
+#    endif
+#endif
+
+using namespace std;
+
+namespace mmkv {
+
+MMBuffer::MMBuffer(size_t length) {
+    if (length > SmallBufferSize()) {
+        type = MMBufferType_Normal;
+        isNoCopy = MMBufferCopy;
+        size = length;
+        ptr = malloc(size);
+        if (!ptr) {
+            throw std::runtime_error(strerror(errno));
+        }
+#ifdef MMKV_APPLE
+        m_data = nil;
+#endif
+    } else {
+        type = MMBufferType_Small;
+        paddedSize = static_cast<uint8_t>(length);
+    }
+}
+
+MMBuffer::MMBuffer(void *source, size_t length, MMBufferCopyFlag flag) : isNoCopy(flag) {
+    if (isNoCopy == MMBufferCopy) {
+        if (length > SmallBufferSize()) {
+            type = MMBufferType_Normal;
+            size = length;
+            ptr = malloc(size);
+            if (!ptr) {
+                throw std::runtime_error(strerror(errno));
+            }
+            memcpy(ptr, source, size);
+#ifdef MMKV_APPLE
+            m_data = nil;
+#endif
+        } else {
+            type = MMBufferType_Small;
+            paddedSize = static_cast<uint8_t>(length);
+            memcpy(paddedBuffer, source, length);
+        }
+    } else {
+        type = MMBufferType_Normal;
+        size = length;
+        ptr = source;
+#ifdef MMKV_APPLE
+        m_data = nil;
+#endif
+    }
+}
+
+#ifdef MMKV_APPLE
+MMBuffer::MMBuffer(NSData *data, MMBufferCopyFlag flag)
+    : type(MMBufferType_Normal), ptr((void *) data.bytes), size(data.length), isNoCopy(flag) {
+    if (isNoCopy == MMBufferCopy) {
+        m_data = [data retain];
+    } else {
+        m_data = data;
+    }
+}
+#endif
+
+MMBuffer::MMBuffer(MMBuffer &&other) noexcept : type(other.type) {
+    if (type == MMBufferType_Normal) {
+        size = other.size;
+        ptr = other.ptr;
+        isNoCopy = other.isNoCopy;
+#ifdef MMKV_APPLE
+        m_data = other.m_data;
+#endif
+        other.detach();
+    } else {
+        paddedSize = other.paddedSize;
+        memcpy(paddedBuffer, other.paddedBuffer, paddedSize);
+    }
+}
+
+MMBuffer &MMBuffer::operator=(MMBuffer &&other) noexcept {
+    if (type == MMBufferType_Normal) {
+        if (other.type == MMBufferType_Normal) {
+            std::swap(isNoCopy, other.isNoCopy);
+            std::swap(size, other.size);
+            std::swap(ptr, other.ptr);
+#ifdef MMKV_APPLE
+            std::swap(m_data, other.m_data);
+#endif
+        } else {
+            type = MMBufferType_Small;
+            if (isNoCopy == MMBufferCopy) {
+#ifdef MMKV_APPLE
+                if (m_data) {
+                    [m_data release];
+                } else if (ptr) {
+                    free(ptr);
+                }
+#else
+                if (ptr) {
+                    free(ptr);
+                }
+#endif
+            }
+            paddedSize = other.paddedSize;
+            memcpy(paddedBuffer, other.paddedBuffer, paddedSize);
+        }
+    } else {
+        if (other.type == MMBufferType_Normal) {
+            type = MMBufferType_Normal;
+            isNoCopy = other.isNoCopy;
+            size = other.size;
+            ptr = other.ptr;
+#ifdef MMKV_APPLE
+            m_data = other.m_data;
+#endif
+            other.detach();
+        } else {
+            uint8_t tmp[SmallBufferSize()];
+            memcpy(tmp, other.paddedBuffer, other.paddedSize);
+            memcpy(other.paddedBuffer, paddedBuffer, paddedSize);
+            memcpy(paddedBuffer, tmp, other.paddedSize);
+            std::swap(paddedSize, other.paddedSize);
+        }
+    }
+
+    return *this;
+}
+
+MMBuffer::~MMBuffer() {
+    if (isStoredOnStack()) {
+        return;
+    }
+
+#ifdef MMKV_APPLE
+    if (m_data) {
+        if (isNoCopy == MMBufferCopy) {
+            [m_data release];
+        }
+        return;
+    }
+#endif
+
+    if (isNoCopy == MMBufferCopy && ptr) {
+        free(ptr);
+    }
+}
+
+void MMBuffer::detach() {
+    // type = MMBufferType_Small;
+    // paddedSize = 0;
+    auto memsetPtr = (size_t *) &type;
+    *memsetPtr = 0;
+}
+
+} // namespace mmkv

package/MMKV/Core/MMBuffer.h

@@ -0,0 +1,107 @@
+/*
+ * Tencent is pleased to support the open source community by making
+ * MMKV available.
+ *
+ * Copyright (C) 2018 THL A29 Limited, a Tencent company.
+ * All rights reserved.
+ *
+ * Licensed under the BSD 3-Clause License (the "License"); you may not use
+ * this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ *
+ *       https://opensource.org/licenses/BSD-3-Clause
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef MMKV_MMBUFFER_H
+#define MMKV_MMBUFFER_H
+#ifdef __cplusplus
+
+#include "MMKVPredef.h"
+
+#include <cstdint>
+#include <cstdlib>
+#include <cstddef>
+
+namespace mmkv {
+
+enum MMBufferCopyFlag : bool {
+    MMBufferCopy = false,
+    MMBufferNoCopy = true,
+};
+
+#pragma pack(push, 1)
+
+#ifndef MMKV_DISABLE_CRYPT
+struct KeyValueHolderCrypt;
+#endif
+
+class MMBuffer {
+    enum MMBufferType : uint8_t {
+        MMBufferType_Small,  // store small buffer in stack memory
+        MMBufferType_Normal, // store in heap memory
+    };
+    MMBufferType type;
+
+    union {
+        struct {
+            MMBufferCopyFlag isNoCopy;
+            size_t size;
+            void *ptr;
+#ifdef MMKV_APPLE
+            NSData *m_data;
+#endif
+        };
+        struct {
+            uint8_t paddedSize;
+            // make at least 10 bytes to hold all primitive types (negative int32, int64, double etc) on 32 bit device
+            // on 64 bit device it's guaranteed larger than 10 bytes
+            uint8_t paddedBuffer[10];
+        };
+    };
+
+    static constexpr size_t SmallBufferSize() {
+        return sizeof(MMBuffer) - offsetof(MMBuffer, paddedBuffer);
+    }
+
+public:
+    explicit MMBuffer(size_t length = 0);
+    MMBuffer(void *source, size_t length, MMBufferCopyFlag flag = MMBufferCopy);
+#ifdef MMKV_APPLE
+    explicit MMBuffer(NSData *data, MMBufferCopyFlag flag = MMBufferCopy);
+#endif
+
+    MMBuffer(MMBuffer &&other) noexcept;
+    MMBuffer &operator=(MMBuffer &&other) noexcept;
+
+    ~MMBuffer();
+
+    bool isStoredOnStack() const { return (type == MMBufferType_Small); }
+
+    void *getPtr() const { return isStoredOnStack() ? (void *) paddedBuffer : ptr; }
+
+    size_t length() const { return isStoredOnStack() ? paddedSize : size; }
+
+    // transfer ownership to others
+    void detach();
+
+    // those are expensive, just forbid it for possibly misuse
+    explicit MMBuffer(const MMBuffer &other) = delete;
+    MMBuffer &operator=(const MMBuffer &other) = delete;
+
+#ifndef MMKV_DISABLE_CRYPT
+    friend KeyValueHolderCrypt;
+#endif
+};
+
+#pragma pack(pop)
+
+} // namespace mmkv
+
+#endif
+#endif //MMKV_MMBUFFER_H