//
//  FingerprintUtils.h
//  libraries/networking/src
//
//  Created by David Kelly on 2016-12-02.
//  Copyright 2016 High Fidelity, Inc.
//
//  Distributed under the Apache License, Version 2.0.
//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//

#include "FingerprintUtils.h"
#include "NetworkLogging.h"

#include <QDebug>

#include <SettingHandle.h>
#include <SettingManager.h>
#include <DependencyManager.h>
#include <QFile>
#include <QCryptographicHash>
#include <QDirIterator>

#ifdef Q_OS_WIN
#include <Windows.h>
#include <winreg.h>
#endif //Q_OS_WIN

#ifdef Q_OS_MAC
#include <IOKit/IOBSD.h>
#include <IOKit/IOKitLib.h>
#include <IOKit/storage/IOMedia.h>
#endif //Q_OS_MAC

// Number of iterations to apply to the hash, for stretching.
// The number is arbitrary and has the only purpose of slowing down brute-force
// attempts. The number here should be low enough not to cause any trouble for
// low-end hardware.
//
// Changing this results in different hardware IDs being computed.
static const int HASH_ITERATIONS = 65535;

// Salt string for the hardware ID, makes our IDs unique to our project.
// Changing this results in different hardware IDs being computed.
static const QByteArray HASH_SALT{"Overte"};

static const QString FALLBACK_FINGERPRINT_KEY = "fallbackFingerprint";

QUuid FingerprintUtils::_machineFingerprint { QUuid() };

QString FingerprintUtils::getMachineFingerprintString() {
    QCryptographicHash hash(QCryptographicHash::Keccak_256);

#ifdef Q_OS_LINUX
    // As per the documentation:
    // https://man7.org/linux/man-pages/man5/machine-id.5.html
    //
    // we use the machine id as a base, but add an application-specific key to it.
    // If machine-id isn't available, we try hardware networking devices instead.

    QFile machineIdFile("/etc/machine-id");
    if (!machineIdFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
        // No machine ID, probably no systemd.
        qCWarning(networking) << "Failed to open /etc/machine-id";

        QDir netDevicesDir("/sys/class/net");
        QFileInfoList netDevicesInfo = netDevicesDir.entryInfoList(QDir::Dirs | QDir::NoDotAndDotDot, QDir::Name);

        if (netDevicesInfo.empty()) {
            // Let getMachineFingerprint handle this contingency
            qCWarning(networking) << "Failed to find any hardware networking devices";
            return QUuid().toString();
        }

        for(auto& fileInfo : netDevicesInfo) {

            if (fileInfo.isSymLink() && fileInfo.symLinkTarget().contains("virtual")) {
                // symlink points to something like:
                // ../../devices/virtual/net/lo
                // these are not real devices and have random IDs, so we
                // don't care about them.
                continue;
            }

            QFile addressFile(fileInfo.filePath() + "/address");
            if (addressFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
                qCDebug(networking) << "Adding contents of " << addressFile.fileName();
                hash.addData(addressFile.readAll());
            } else {
                qCWarning(networking) << "Failed to read " << addressFile.fileName();
            }
        }
    } else {
        QByteArray data = machineIdFile.readAll();
        hash.addData(data);
    }

#endif //Q_OS_LINUX

#ifdef Q_OS_MAC
    io_registry_entry_t ioRegistryRoot = IORegistryEntryFromPath(kIOMasterPortDefault, "IOService:/");
    CFStringRef uuidCf = (CFStringRef) IORegistryEntryCreateCFProperty(ioRegistryRoot, CFSTR(kIOPlatformUUIDKey), kCFAllocatorDefault, 0);
    IOObjectRelease(ioRegistryRoot);
    hash.addData(QString::fromCFString(uuidCf).toUtf8());
    CFRelease(uuidCf); 
#endif //Q_OS_MAC

#ifdef Q_OS_WIN
    HKEY cryptoKey;
    bool success = false;

    // try and open the key that contains the machine GUID
    if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Cryptography", 0, KEY_READ, &cryptoKey) == ERROR_SUCCESS) {
        DWORD type;
        DWORD guidSize;

        const char* MACHINE_GUID_KEY = "MachineGuid";

        // try and retrieve the size of the GUID value
        if (RegQueryValueEx(cryptoKey, MACHINE_GUID_KEY, NULL, &type, NULL, &guidSize) == ERROR_SUCCESS) {
            // make sure that the value is a string
            if (type == REG_SZ) {
                // retrieve the machine GUID and return that as our UUID string
                std::string machineGUID(guidSize / sizeof(char), '\0');

                if (RegQueryValueEx(cryptoKey, MACHINE_GUID_KEY, NULL, NULL,
                                    reinterpret_cast<LPBYTE>(&machineGUID[0]), &guidSize) == ERROR_SUCCESS) {
                    hash.addData(QString::fromStdString(machineGUID).toUtf8());
                    success = true;
                }
            }
        }

        RegCloseKey(cryptoKey);
    }

    if (!success) {
        // Let getMachineFingerprint handle this contingency
        return QUuid().toString();
    }
#endif //Q_OS_WIN

    // Makes this hash unique to us
    hash.addData(HASH_SALT);

    // Stretching
    for (int i = 0; i < HASH_ITERATIONS; i++) {
        hash.addData(hash.result());
    }

    QByteArray result = hash.result();
    result.resize(128 / 8); // GUIDs are 128 bit numbers

    // Set UUID version to 4, ensuring it's a valid UUID
    result[6] = (result[6] & 0x0F) | 0x40;

    // Of course, Qt couldn't be nice and just parse something like:
    // 1b1b9d6d45c2473bac13dc3011ff58d6
    //
    // So we have to turn it into:
    // {1b1b9d6d-45c2-473b-ac13-dc3011ff58d6}

    QString uuidString = result.toHex();
    uuidString.insert(20, '-');
    uuidString.insert(16, '-');
    uuidString.insert(12, '-');
    uuidString.insert(8, '-');
    uuidString.prepend("{");
    uuidString.append("}");

    qCDebug(networking) << "Final machine fingerprint:" << uuidString;

    return uuidString;
}

QUuid FingerprintUtils::getMachineFingerprint() {

    if (_machineFingerprint.isNull()) {
        QString uuidString = getMachineFingerprintString();

        // now, turn into uuid.  A malformed string will
        // return QUuid() ("{00000...}"), which handles
        // any errors in getting the string
        QUuid uuid(uuidString);

        if (uuid == QUuid()) {
            // if you cannot read a fallback key cuz we aren't saving them, just generate one for
            // this session and move on
            if (DependencyManager::get<Setting::Manager>().isNull()) {
                return QUuid::createUuid();
            }
            // read fallback key (if any)
            Settings settings;
            uuid = QUuid(settings.value(FALLBACK_FINGERPRINT_KEY).toString());
            qCDebug(networking) << "read fallback maching fingerprint: " << uuid.toString();

            if (uuid == QUuid()) {
                // no fallback yet, set one
                uuid = QUuid::createUuid();
                settings.setValue(FALLBACK_FINGERPRINT_KEY, uuid.toString());
                qCDebug(networking) << "no fallback machine fingerprint, setting it to: " << uuid.toString();
            }
        }

        _machineFingerprint = uuid;
    }

    return _machineFingerprint;
}