cbc.master.cc

/*
    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 <string.h>
 
CipherBlockChain::CipherBlockChain(BlockCipher *cipher) : _cipher(cipher)
{
    _next = 0L;
    _register = 0L;
    _len = -1;
    _reader = _writer = 0L;
    if (cipher) {
        _blksz = cipher->blockSize();
    }
}
 
CipherBlockChain::~CipherBlockChain()
{
    delete[](char *)_register;
    _register = 0L;
    delete[](char *)_next;
    _next = 0L;
}
 
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;
}
 
int CipherBlockChain::encrypt(void *block, int len)
{
    if (_cipher && !_reader) {
        int rc;
 
        _writer |= 1;
 
        if (!_register) {
            _register = new unsigned char[len];
            _len = len;
            memset(_register, 0, len);
        } else if (len > _len) {
            return -1;
        }
 
        // This might be optimizable
        char *tb = (char *)block;
        for (int i = 0; i < len; i++) {
            tb[i] ^= ((char *)_register)[i];
        }
 
        rc = _cipher->encrypt(block, len);
 
        if (rc != -1) {
            memcpy(_register, block, len);
        }
 
        return rc;
    }
    return -1;
}
 
int CipherBlockChain::decrypt(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;
}