File indexing completed on 2024-11-24 03:41:07

 /*
     This file is part of the KDE libraries
     SPDX-FileCopyrightText: 2021 Slava Aseev <nullptrnine@basealt.ru>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 #include "kwalletfreedesktopsession.h"
 
 #include "kwalletfreedesktopsessionadaptor.h"
 #include <QDBusConnection>
 
 KWalletFreedesktopSession::KWalletFreedesktopSession(KWalletFreedesktopService *service,
                                                      std::unique_ptr<KWalletFreedesktopSessionAlgorithm> algorithm,
                                                      QString sessionPath,
                                                      const QDBusConnection &connection,
                                                      const QDBusMessage &message)
     : m_service(service)
     , m_algorithm(std::move(algorithm))
     , m_sessionPath(std::move(sessionPath))
     , m_serviceBusName(message.service())
 {
     (void)new KWalletFreedesktopSessionAdaptor(this);
     QDBusConnection::sessionBus().registerObject(m_sessionPath, this);
 
     m_serviceWatcher.setConnection(connection);
     m_serviceWatcher.addWatchedService(m_serviceBusName);
     m_serviceWatcher.setWatchMode(QDBusServiceWatcher::WatchForOwnerChange);
     connect(&m_serviceWatcher, &QDBusServiceWatcher::serviceOwnerChanged, this, &KWalletFreedesktopSession::slotServiceOwnerChanged);
 }
 
 void KWalletFreedesktopSession::slotServiceOwnerChanged(const QString &, const QString &, const QString &)
 {
     fdoService()->deleteSession(m_sessionPath);
 }
 
 void KWalletFreedesktopSession::Close()
 {
     if (message().service() != m_serviceBusName) {
         sendErrorReply(QDBusError::ErrorType::UnknownObject, QStringLiteral("Can't find session ") + m_sessionPath);
     } else {
         fdoService()->deleteSession(m_sessionPath);
     }
 }
 
 QByteArray KWalletFreedesktopSession::negotiationOutput() const
 {
     return m_algorithm->negotiationOutput();
 }
 
 bool KWalletFreedesktopSession::encrypt(const QDBusMessage &message, FreedesktopSecret &secret) const
 {
     if (message.service() != m_serviceBusName) {
         return false;
     }
 
     return m_algorithm->encrypt(secret);
 }
 
 bool KWalletFreedesktopSession::decrypt(const QDBusMessage &message, FreedesktopSecret &secret) const
 {
     if (message.service() != m_serviceBusName) {
         return false;
     }
 
     return m_algorithm->decrypt(secret);
 }
 
 KWalletFreedesktopService *KWalletFreedesktopSession::fdoService() const
 {
     return m_service;
 }
 
 KWalletD *KWalletFreedesktopSession::backend() const
 {
     return fdoService()->backend();
 }
 
 QDBusObjectPath KWalletFreedesktopSession::fdoObjectPath() const
 {
     return QDBusObjectPath(m_sessionPath);
 }
 
 QByteArray KWalletFreedesktopSessionAlgorithmPlain::negotiationOutput() const
 {
     return QByteArray();
 }
 
 bool KWalletFreedesktopSessionAlgorithmPlain::encrypt(FreedesktopSecret &secret) const
 {
     secret.parameters = QByteArray();
     return true;
 }
 
 bool KWalletFreedesktopSessionAlgorithmPlain::decrypt(FreedesktopSecret &) const
 {
     return true;
 }
 
 KWalletFreedesktopSessionAlgorithmDhAes::KWalletFreedesktopSessionAlgorithmDhAes(const QCA::PublicKey &publicKey, QCA::SymmetricKey symmetricKey)
     : m_publicKey(publicKey)
     , m_symmetricKey(std::move(symmetricKey))
 {
 }
 
 QByteArray KWalletFreedesktopSessionAlgorithmDhAes::negotiationOutput() const
 {
     return m_publicKey.toDH().y().toArray().toByteArray();
 }
 
 bool KWalletFreedesktopSessionAlgorithmDhAes::encrypt(FreedesktopSecret &secret) const
 {
     auto initVector = QCA::InitializationVector(FDO_SECRETS_CIPHER_KEY_SIZE);
     auto cipher = QCA::Cipher(QStringLiteral("aes128"), QCA::Cipher::CBC, QCA::Cipher::PKCS7, QCA::Encode, m_symmetricKey, initVector);
     QCA::SecureArray result;
     result.append(cipher.update(QCA::MemoryRegion(secret.value)));
     if (cipher.ok()) {
         result.append(cipher.final());
         if (cipher.ok()) {
             secret.value = std::move(result);
             secret.parameters = initVector;
             return true;
         }
     }
     return false;
 }
 
 bool KWalletFreedesktopSessionAlgorithmDhAes::decrypt(FreedesktopSecret &secret) const
 {
     auto cipher =
         QCA::Cipher(QStringLiteral("aes128"), QCA::Cipher::CBC, QCA::Cipher::PKCS7, QCA::Decode, m_symmetricKey, QCA::InitializationVector(secret.parameters));
     QCA::SecureArray result;
     result.append(cipher.update(QCA::MemoryRegion(secret.value)));
     if (cipher.ok()) {
         result.append(cipher.final());
         if (cipher.ok()) {
             secret.value = std::move(result);
             return true;
         }
     }
     return false;
 }
 
 #include "moc_kwalletfreedesktopsession.cpp"