runtime/kwalletd/backend/cbc.cc

   1 /* This file is part of the KDE project
   2    Copyright (C) 2001 George Staikos <staikos@kde.org>
   3
   4    This library is free software; you can redistribute it and/or
   5    modify it under the terms of the GNU Library General Public
   6    License as published by the Free Software Foundation; either
   7    version 2 of the License, or (at your option) any later version.
   8
   9    This library is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12    Library General Public License for more details.
  13
  14    You should have received a copy of the GNU Library General Public License
  15    along with this library; see the file COPYING.LIB.  If not, write to
  16    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  17    Boston, MA 02110-1301, USA.
  18 */
  19
  20
  21 #include "cbc.h"
  22 #include <string.h>
  23
  24
  25
  26 CipherBlockChain::CipherBlockChain(BlockCipher *cipher) : _cipher(cipher) {
  27         _next = 0L;
  28         _register = 0L;
  29         _len = -1;
  30         _reader = _writer = 0L;
  31         if (cipher) {
  32                 _blksz = cipher->blockSize();
  33         }
  34 }
  35
  36
  37 CipherBlockChain::~CipherBlockChain() {
  38         delete[] (char *)_register;
  39         _register = 0L;
  40         delete[] (char *)_next;
  41         _next = 0L;
  42 }
  43
  44
  45 bool CipherBlockChain::setKey(void *key, int bitlength) {
  46         if (_cipher) {
  47                 return _cipher->setKey(key, bitlength);
  48         }
  49         return false;
  50 }
  51
  52
  53 int CipherBlockChain::keyLen() const {
  54         if (_cipher) {
  55                 return _cipher->keyLen();
  56         }
  57         return -1;
  58 }
  59
  60
  61 bool CipherBlockChain::variableKeyLen() const {
  62         if (_cipher) {
  63                 return _cipher->variableKeyLen();
  64         }
  65         return false;
  66 }
  67
  68
  69 bool CipherBlockChain::readyToGo() const {
  70         if (_cipher) {
  71                 return _cipher->readyToGo();
  72         }
  73         return false;
  74 }
  75
  76
  77 int CipherBlockChain::encrypt(void *block, int len) {
  78         if (_cipher && !_reader) {
  79                 int rc;
  80
  81                 _writer |= 1;
  82
  83                 if (!_register) {
  84                         _register = new unsigned char[len];
  85                         _len = len;
  86                         memset(_register, 0, len);
  87                 } else if (len > _len) {
  88                         return -1;
  89                 }
  90
  91                 // This might be optimizable
  92                 char *tb = (char *)block;
  93                 for (int i = 0; i < len; i++) {
  94                         tb[i] ^= ((char *)_register)[i];
  95                 }
  96
  97                 rc = _cipher->encrypt(block, len);
  98
  99                 if (rc != -1) {
 100                         memcpy(_register, block, len);
 101                 }
 102
 103                 return rc;
 104         }
 105         return -1;
 106 }
 107
 108
 109 int CipherBlockChain::decrypt(void *block, int len) {
 110         if (_cipher && !_writer) {
 111                 int rc;
 112
 113                 _reader |= 1;
 114
 115                 if (!_register) {
 116                         _register = new unsigned char[len];
 117                         _len = len;
 118                         memset(_register, 0, len);
 119                 } else if (len > _len) {
 120                         return -1;
 121                 }
 122
 123                 if (!_next)
 124                         _next = new unsigned char[_len];
 125                 memcpy(_next, block, _len);
 126
 127                 rc = _cipher->decrypt(block, len);
 128
 129                 if (rc != -1) {
 130                         // This might be optimizable
 131                         char *tb = (char *)block;
 132                         for (int i = 0; i < len; i++) {
 133                                 tb[i] ^= ((char *)_register)[i];
 134                         }
 135                 }
 136
 137                 void *temp;
 138                 temp = _next;
 139                 _next = _register;
 140                 _register = temp;
 141
 142                 return rc;
 143         }
 144         return -1;
 145 }
 146
 147
 148
 149