File indexing completed on 2024-06-16 03:53:03

 /*
     This file is part of the KDE project
     SPDX-FileCopyrightText: 2001 George Staikos <staikos@kde.org>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "cbc.h"
 #include "kwalletbackend_debug.h"
 #include <string.h>
 
 CipherBlockChain::CipherBlockChain(BlockCipher *cipher, bool useECBforReading) :
     _cipher(cipher)
     , _useECBforReading(useECBforReading)
 {
     _next = nullptr;
     _register = nullptr;
     _len = -1;
     _reader = _writer = 0L;
     if (cipher) {
         _blksz = cipher->blockSize();
     }
 }
 
 CipherBlockChain::~CipherBlockChain()
 {
     delete[](char *)_register;
     _register = nullptr;
     delete[](char *)_next;
     _next = nullptr;
 }
 
 bool CipherBlockChain::setKey(void *key, int bitlength)
 {
     if (_cipher) {
         return _cipher->setKey(key, bitlength);
     }
     return false;
 }
 
 int CipherBlockChain::keyLen() const
 {
     if (_cipher) {
         return _cipher->keyLen();
     }
     return -1;
 }
 
 bool CipherBlockChain::variableKeyLen() const
 {
     if (_cipher) {
         return _cipher->variableKeyLen();
     }
     return false;
 }
 
 bool CipherBlockChain::readyToGo() const
 {
     if (_cipher) {
         return _cipher->readyToGo();
     }
     return false;
 }
 
 void CipherBlockChain::initRegister() {
     if (_register == nullptr) {
         size_t registerLen = _cipher->blockSize();
         _register = new unsigned char[registerLen];
         _len = registerLen;
     }
     memset(_register, 0, _len);
 }
 
 int CipherBlockChain::encrypt(void *block, int len)
 {
     if (_cipher && !_reader) {
         int rc;
 
         _writer |= 1;
 
         initRegister();
 
         if ((len % _len) >0) {
             qCDebug(KWALLETBACKEND_LOG) << "Block length given encrypt (" << len << ") is not a multiple of " << _len;
             return -1;
         }
 
         char *elemBlock = static_cast<char*>(block);
         for (int b = 0; b < len/_len; b++) {
 
             // This might be optimizable
             char *tb = static_cast<char*>(elemBlock);
             for (int i = 0; i < _len; i++) {
                 *tb++ ^= ((char *)_register)[i];
             }
 
             rc = _cipher->encrypt(elemBlock, _len);
 
             if (rc != -1) {
                 memcpy(_register, elemBlock, _len);
             }
             elemBlock += _len;
         }
 
         return rc;
     }
     return -1;
 }
 
 // This is the old decrypt method, that was decrypting using ECB
 // instead of CBC
 int CipherBlockChain::decryptECB(void *block, int len) {
     if (_cipher && !_writer) {
         int rc;
 
         _reader |= 1;
 
         if (!_register) {
             _register = new unsigned char[len];
             _len = len;
             memset(_register, 0, len);
         } else if (len > _len) {
             return -1;
         }
 
         if (!_next) {
             _next = new unsigned char[_len];
         }
         memcpy(_next, block, _len);
 
         rc = _cipher->decrypt(block, len);
 
         if (rc != -1) {
             // This might be optimizable
             char *tb = (char *)block;
             for (int i = 0; i < len; i++) {
                 tb[i] ^= ((char *)_register)[i];
             }
         }
 
         void *temp;
         temp = _next;
         _next = _register;
         _register = temp;
 
         return rc;
     }
     return -1;
 }
 
 int CipherBlockChain::decrypt(void *block, int len)
 {
     if (_useECBforReading) {
         qCDebug(KWALLETBACKEND_LOG) << "decrypting using ECB!";
         return decryptECB(block, len);
     }
 
     if (_cipher && !_writer) {
         int rc = 0;
 
         _reader |= 1;
 
         initRegister();
 
         if ((len % _len) >0) {
             qCDebug(KWALLETBACKEND_LOG) << "Block length given for decrypt (" << len << ") is not a multiple of " << _len;
             return -1;
         }
 
         char *elemBlock = static_cast<char*>(block);
         for (int b = 0; b < len/_len; b++) {
             if (_next == nullptr) {
                 _next = new unsigned char[_len];
             }
             memcpy(_next, elemBlock, _len);
 
             int bytesDecrypted = _cipher->decrypt(elemBlock, _len);
 
             if (bytesDecrypted != -1) {
                 rc += bytesDecrypted;
                 // This might be optimizable
                 char *tb = (char *)elemBlock;
                 for (int i = 0; i < _len; i++) {
                     *tb++ ^= ((char *)_register)[i];
                 }
             }
 
             void *temp;
             temp = _next;
             _next = _register;
             _register = temp;
 
             elemBlock += _len;
         }
 
         return rc;
     }
     return -1;
 }