qv4compileddata.cpp

++ // Copyright (C) 2024 The Qt Company Ltd.

++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only

++ // Qt-Security score:critical data-parser

++

++ #include "qv4compileddata_p.h"

++

++ #include <private/inlinecomponentutils_p.h>

++ #include <private/qqmlscriptdata_p.h>

++ #include <private/qqmltypenamecache_p.h>

++ #include <private/qv4resolvedtypereference_p.h>

++

++ #include <QtQml/qqmlfile.h>

++

++ #include <QtCore/qdir.h>

++ #include <QtCore/qscopeguard.h>

++ #include <QtCore/qstandardpaths.h>

++ #include <QtCore/qxpfunctional.h>

++

++ QT_BEGIN_NAMESPACE

++

++ namespace QV4 {

++ namespace CompiledData {

++

++

++ bool Unit::verifyHeader(QDateTime expectedSourceTimeStamp, QString *errorString) const

++ {

++     if (strncmp(magic, CompiledData::magic_str, sizeof(magic))) {

++         *errorString = QStringLiteral("Magic bytes in the header do not match");

++         return false;

++     }

++

++     if (version != quint32(QV4_DATA_STRUCTURE_VERSION)) {

++         *errorString = QString::fromUtf8("V4 data structure version mismatch. Found %1 expected %2")

++                                .arg(quint32(version), 0, 16).arg(QV4_DATA_STRUCTURE_VERSION, 0, 16);

++         return false;

++     }

++

++     switch (sourceTimeStamp) {

++     case 0:

++         // No validation necessary

++         return true;

++     case -1:

++         // Content-hash mode: the unit is validated against sourceChecksum rather than the source

++         // file's time stamp. The actual comparison is done in CompilationUnit::loadFromDisk, which

++         // has access to the source code.

++         return true;

++     default:

++         break;

++     }

++

++     // Files from the resource system do not have any time stamps, so fall back to the application

++     // executable.

++     if (!expectedSourceTimeStamp.isValid()) {

++         expectedSourceTimeStamp = QFileInfo(QCoreApplication::applicationFilePath()).lastModified();

++         if (!expectedSourceTimeStamp.isValid()) {

++             *errorString =

++                     QStringLiteral("Failed to get valid timestamp from application executable");

++             return false;

++         }

++     }

++     if (expectedSourceTimeStamp.toMSecsSinceEpoch() != sourceTimeStamp) {

++         *errorString =

++                 QStringLiteral("QML source file has a different time stamp than cached file.");

++         return false;

++     }

++

++     return true;

++ }

++

++ /*!

++     \internal

++     This function creates a temporary key vector and sorts it to guarantuee a stable

++     hash. This is used to calculate a check-sum on dependent meta-objects.

++  */

++ bool ResolvedTypeReferenceMap::addToHash(

++         QCryptographicHash *hash, QHash<quintptr, QByteArray> *checksums) const

++ {

++     std::vector<int> keys (size());

++     int i = 0;

++     for (auto it = constBegin(), end = constEnd(); it != end; ++it) {

++         keys[i] = it.key();

++         ++i;

++     }

++     std::sort(keys.begin(), keys.end());

++     for (int key: keys) {

++         if (!this->operator[](key)->addToHash(hash, checksums))

++             return false;

++     }

++

++     return true;

++ }

++

++ CompilationUnit::CompilationUnit(

++         const Unit *unitData, const QString &fileName, const QString &finalUrlString)

++ {

++     setUnitData(unitData, nullptr, fileName, finalUrlString);

++ }

++

++ CompilationUnit::~CompilationUnit()

++ {

++     qDeleteAll(resolvedTypes);

++

++     if (data) {

++         if (data->qmlUnit() != qmlData)

++             free(const_cast<QmlUnit *>(qmlData));

++         qmlData = nullptr;

++

++         if (!(data->flags & QV4::CompiledData::Unit::StaticData))

++             free(const_cast<Unit *>(data));

++     }

++     data = nullptr;

++ #if Q_BYTE_ORDER == Q_BIG_ENDIAN

++     delete [] constants;

++     constants = nullptr;

++ #endif

++ }

++

++ QString CompilationUnit::localCacheFilePath(const QUrl &url)

++ {

++     static const QByteArray envCachePath = qgetenv("QML_DISK_CACHE_PATH");

++

++     const QString localSourcePath = QQmlFile::urlToLocalFileOrQrc(url);

++     const QString cacheFileSuffix

++             = QFileInfo(localSourcePath + QLatin1Char('c')).completeSuffix();

++     QCryptographicHash fileNameHash(QCryptographicHash::Sha1);

++     fileNameHash.addData(localSourcePath.toUtf8());

++     QString directory = envCachePath.isEmpty()

++             ? QStandardPaths::writableLocation(QStandardPaths::CacheLocation)

++                     + QLatin1String("/qmlcache/")

++             : QString::fromLocal8Bit(envCachePath) + QLatin1String("/");

++     QDir::root().mkpath(directory);

++     return directory + QString::fromUtf8(fileNameHash.result().toHex())

++             + QLatin1Char('.') + cacheFileSuffix;

++ }

++

++ bool CompilationUnit::loadFromDisk(

++         const QUrl &url, const QDateTime &sourceTimeStamp,

++         qxp::function_ref<QByteArray() const> sourceChecksum, QString *errorString)

++ {

++     if (!QQmlFile::isLocalFile(url)) {

++         *errorString = QStringLiteral("File has to be a local file.");

++         return false;

++     }

++

++     const QString sourcePath = QQmlFile::urlToLocalFileOrQrc(url);

++     auto cacheFile = std::make_unique<CompilationUnitMapper>();

++

++     const QStringList cachePaths = { sourcePath + QLatin1Char('c'), localCacheFilePath(url) };

++     for (const QString &cachePath : cachePaths) {

++         Unit *mappedUnit = cacheFile->get(cachePath, sourceTimeStamp, errorString);

++         if (!mappedUnit)

++             continue;

++

++         const Unit *oldData = unitData();

++         const Unit * const oldDataPtr

++                 = (oldData && !(oldData->flags & Unit::StaticData))

++                 ? oldData

++                 : nullptr;

++

++         auto dataPtrRevert = qScopeGuard([this, oldData](){

++             setUnitData(oldData);

++         });

++         setUnitData(mappedUnit);

++

++         if (mappedUnit->sourceTimeStamp == -1) {

++             const QByteArray checksum = sourceChecksum();

++             if (checksum.size() != sizeof(mappedUnit->sourceChecksum)

++                 || memcmp(mappedUnit->sourceChecksum, checksum.constData(), checksum.size()) != 0) {

++                 *errorString = QStringLiteral(

++                         "QML source file has a different content checksum than cached file.");

++                 continue;

++             }

++         }

++

++         if (mappedUnit->sourceFileIndex != 0) {

++             if (mappedUnit->sourceFileIndex >=

++                 mappedUnit->stringTableSize + dynamicStrings.size()) {

++                 *errorString = QStringLiteral("QML source file index is invalid.");

++                 continue;

++             }

++             if (sourcePath !=

++                 QQmlFile::urlToLocalFileOrQrc(stringAt(mappedUnit->sourceFileIndex))) {

++                 *errorString = QStringLiteral("QML source file has moved to a different location.");

++                 continue;

++             }

++         }

++

++         dataPtrRevert.dismiss();

++         free(const_cast<Unit*>(oldDataPtr));

++         backingFile = std::move(cacheFile);

++         return true;

++     }

++

++     return false;

++ }

++

++ bool CompilationUnit::saveToDisk(

++         const QUrl &unitUrl, qxp::function_ref<QByteArray() const> sourceChecksum,

++         QString *errorString) const

++ {

++     if (!QQmlFile::isLocalFile(unitUrl)) {

++         *errorString = QStringLiteral("File has to be a local file.");

++         return false;

++     }

++

++     Unit *mutableUnit = const_cast<Unit *>(unitData());

++     const QByteArray checksum = sourceChecksum();

++     if (checksum.size() != sizeof(mutableUnit->sourceChecksum)) {

++         *errorString = QStringLiteral("Failed to compute source code checksum");

++         return false;

++     }

++

++     // Switch the unit to content-hash mode for the duration of the write. sourceTimeStamp and

++     // sourceChecksum live before md5Checksum and are therefore not covered by it, so we can patch

++     // them without recomputing the integrity checksum. Restore them afterwards because the

++     // in-memory unit is kept around and may still be used with its original time stamp.

++     const qint64 oldTimeStamp = mutableUnit->sourceTimeStamp;

++     char oldChecksum[sizeof(mutableUnit->sourceChecksum)];

++     memcpy(oldChecksum, mutableUnit->sourceChecksum, sizeof(oldChecksum));

++     mutableUnit->sourceTimeStamp = -1;

++     memcpy(mutableUnit->sourceChecksum, checksum.constData(), sizeof(mutableUnit->sourceChecksum));

++     const auto restore = qScopeGuard([&]() {

++         mutableUnit->sourceTimeStamp = oldTimeStamp;

++         memcpy(mutableUnit->sourceChecksum, oldChecksum, sizeof(oldChecksum));

++     });

++

++     return SaveableUnitPointer(unitData()).saveToDisk<char>(

++             [&unitUrl, errorString](const char *data, quint32 size) {

++                 const QString cachePath = localCacheFilePath(unitUrl);

++                 if (SaveableUnitPointer::writeDataToFile(

++                             cachePath, data, size, errorString)) {

++                     CompilationUnitMapper::invalidate(cachePath);

++                     return true;

++                 }

++

++                 return false;

++             });

++ }

++

++ QStringList CompilationUnit::moduleRequests() const

++ {

++     QStringList requests;

++     requests.reserve(data->moduleRequestTableSize);

++     for (uint i = 0; i < data->moduleRequestTableSize; ++i)

++         requests << stringAt(data->moduleRequestTable()[i]);

++     return requests;

++ }

++

++ ResolvedTypeReference *CompilationUnit::resolvedType(QMetaType type) const

++ {

++     for (ResolvedTypeReference *ref : std::as_const(resolvedTypes)) {

++         if (ref->type().typeId() == type)

++             return ref;

++     }

++     return nullptr;

++

++ }

++

++ void CompiledData::CompilationUnit::finalizeCompositeType(const QQmlType &type)

++ {

++     // Add to type registry of composites

++     if (propertyCaches.needsVMEMetaObject(/*root object*/0)) {

++         // qmlType is only valid for types that have references to themselves.

++         if (type.isValid()) {

++             qmlType = type;

++         } else {

++             qmlType = QQmlMetaType::findCompositeType(

++                     url(), this, (unitData()->flags & CompiledData::Unit::IsSingleton)

++                             ? QQmlMetaType::Singleton

++                             : QQmlMetaType::NonSingleton);

++         }

++

++         QQmlMetaType::registerInternalCompositeType(this);

++     } else {

++         const QV4::CompiledData::Object *obj = objectAt(/*root object*/0);

++         auto *typeRef = resolvedTypes.value(obj->inheritedTypeNameIndex);

++         Q_ASSERT(typeRef);

++         qmlType = typeRef->type();

++     }

++ }

++

++ bool CompilationUnit::verifyChecksum(const DependentTypesHasher &dependencyHasher) const

++ {

++     if (!dependencyHasher) {

++         for (size_t i = 0; i < sizeof(data->dependencyMD5Checksum); ++i) {

++             if (data->dependencyMD5Checksum[i] != 0)

++                 return false;

++         }

++         return true;

++     }

++     const QByteArray checksum = dependencyHasher();

++     return checksum.size() == sizeof(data->dependencyMD5Checksum)

++             && memcmp(data->dependencyMD5Checksum, checksum.constData(),

++                       sizeof(data->dependencyMD5Checksum)) == 0;

++ }

++

++ QQmlType CompilationUnit::qmlTypeForComponent(const QString &inlineComponentName) const

++ {

++     if (inlineComponentName.isEmpty())

++         return qmlType;

++     return inlineComponentData[inlineComponentName].qmlType;

++ }

++

++ void CompilationUnit::allocateRuntimeData()

++ {

++     Q_ASSERT(qmlData);

++     const uint nObjects = qmlData->nObjects;

++

++     const auto align4 = [](quint32 n) -> quint32 { return (n + 3u) & ~3u; };

++

++     // An offset table for the objects, followed by each object, its bindings and its binding

++     // order. We pad each object so that the next one is aligned.

++     const auto objectSpan = [&](uint nBindings) -> quint32 {

++         return align4(sizeof(RuntimeObject) + nBindings * sizeof(RuntimeBinding)

++                       + nBindings * sizeof(RuntimeBindingIndex));

++     };

++

++     quint32 size = sizeof(RuntimeDataBlock) + nObjects * sizeof(quint32_le);

++     for (uint i = 0; i < nObjects; ++i)

++         size += objectSpan(qmlData->objectAt(i)->nBindings);

++

++     runtimeDataStorage = QByteArray(size, 0);

++     char *base = runtimeDataStorage.data();

++

++     RuntimeDataBlock *block = reinterpret_cast<RuntimeDataBlock *>(base);

++     block->nObjects = nObjects;

++

++     quint32_le *objectOffsetTable = reinterpret_cast<quint32_le *>(base + sizeof(RuntimeDataBlock));

++     quint32 nextOffset = sizeof(RuntimeDataBlock) + nObjects * sizeof(quint32_le);

++

++     for (uint i = 0; i < nObjects; ++i) {

++         const Object *object = qmlData->objectAt(i);

++         const uint nBindings = object->nBindings;

++         objectOffsetTable[i] = nextOffset;

++

++         RuntimeObject *runtimeObject = reinterpret_cast<RuntimeObject *>(base + nextOffset);

++         runtimeObject->offsetToBindingOrder

++                 = sizeof(RuntimeObject) + nBindings * sizeof(RuntimeBinding);

++         nextOffset += objectSpan(nBindings);

++     }

++

++     runtimeData = block;

++ }

++

++ } // namespace CompiledData

++ } // namespace QV4

++

++ QT_END_NAMESPACE

Revision control