bcal/bcal-cbc.c

   1 /* bcal-cbc.c */
   2 /*
   3  This file is part of the AVR-Crypto-Lib.
   4  Copyright (C) 2006-2015 Daniel Otte (bg@nerilex.org)
   5
   6  This program is free software: you can redistribute it and/or modify
   7  it under the terms of the GNU General Public License as published by
   8  the Free Software Foundation, either version 3 of the License, or
   9  (at your option) any later version.
  10
  11  This program is distributed in the hope that it will be useful,
  12  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  GNU General Public License for more details.
  15
  16  You should have received a copy of the GNU General Public License
  17  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <stdint.h>
  21 #include <string.h>
  22 #include "bcal-cbc.h"
  23 #include "bcal-basic.h"
  24 #include "memxor.h"
  25
  26 uint8_t bcal_cbc_init(const bcdesc_t *desc, const void *key, uint16_t keysize_b,
  27         bcal_cbc_ctx_t *ctx)
  28 {
  29     ctx->desc = (bcdesc_t*) desc;
  30     ctx->blocksize_B = (bcal_cipher_getBlocksize_b(desc) + 7) / 8;
  31     ctx->prev_block = malloc(ctx->blocksize_B);
  32
  33     if (ctx->prev_block == NULL) {
  34         return 0x11;
  35     }
  36     return bcal_cipher_init(desc, key, keysize_b, &(ctx->cctx));
  37 }
  38
  39 void bcal_cbc_free(bcal_cbc_ctx_t *ctx)
  40 {
  41     bcal_cipher_free(&(ctx->cctx));
  42     free(ctx->prev_block);
  43 }
  44
  45 void bcal_cbc_loadIV(const void *iv, bcal_cbc_ctx_t *ctx)
  46 {
  47     if (iv) {
  48         memcpy(ctx->prev_block, iv, ctx->blocksize_B);
  49     }
  50 }
  51
  52 void bcal_cbc_encNext(void *block, bcal_cbc_ctx_t *ctx)
  53 {
  54     memxor(block, ctx->prev_block, ctx->blocksize_B);
  55     bcal_cipher_enc(block, &(ctx->cctx));
  56     memcpy(ctx->prev_block, block, ctx->blocksize_B);
  57 }
  58
  59 void bcal_cbc_decNext(void *block, bcal_cbc_ctx_t *ctx)
  60 {
  61     uint8_t tmp[ctx->blocksize_B];
  62     memcpy(tmp, block, ctx->blocksize_B);
  63     bcal_cipher_dec(block, &(ctx->cctx));
  64     memxor(block, ctx->prev_block, ctx->blocksize_B);
  65     memcpy(ctx->prev_block, tmp, ctx->blocksize_B);
  66 }
  67 void bcal_cbc_decRand(void *block, const void *prev_block, bcal_cbc_ctx_t *ctx)
  68 {
  69     bcal_cipher_dec(block, &(ctx->cctx));
  70     memxor(block, prev_block, ctx->blocksize_B);
  71 }
  72
  73 void bcal_cbc_encMsg(const void *iv, void *msg, uint16_t msg_blocks,
  74         bcal_cbc_ctx_t *ctx)
  75 {
  76     bcal_cbc_loadIV(iv, ctx);
  77     while (msg_blocks--) {
  78         bcal_cbc_encNext(msg, ctx);
  79         msg = (uint8_t*) msg + ctx->blocksize_B;
  80     }
  81 }
  82
  83 void bcal_cbc_decMsg(const void *iv, void *msg, uint16_t msg_blocks,
  84         bcal_cbc_ctx_t *ctx)
  85 {
  86     msg = (uint8_t*) msg + (msg_blocks - 1) * ctx->blocksize_B;
  87     while (msg_blocks > 1) {
  88         bcal_cbc_decRand(msg, (uint8_t*) msg - ctx->blocksize_B, ctx);
  89         msg_blocks -= 1;
  90         msg = (uint8_t*) msg - ctx->blocksize_B;
  91     }
  92     bcal_cbc_decRand(msg, iv, ctx);
  93 }
  94