Cleanup repo with some directories

1 files changed, 0 insertions, 277 deletions

diff --git a/libcommuni/src/3rdparty/qblowfish/qblowfish.cpp b/libcommuni/src/3rdparty/qblowfish/qblowfish.cpp
deleted file mode 100644
index 605ff24..0000000
--- a/libcommuni/src/3rdparty/qblowfish/qblowfish.cpp
+++ /dev/null
@@ -1,277 +0,0 @@
-/*
-  This file is part of QBlowfish and is licensed under the MIT License
-
-  Copyright (C) 2012 Roopesh Chander <roop@forwardbias.in>
-
-  Permission is hereby granted, free of charge, to any person obtaining
-  a copy of this software and associated documentation files (the
-  "Software"), to deal in the Software without restriction, including
-  without limitation the rights to use, copy, modify, merge, publish,
-  distribute, sublicense, and/or sell copies of the Software, and to
-  permit persons to whom the Software is furnished to do so, subject
-  to the following conditions:
-
-  The above copyright notice and this permission notice shall be
-  included in all copies or substantial portions of the Software.
-
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
-  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-  ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-  SOFTWARE.
-*/
-
-#include "qblowfish.h"
-#include "qblowfish_p.h"
-#include <QtEndian>
-#include <QDebug>
-
-QBlowfish::QBlowfish(const QByteArray &key)
-    : m_key(key)
-    , m_initialized(false)
-    , m_paddingEnabled(false)
-{
-}
-
-void QBlowfish::setPaddingEnabled(bool enabled)
-{
-    m_paddingEnabled = enabled;
-}
-
-bool QBlowfish::isPaddingEnabled() const
-{
-    return m_paddingEnabled;
-}
-
-QByteArray QBlowfish::encrypted(const QByteArray &_clearText)
-{
-    QByteArray clearText(_clearText);
-    if (clearText.isEmpty()) {
-        return QByteArray();
-    }
-
-    if (isPaddingEnabled()) {
-        // Add padding as per PKCS5
-        // Ref: RFC 5652 http://tools.ietf.org/html/rfc5652#section-6.3
-        quint8 paddingLength = 8 - (clearText.size() % 8);
-        QByteArray paddingBa(paddingLength, static_cast<char>(paddingLength));
-        clearText.append(paddingBa);
-    } else {
-        if (clearText.size() % 8 != 0) {
-            qWarning("Cannot encrypt. Clear-text length is not a multiple of 8 and padding is not enabled.");
-            return QByteArray();
-        }
-    }
-
-    Q_ASSERT(clearText.size() % 8 == 0);
-    if ((clearText.size() % 8 == 0) && init()) {
-
-        QByteArray copyBa(clearText.constData(), clearText.size());
-        for (int i = 0; i < clearText.size(); i += 8) {
-            coreEncrypt(copyBa.data() + i);
-        }
-        return copyBa;
-
-    }
-    return QByteArray();
-}
-
-QByteArray QBlowfish::decrypted(const QByteArray &cipherText)
-{
-    if (cipherText.isEmpty()) {
-        return QByteArray();
-    }
-
-    Q_ASSERT(cipherText.size() % 8 == 0);
-    if ((cipherText.size() % 8 == 0) && init()) {
-
-        QByteArray copyBa(cipherText.constData(), cipherText.size());
-        for (int i = 0; i < cipherText.size(); i += 8) {
-            coreDecrypt(copyBa.data() + i);
-        }
-
-        if (isPaddingEnabled()) {
-            // Remove padding as per PKCS5
-            quint8 paddingLength = static_cast<quint8>(copyBa.right(1).at(0));
-            QByteArray paddingBa(paddingLength, static_cast<char>(paddingLength));
-            if (copyBa.right(paddingLength) == paddingBa) {
-                return copyBa.left(copyBa.length() - paddingLength);
-            }
-            return QByteArray();
-        }
-        return copyBa;
-    }
-    return QByteArray();
-}
-
-/*
-  Core encryption code follows. This is an implementation of the Blowfish algorithm as described at:
-  http://www.schneier.com/paper-blowfish-fse.html
-*/
-
-bool QBlowfish::init()
-{
-    if (m_initialized) {
-        return true;
-    }
-
-    if (m_key.isEmpty()) {
-        qWarning("Cannot init. Key is empty.");
-        return false;
-    }
-
-    m_sbox1 = QByteArray::fromHex(QByteArray::fromRawData(sbox0, SBOX_SIZE_BYTES * 2));
-    m_sbox2 = QByteArray::fromHex(QByteArray::fromRawData(sbox1, SBOX_SIZE_BYTES * 2));
-    m_sbox3 = QByteArray::fromHex(QByteArray::fromRawData(sbox2, SBOX_SIZE_BYTES * 2));
-    m_sbox4 = QByteArray::fromHex(QByteArray::fromRawData(sbox3, SBOX_SIZE_BYTES * 2));
-    m_parray = QByteArray::fromHex(QByteArray::fromRawData(parray, PARRAY_SIZE_BYTES * 2));
-
-    const QByteArray &key = m_key;
-    int keyLength = key.length();
-    for (int i = 0; i < PARRAY_SIZE_BYTES; i++) {
-        m_parray[i] = static_cast<char>(static_cast<quint8>(m_parray[i]) ^ static_cast<quint8>(key[i % keyLength]));
-    }
-
-    char seed[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
-
-    // Update p-array
-    for (int i = 0; i < (PARRAY_SIZE_BYTES / 4); i += 2) {
-        coreEncrypt(seed);
-        for (int j = 0; j < 8; j++) {
-            // P1 = xL; P2 = xR
-            m_parray[i * 4 + j] = seed[j];
-        }
-    }
-
-    // Update s-boxes
-    for (int sboxIndex = 1; sboxIndex <= 4; sboxIndex++) {
-        QByteArray *sbox = 0;
-        switch (sboxIndex) {
-        case 1: sbox = &m_sbox1; break;
-        case 2: sbox = &m_sbox2; break;
-        case 3: sbox = &m_sbox3; break;
-        case 4: sbox = &m_sbox4; break;
-        default: Q_ASSERT(false);
-        }
-        Q_ASSERT(sbox != 0);
-
-        for (int i = 0; i < (SBOX_SIZE_BYTES / 4); i += 2) {
-            coreEncrypt(seed);
-            for (int j = 0; j < 8; j++) {
-                // S1,1 = xL; S1,2 = xR
-                sbox->operator[](i * 4 + j) = seed[j];
-            }
-        }
-    }
-
-    m_initialized = true;
-    return true;
-}
-
-void QBlowfish::coreEncrypt(char *x) // encrypts 8 bytes pointed to by x, result is written to the same location
-{
-    // Divide x into two 32-bit halves: xL, xR
-    char *xL = x;
-    char *xR = x + 4;
-    uchar f_xL_bytes[4] = { 0, 0, 0, 0 };
-
-    for (int i = 0; i < 16; i++) {
-
-        // xL = xL XOR Pi
-        for (int j = 0; j < 4; j++) {
-            // quint8 old_xL = xL[j];
-            xL[j] = static_cast<char>(static_cast<quint8>(xL[j]) ^ static_cast<quint8>(m_parray[i * 4 + j]));
-        }
-
-        // Divide xL into four eight-bit quarters: a, b, c, and d
-        quint8 a = static_cast<quint8>(xL[0]);
-        quint8 b = static_cast<quint8>(xL[1]);
-        quint8 c = static_cast<quint8>(xL[2]);
-        quint8 d = static_cast<quint8>(xL[3]);
-
-        // F(xL) = ((S1,a + S2,b mod 2**32) XOR S3,c) + S4,d mod 2**32
-        quint32 s1a = qFromBigEndian<quint32>(reinterpret_cast<const uchar *>(m_sbox1.constData() + a * 4));
-        quint32 s2b = qFromBigEndian<quint32>(reinterpret_cast<const uchar *>(m_sbox2.constData() + b * 4));
-        quint32 s3c = qFromBigEndian<quint32>(reinterpret_cast<const uchar *>(m_sbox3.constData() + c * 4));
-        quint32 s4d = qFromBigEndian<quint32>(reinterpret_cast<const uchar *>(m_sbox4.constData() + d * 4));
-        quint32 f_xL = ((((s1a + s2b) & 0xffffffff) ^ s3c) + s4d) & 0xffffffff;
-        qToBigEndian<quint32>(f_xL, f_xL_bytes);
-
-        // xR = F(xL) XOR xR
-        for (int j = 0; j < 4; j++) {
-            xR[j] = static_cast<char>(static_cast<quint8>(f_xL_bytes[j]) ^ static_cast<quint8>(xR[j]));
-        }
-
-        // Swap xL and xR, but not in the last iteration
-        if (i != 15) {
-            for (int j = 0; j < 4; j++) {
-                char temp = xL[j];
-                xL[j] = xR[j];
-                xR[j] = temp;
-            }
-        }
-
-    }
-
-    // xR = xR XOR P17
-    // xL = xL XOR P18
-    for (int j = 0; j < 4; j++) {
-        xR[j] = static_cast<char>(static_cast<quint8>(xR[j]) ^ static_cast<quint8>(m_parray[16 * 4 + j]));
-        xL[j] = static_cast<char>(static_cast<quint8>(xL[j]) ^ static_cast<quint8>(m_parray[17 * 4 + j]));
-    }
-}
-
-void QBlowfish::coreDecrypt(char *x) // decrypts 8 bytes pointed to by x, result is written to the same location
-{
-    // Divide x into two 32-bit halves: xL, xR
-    char *xL = x;
-    char *xR = x + 4;
-    uchar f_xL_bytes[4] = { 0, 0, 0, 0 };
-
-    // xL = xL XOR P18
-    // xR = xR XOR P17
-    for (int j = 0; j < 4; j++) {
-        xL[j] = static_cast<char>(static_cast<quint8>(xL[j]) ^ static_cast<quint8>(m_parray[17 * 4 + j]));
-        xR[j] = static_cast<char>(static_cast<quint8>(xR[j]) ^ static_cast<quint8>(m_parray[16 * 4 + j]));
-    }
-
-    for (int i = 15; i >= 0; i--) {
-
-        // Swap xL and xR, but not in the first iteration
-        if (i != 15) {
-            for (int j = 0; j < 4; j++) {
-                char temp = xL[j];
-                xL[j] = xR[j];
-                xR[j] = temp;
-            }
-        }
-
-        // Divide xL into four eight-bit quarters: a, b, c, and d
-        quint8 a = static_cast<quint8>(xL[0]);
-        quint8 b = static_cast<quint8>(xL[1]);
-        quint8 c = static_cast<quint8>(xL[2]);
-        quint8 d = static_cast<quint8>(xL[3]);
-
-        // F(xL) = ((S1,a + S2,b mod 2**32) XOR S3,c) + S4,d mod 2**32
-        quint32 s1a = qFromBigEndian<quint32>(reinterpret_cast<const uchar *>(m_sbox1.constData() + a * 4));
-        quint32 s2b = qFromBigEndian<quint32>(reinterpret_cast<const uchar *>(m_sbox2.constData() + b * 4));
-        quint32 s3c = qFromBigEndian<quint32>(reinterpret_cast<const uchar *>(m_sbox3.constData() + c * 4));
-        quint32 s4d = qFromBigEndian<quint32>(reinterpret_cast<const uchar *>(m_sbox4.constData() + d * 4));
-        quint32 f_xL = ((((s1a + s2b) & 0xffffffff) ^ s3c) + s4d) & 0xffffffff;
-        qToBigEndian<quint32>(f_xL, f_xL_bytes);
-
-        // xR = F(xL) XOR xR
-        for (int j = 0; j < 4; j++) {
-            xR[j] = static_cast<char>(static_cast<quint8>(f_xL_bytes[j]) ^ static_cast<quint8>(xR[j]));
-        }
-
-        // xL = xL XOR Pi
-        for (int j = 0; j < 4; j++) {
-            xL[j] = static_cast<char>(static_cast<quint8>(xL[j]) ^ static_cast<quint8>(m_parray[i * 4 + j]));
-        }
-
-    }
-}