react-native-mmkv 3.0.0-beta.7 → 3.0.0

package/MMKV/Core/KeyValueHolder.cpp

@@ -131,7 +131,7 @@ uint32_t KeyValueHolderCrypt::realValueSize() const {
 
 // 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)];
+    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)) {

package/MMKV/Core/KeyValueHolder.h

@@ -78,7 +78,11 @@ struct KeyValueHolderCrypt {
         return sizeof(KeyValueHolderCrypt) - offsetof(KeyValueHolderCrypt, paddedValue);
     }
 
-    static bool isValueStoredAsOffset(size_t valueSize) { return valueSize >= 256; }
+    static constexpr size_t MediumBufferSize() {
+        return 256;
+    }
+
+    static bool isValueStoredAsOffset(size_t valueSize) { return valueSize > MediumBufferSize(); }
 
     KeyValueHolderCrypt() = default;
     KeyValueHolderCrypt(const void *valuePtr, size_t valueLength);

package/MMKV/Core/MMKVPredef.h

@@ -34,7 +34,7 @@
 #include <vector>
 #include <unordered_map>
 
-constexpr auto MMKV_VERSION = "v1.3.7";
+constexpr auto MMKV_VERSION = "v1.3.9";
 
 #ifdef DEBUG
 #    define MMKV_DEBUG

package/MMKV/Core/MMKV_IO.cpp

@@ -338,7 +338,6 @@ void MMKV::checkLoadData() {
     }
 }
 
