usr/src/common/crypto/modes/cbc.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 #ifndef _KERNEL
  27 #include <strings.h>
  28 #include <limits.h>
  29 #include <assert.h>
  30 #include <security/cryptoki.h>
  31 #endif
  32
  33 #include <sys/types.h>
  34 #include <modes/modes.h>
  35 #include <sys/crypto/common.h>
  36 #include <sys/crypto/impl.h>
  37
  38 /*
  39  * Algorithm independent CBC functions.
  40  */
  41 int
  42 cbc_encrypt_contiguous_blocks(cbc_ctx_t *ctx, char *data, size_t length,
  43     crypto_data_t *out, size_t block_size,
  44     int (*encrypt)(const void *, const uint8_t *, uint8_t *),
  45     void (*copy_block)(uint8_t *, uint8_t *),
  46     void (*xor_block)(uint8_t *, uint8_t *))
  47 {
  48         size_t remainder = length;
  49         size_t need;
  50         uint8_t *datap = (uint8_t *)data;
  51         uint8_t *blockp;
  52         uint8_t *lastp;
  53         void *iov_or_mp;
  54         offset_t offset;
  55         uint8_t *out_data_1;
  56         uint8_t *out_data_2;
  57         size_t out_data_1_len;
  58
  59         if (length + ctx->cbc_remainder_len < block_size) {
  60                 /* accumulate bytes here and return */
  61                 bcopy(datap,
  62                     (uint8_t *)ctx->cbc_remainder + ctx->cbc_remainder_len,
  63                     length);
  64                 ctx->cbc_remainder_len += length;
  65                 ctx->cbc_copy_to = datap;
  66                 return (CRYPTO_SUCCESS);
  67         }
  68
  69         lastp = (uint8_t *)ctx->cbc_iv;
  70         if (out != NULL)
  71                 crypto_init_ptrs(out, &iov_or_mp, &offset);
  72
  73         do {
  74                 /* Unprocessed data from last call. */
  75                 if (ctx->cbc_remainder_len > 0) {
  76                         need = block_size - ctx->cbc_remainder_len;
  77
  78                         if (need > remainder)
  79                                 return (CRYPTO_DATA_LEN_RANGE);
  80
  81                         bcopy(datap, &((uint8_t *)ctx->cbc_remainder)
  82                             [ctx->cbc_remainder_len], need);
  83
  84                         blockp = (uint8_t *)ctx->cbc_remainder;
  85                 } else {
  86                         blockp = datap;
  87                 }
  88
  89                 if (out == NULL) {
  90                         /*
  91                          * XOR the previous cipher block or IV with the
  92                          * current clear block.
  93                          */
  94                         xor_block(lastp, blockp);
  95                         encrypt(ctx->cbc_keysched, blockp, blockp);
  96
  97                         ctx->cbc_lastp = blockp;
  98                         lastp = blockp;
  99
 100                         if (ctx->cbc_remainder_len > 0) {
 101                                 bcopy(blockp, ctx->cbc_copy_to,
 102                                     ctx->cbc_remainder_len);
 103                                 bcopy(blockp + ctx->cbc_remainder_len, datap,
 104                                     need);
 105                         }
 106                 } else {
 107                         /*
 108                          * XOR the previous cipher block or IV with the
 109                          * current clear block.
 110                          */
 111                         xor_block(blockp, lastp);
 112                         encrypt(ctx->cbc_keysched, lastp, lastp);
 113                         crypto_get_ptrs(out, &iov_or_mp, &offset, &out_data_1,
 114                             &out_data_1_len, &out_data_2, block_size);
 115
 116                         /* copy block to where it belongs */
 117                         if (out_data_1_len == block_size) {
 118                                 copy_block(lastp, out_data_1);
 119                         } else {
 120                                 bcopy(lastp, out_data_1, out_data_1_len);
 121                                 if (out_data_2 != NULL) {
 122                                         bcopy(lastp + out_data_1_len,
 123                                             out_data_2,
 124                                             block_size - out_data_1_len);
 125                                 }
 126                         }
 127                         /* update offset */
 128                         out->cd_offset += block_size;
 129                 }
 130
 131                 /* Update pointer to next block of data to be processed. */
 132                 if (ctx->cbc_remainder_len != 0) {
 133                         datap += need;
 134                         ctx->cbc_remainder_len = 0;
 135                 } else {
 136                         datap += block_size;
 137                 }
 138
 139                 remainder = (size_t)&data[length] - (size_t)datap;
 140
 141                 /* Incomplete last block. */
 142                 if (remainder > 0 && remainder < block_size) {
 143                         bcopy(datap, ctx->cbc_remainder, remainder);
 144                         ctx->cbc_remainder_len = remainder;
 145                         ctx->cbc_copy_to = datap;
 146                         goto out;
 147                 }
 148                 ctx->cbc_copy_to = NULL;
 149
 150         } while (remainder > 0);
 151
 152 out:
 153         /*
 154          * Save the last encrypted block in the context.
 155          */
 156         if (ctx->cbc_lastp != NULL) {
 157                 copy_block((uint8_t *)ctx->cbc_lastp, (uint8_t *)ctx->cbc_iv);
 158                 ctx->cbc_lastp = (uint8_t *)ctx->cbc_iv;
 159         }
 160
 161         return (CRYPTO_SUCCESS);
 162 }
 163
 164 #define OTHER(a, ctx) \
 165         (((a) == (ctx)->cbc_lastblock) ? (ctx)->cbc_iv : (ctx)->cbc_lastblock)
 166
 167 /* ARGSUSED */
 168 int
 169 cbc_decrypt_contiguous_blocks(cbc_ctx_t *ctx, char *data, size_t length,
 170     crypto_data_t *out, size_t block_size,
 171     int (*decrypt)(const void *, const uint8_t *, uint8_t *),
 172     void (*copy_block)(uint8_t *, uint8_t *),
 173     void (*xor_block)(uint8_t *, uint8_t *))
 174 {
 175         size_t remainder = length;
 176         size_t need;
 177         uint8_t *datap = (uint8_t *)data;
 178         uint8_t *blockp;
 179         uint8_t *lastp;
 180         void *iov_or_mp;
 181         offset_t offset;
 182         uint8_t *out_data_1;
 183         uint8_t *out_data_2;
 184         size_t out_data_1_len;
 185
 186         if (length + ctx->cbc_remainder_len < block_size) {
 187                 /* accumulate bytes here and return */
 188                 bcopy(datap,
 189                     (uint8_t *)ctx->cbc_remainder + ctx->cbc_remainder_len,
 190                     length);
 191                 ctx->cbc_remainder_len += length;
 192                 ctx->cbc_copy_to = datap;
 193                 return (CRYPTO_SUCCESS);
 194         }
 195
 196         lastp = ctx->cbc_lastp;
 197         if (out != NULL)
 198                 crypto_init_ptrs(out, &iov_or_mp, &offset);
 199
 200         do {
 201                 /* Unprocessed data from last call. */
 202                 if (ctx->cbc_remainder_len > 0) {
 203                         need = block_size - ctx->cbc_remainder_len;
 204
 205                         if (need > remainder)
 206                                 return (CRYPTO_ENCRYPTED_DATA_LEN_RANGE);
 207
 208                         bcopy(datap, &((uint8_t *)ctx->cbc_remainder)
 209                             [ctx->cbc_remainder_len], need);
 210
 211                         blockp = (uint8_t *)ctx->cbc_remainder;
 212                 } else {
 213                         blockp = datap;
 214                 }
 215
 216                 /* LINTED: pointer alignment */
 217                 copy_block(blockp, (uint8_t *)OTHER((uint64_t *)lastp, ctx));
 218
 219                 if (out != NULL) {
 220                         decrypt(ctx->cbc_keysched, blockp,
 221                             (uint8_t *)ctx->cbc_remainder);
 222                         blockp = (uint8_t *)ctx->cbc_remainder;
 223                 } else {
 224                         decrypt(ctx->cbc_keysched, blockp, blockp);
 225                 }
 226
 227                 /*
 228                  * XOR the previous cipher block or IV with the
 229                  * currently decrypted block.
 230                  */
 231                 xor_block(lastp, blockp);
 232
 233                 /* LINTED: pointer alignment */
 234                 lastp = (uint8_t *)OTHER((uint64_t *)lastp, ctx);
 235
 236                 if (out != NULL) {
 237                         crypto_get_ptrs(out, &iov_or_mp, &offset, &out_data_1,
 238                             &out_data_1_len, &out_data_2, block_size);
 239
 240                         bcopy(blockp, out_data_1, out_data_1_len);
 241                         if (out_data_2 != NULL) {
 242                                 bcopy(blockp + out_data_1_len, out_data_2,
 243                                     block_size - out_data_1_len);
 244                         }
 245
 246                         /* update offset */
 247                         out->cd_offset += block_size;
 248
 249                 } else if (ctx->cbc_remainder_len > 0) {
 250                         /* copy temporary block to where it belongs */
 251                         bcopy(blockp, ctx->cbc_copy_to, ctx->cbc_remainder_len);
 252                         bcopy(blockp + ctx->cbc_remainder_len, datap, need);
 253                 }
 254
 255                 /* Update pointer to next block of data to be processed. */
 256                 if (ctx->cbc_remainder_len != 0) {
 257                         datap += need;
 258                         ctx->cbc_remainder_len = 0;
 259                 } else {
 260                         datap += block_size;
 261                 }
 262
 263                 remainder = (size_t)&data[length] - (size_t)datap;
 264
 265                 /* Incomplete last block. */
 266                 if (remainder > 0 && remainder < block_size) {
 267                         bcopy(datap, ctx->cbc_remainder, remainder);
 268                         ctx->cbc_remainder_len = remainder;
 269                         ctx->cbc_lastp = lastp;
 270                         ctx->cbc_copy_to = datap;
 271                         return (CRYPTO_SUCCESS);
 272                 }
 273                 ctx->cbc_copy_to = NULL;
 274
 275         } while (remainder > 0);
 276
 277         ctx->cbc_lastp = lastp;
 278         return (CRYPTO_SUCCESS);
 279 }
 280
 281 int
 282 cbc_init_ctx(cbc_ctx_t *cbc_ctx, char *param, size_t param_len,
 283     size_t block_size, void (*copy_block)(uint8_t *, uint64_t *))
 284 {
 285         /*
 286          * Copy IV into context.
 287          *
 288          * If cm_param == NULL then the IV comes from the
 289          * cd_miscdata field in the crypto_data structure.
 290          */
 291         if (param != NULL) {
 292 #ifdef _KERNEL
 293                 ASSERT(param_len == block_size);
 294 #else
 295                 assert(param_len == block_size);
 296 #endif
 297                 copy_block((uchar_t *)param, cbc_ctx->cbc_iv);
 298         }
 299
 300         cbc_ctx->cbc_lastp = (uint8_t *)&cbc_ctx->cbc_iv[0];
 301         cbc_ctx->cbc_flags |= CBC_MODE;
 302         return (CRYPTO_SUCCESS);
 303 }
 304
 305 /* ARGSUSED */
 306 void *
 307 cbc_alloc_ctx(int kmflag)
 308 {
 309         cbc_ctx_t *cbc_ctx;
 310
 311 #ifdef _KERNEL
 312         if ((cbc_ctx = kmem_zalloc(sizeof (cbc_ctx_t), kmflag)) == NULL)
 313 #else
 314         if ((cbc_ctx = calloc(1, sizeof (cbc_ctx_t))) == NULL)
 315 #endif
 316                 return (NULL);
 317
 318         cbc_ctx->cbc_flags = CBC_MODE;
 319         return (cbc_ctx);
 320 }