-constexpr uint32_t ItemSizeHolder = 0x00ffffff;
 constexpr uint32_t ItemSizeHolderSize = 4;
 
 static pair<MMBuffer, size_t> prepareEncode(const MMKVMap &dic) {
@@ -911,17 +910,22 @@ KVHolderRet_t MMKV::doOverrideDataWithKey(const MMBuffer &data,
         } else {
             m_crypter->resetIV();
         }
-        if (KeyValueHolderCrypt::isValueStoredAsOffset(valueLength)) {
-            m_crypter->getCurStatus(t_status);
-        }
     }
 #endif
     try {
         // write ItemSizeHolder
         m_output->setPosition(0);
-        m_output->writeRawVarint32(ItemSizeHolder);
+        m_output->writeUInt32(AESCrypt::randomItemSizeHolder(ItemSizeHolderSize));
         m_actualSize = ItemSizeHolderSize;
-
+#ifndef MMKV_DISABLE_CRYPT
+        if (m_crypter) {
+            auto ptr = (uint8_t *) m_file->getMemory() + Fixed32Size;
+            m_crypter->encrypt(ptr, ptr, m_actualSize);
+            if (KeyValueHolderCrypt::isValueStoredAsOffset(valueLength)) {
+                m_crypter->getCurStatus(t_status);
+            }
+        }
+#endif
         if (isKeyEncoded) {
             m_output->writeRawData(keyData);
         } else {
@@ -941,10 +945,10 @@ KVHolderRet_t MMKV::doOverrideDataWithKey(const MMBuffer &data,
 
     auto offset = static_cast<uint32_t>(m_actualSize);
     m_actualSize += size;
-    auto ptr = (uint8_t *) m_file->getMemory() + Fixed32Size;
 #ifndef MMKV_DISABLE_CRYPT
     if (m_crypter) {
-        m_crypter->encrypt(ptr, ptr, m_actualSize);
+        auto ptr = (uint8_t *) m_file->getMemory() + Fixed32Size + offset;
+        m_crypter->encrypt(ptr, ptr, size);
     }
 #endif
     recalculateCRCDigestOnly();
@@ -1128,7 +1132,7 @@ memmoveDictionary(MMKVMap &dic, CodedOutputData *output, uint8_t *ptr, AESCrypt
         }
     }
     // hold the fake size of dictionary's serialization result
-    output->writeRawVarint32(ItemSizeHolder);
+    output->writeUInt32(AESCrypt::randomItemSizeHolder(ItemSizeHolderSize));
     auto writtenSize = static_cast<size_t>(writePtr - originOutputPtr);
 #ifndef MMKV_DISABLE_CRYPT
     if (encrypter) {
@@ -1159,14 +1163,16 @@ static void memmoveDictionary(MMKVMapCrypt &dic,
         }
         sort(vec.begin(), vec.end(), [](auto left, auto right) { return left->offset < right->offset; });
     }
-    auto sizeHolder = ItemSizeHolder, sizeHolderSize = ItemSizeHolderSize;
+    auto sizeHolderSize = ItemSizeHolderSize;
+    auto sizeHolder = AESCrypt::randomItemSizeHolder(sizeHolderSize);
     if (!vec.empty()) {
         auto smallestOffset = vec.front()->offset;
         if (smallestOffset != ItemSizeHolderSize && smallestOffset <= 5) {
             sizeHolderSize = smallestOffset;
             assert(sizeHolderSize != 0);
             static const uint32_t ItemSizeHolders[] = {0, 0x0f, 0xff, 0xffff, 0xffffff, 0xffffffff};
-            sizeHolder = ItemSizeHolders[sizeHolderSize];
+            sizeHolder = AESCrypt::randomItemSizeHolder(sizeHolderSize);
+            assert(sizeHolder >= ItemSizeHolders[sizeHolderSize] && sizeHolder <= ItemSizeHolders[sizeHolderSize]);
         }
     }
     output->writeRawVarint32(static_cast<int32_t>(sizeHolder));
@@ -1230,7 +1236,7 @@ static void memmoveDictionary(MMKVMapCrypt &dic,
 
 static void fullWriteBackWholeData(MMBuffer allData, size_t totalSize, CodedOutputData *output) {
     auto originOutputPtr = output->curWritePointer();
-    output->writeRawVarint32(ItemSizeHolder);
+    output->writeUInt32(AESCrypt::randomItemSizeHolder(ItemSizeHolderSize));
     if (allData.length() > 0) {
         auto dataSize = CodedInputData(allData.getPtr(), allData.length()).readUInt32();
         if (dataSize > 0) {

package/MMKV/Core/MMKV_OSX.cpp

@@ -260,35 +260,21 @@ MMKV::appendDataWithKey(const MMBuffer &data, MMKVKey_t key, const KeyValueHolde
 
 pair<bool, KeyValueHolder>
 MMKV::overrideDataWithKey(const MMBuffer &data, MMKVKey_t key, const KeyValueHolderCrypt &kvHolder, bool isDataHolder) {
-    size_t old_actualSize = m_actualSize;
-    size_t old_position = m_output->getPosition();
-    // only one key in dict, do not append, just rewrite from beginning
-    m_actualSize = 0;
-    m_output->setPosition(0);
-
-    auto m_tmpDic = m_dic;
-    auto m_tmpDicCrypt = m_dicCrypt;
-    if (m_crypter) {
-        m_dicCrypt = new MMKVMapCrypt();
-    } else {
-        m_dic = new MMKVMap();
+    if (kvHolder.type != KeyValueHolderType_Offset) {
+        return overrideDataWithKey(data, key, isDataHolder);
     }
+    SCOPED_LOCK(m_exclusiveProcessLock);
 
-    auto ret = appendDataWithKey(data, key, kvHolder, isDataHolder);
-    if (!ret.first) {
-        // rollback
-        m_actualSize = old_actualSize;
-        m_output->setPosition(old_position);
-    }
+    uint32_t keyLength = kvHolder.keySize;
+    // size needed to encode the key
+    size_t rawKeySize = keyLength + pbRawVarint32Size(keyLength);
 
-    if (m_crypter) {
-        delete m_dicCrypt;
-        m_dicCrypt = m_tmpDicCrypt;
-    } else {
-        delete m_dic;
-        m_dic = m_tmpDic;
-    }
-    return ret;
+    auto basePtr = (uint8_t *) m_file->getMemory() + Fixed32Size;
+    MMBuffer keyData(rawKeySize);
+    AESCrypt decrypter = m_crypter->cloneWithStatus(kvHolder.cryptStatus);
+    decrypter.decrypt(basePtr + kvHolder.offset, keyData.getPtr(), rawKeySize);
+
+    return doOverrideDataWithKey(data, keyData, isDataHolder, keyLength);
 }
 #    endif
 

package/MMKV/Core/ThreadLock.cpp

@@ -38,10 +38,8 @@ ThreadLock::ThreadLock() : m_lock({}) {
 }
 
 ThreadLock::~ThreadLock() {
-#ifdef MMKV_OHOS
-    // OHOS's pthread is buggy, check for POC: https://gist.github.com/lingol/622af352e090e0490ebacfe3a38b9221 
     pthread_mutex_unlock(&m_lock);
-#endif
+
     pthread_mutex_destroy(&m_lock);
 }
 

package/MMKV/Core/aes/AESCrypt.cpp

@@ -25,12 +25,25 @@
 #include <cstring>
 #include <ctime>
 
+namespace mmkv {
+
+// assuming size in [1, 5]
+uint32_t AESCrypt::randomItemSizeHolder(uint32_t size) {
+    constexpr uint32_t ItemSizeHolders[] = {0, 0x80, 0x4000, 0x200000, 0x10000000, 0};
+    auto ItemSizeHolderMin = ItemSizeHolders[size - 1];
+    auto ItemSizeHolderMax = ItemSizeHolders[size] - 1;
+
+    srand((unsigned) time(nullptr));
+    auto result = static_cast<uint32_t>(rand());
+    result = result % (ItemSizeHolderMax - ItemSizeHolderMin + 1);
+    result += ItemSizeHolderMin;
+    return result;
+}
+
 #ifndef MMKV_DISABLE_CRYPT
 
 using namespace openssl;
 
-namespace mmkv {
-
 AESCrypt::AESCrypt(const void *key, size_t keyLength, const void *iv, size_t ivLength) {
     if (key && keyLength > 0) {
         memcpy(m_key, key, (keyLength > AES_KEY_LEN) ? AES_KEY_LEN : keyLength);
@@ -161,8 +174,6 @@ AESCrypt AESCrypt::cloneWithStatus(const AESCryptStatus &status) const {
     return AESCrypt(*this, status);
 }
 
-} // namespace mmkv
-
 #    ifdef MMKV_DEBUG
 
 #        include "../MMKVLog.h"
@@ -170,8 +181,17 @@ AESCrypt AESCrypt::cloneWithStatus(const AESCryptStatus &status) const {
 
 namespace mmkv {
 
+void testRandomPlaceHolder() {
+    for (uint32_t size = 1; size < 6; size++) {
+        auto holder = AESCrypt::randomItemSizeHolder(size);
+        MMKVInfo("holder 0x%x for size %u", holder, size);
+    }
+}
+
 // check if AESCrypt is encrypt-decrypt full-duplex
 void AESCrypt::testAESCrypt() {
+    testRandomPlaceHolder();
+
     const uint8_t plainText[] = "Hello, OpenSSL-mmkv::AESCrypt::testAESCrypt() with AES CFB 128.";
     constexpr size_t textLength = sizeof(plainText) - 1;
 
@@ -250,7 +270,7 @@ void AESCrypt::testAESCrypt() {
     delete[] decryptText;
 }
 
-} // namespace mmkv
-
 #    endif // MMKV_DEBUG
 #endif     // MMKV_DISABLE_CRYPT
+
+} // namespace mmkv

package/MMKV/Core/aes/AESCrypt.h

@@ -29,7 +29,10 @@
 #ifdef MMKV_DISABLE_CRYPT
 
 namespace mmkv {
-class AESCrypt;
+class AESCrypt {
+public:
+    static uint32_t randomItemSizeHolder(uint32_t size);
+};
 }
 
 #else
@@ -88,6 +91,7 @@ public:
     void getKey(void *output) const;
 
     static void fillRandomIV(void *vector);
+    static uint32_t randomItemSizeHolder(uint32_t size);
 
     // just forbid it for possibly misuse
     explicit AESCrypt(const AESCrypt &other) = delete;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-mmkv",
-  "version": "3.0.0-beta.7",
+  "version": "3.0.0",
   "description": "The fastest key/value storage for React Native. ~30x faster than AsyncStorage! Works on Android, iOS and Web.",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",