libkern/crypto/corecrypto_aes.c

   1 /*
   2  * Copyright (c) 2012 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. The rights granted to you under the License
  10  * may not be used to create, or enable the creation or redistribution of,
  11  * unlawful or unlicensed copies of an Apple operating system, or to
  12  * circumvent, violate, or enable the circumvention or violation of, any
  13  * terms of an Apple operating system software license agreement.
  14  *
  15  * Please obtain a copy of the License at
  16  * http://www.opensource.apple.com/apsl/ and read it before using this file.
  17  *
  18  * The Original Code and all software distributed under the License are
  19  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  20  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  21  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  23  * Please see the License for the specific language governing rights and
  24  * limitations under the License.
  25  *
  26  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  27  */
  28
  29 #include <libkern/crypto/crypto_internal.h>
  30 #include <libkern/crypto/aes.h>
  31 #include <corecrypto/ccmode.h>
  32 #include <corecrypto/ccaes.h>
  33 #include <kern/debug.h>
  34
  35 aes_rval
  36 aes_encrypt_key(const unsigned char *key, int key_len, aes_encrypt_ctx cx[1])
  37 {
  38         const struct ccmode_cbc *cbc = g_crypto_funcs->ccaes_cbc_encrypt;
  39
  40         /* Make sure the context size for the mode fits in the one we have */
  41         if (cbc->size > sizeof(aes_encrypt_ctx)) {
  42                 panic("%s: inconsistent size for AES encrypt context", __FUNCTION__);
  43         }
  44
  45         cccbc_init(cbc, cx[0].ctx, key_len, key);
  46
  47         return aes_good;
  48 }
  49
  50 aes_rval
  51 aes_encrypt_cbc(const unsigned char *in_blk, const unsigned char *in_iv, unsigned int num_blk,
  52     unsigned char *out_blk, aes_encrypt_ctx cx[1])
  53 {
  54         const struct ccmode_cbc *cbc = g_crypto_funcs->ccaes_cbc_encrypt;
  55         cccbc_iv_decl(cbc->block_size, ctx_iv);
  56
  57         cccbc_set_iv(cbc, ctx_iv, in_iv);
  58         cccbc_update(cbc, cx[0].ctx, ctx_iv, num_blk, in_blk, out_blk); //Actually cbc encrypt.
  59
  60         return aes_good;
  61 }
  62
  63 #if defined (__i386__) || defined (__x86_64__) || defined (__arm64__)
  64 /* This does one block of ECB, using the CBC implementation - this allow to use the same context for both CBC and ECB */
  65 aes_rval
  66 aes_encrypt(const unsigned char *in_blk, unsigned char *out_blk, aes_encrypt_ctx cx[1])
  67 {
  68         return aes_encrypt_cbc(in_blk, NULL, 1, out_blk, cx);
  69 }
  70 #endif
  71
  72 aes_rval
  73 aes_decrypt_key(const unsigned char *key, int key_len, aes_decrypt_ctx cx[1])
  74 {
  75         const struct ccmode_cbc *cbc = g_crypto_funcs->ccaes_cbc_decrypt;
  76
  77         /* Make sure the context size for the mode fits in the one we have */
  78         if (cbc->size > sizeof(aes_decrypt_ctx)) {
  79                 panic("%s: inconsistent size for AES decrypt context", __FUNCTION__);
  80         }
  81
  82         cccbc_init(cbc, cx[0].ctx, key_len, key);
  83
  84         return aes_good;
  85 }
  86
  87 aes_rval
  88 aes_decrypt_cbc(const unsigned char *in_blk, const unsigned char *in_iv, unsigned int num_blk,
  89     unsigned char *out_blk, aes_decrypt_ctx cx[1])
  90 {
  91         const struct ccmode_cbc *cbc = g_crypto_funcs->ccaes_cbc_decrypt;
  92         cccbc_iv_decl(cbc->block_size, ctx_iv);
  93
  94         cccbc_set_iv(cbc, ctx_iv, in_iv);
  95         cccbc_update(cbc, cx[0].ctx, ctx_iv, num_blk, in_blk, out_blk); //Actually cbc decrypt.
  96
  97         return aes_good;
  98 }
  99
 100 #if defined (__i386__) || defined (__x86_64__) || defined (__arm64__)
 101 /* This does one block of ECB, using the CBC implementation - this allow to use the same context for both CBC and ECB */
 102 aes_rval
 103 aes_decrypt(const unsigned char *in_blk, unsigned char *out_blk, aes_decrypt_ctx cx[1])
 104 {
 105         return aes_decrypt_cbc(in_blk, NULL, 1, out_blk, cx);
 106 }
 107 #endif
 108
 109 aes_rval
 110 aes_encrypt_key128(const unsigned char *key, aes_encrypt_ctx cx[1])
 111 {
 112         return aes_encrypt_key(key, 16, cx);
 113 }
 114
 115 aes_rval
 116 aes_decrypt_key128(const unsigned char *key, aes_decrypt_ctx cx[1])
 117 {
 118         return aes_decrypt_key(key, 16, cx);
 119 }
 120
 121
 122 aes_rval
 123 aes_encrypt_key256(const unsigned char *key, aes_encrypt_ctx cx[1])
 124 {
 125         return aes_encrypt_key(key, 32, cx);
 126 }
 127
 128 aes_rval
 129 aes_decrypt_key256(const unsigned char *key, aes_decrypt_ctx cx[1])
 130 {
 131         return aes_decrypt_key(key, 32, cx);
 132 }
 133
 134 aes_rval
 135 aes_encrypt_key_gcm(const unsigned char *key, int key_len, ccgcm_ctx *ctx)
 136 {
 137         const struct ccmode_gcm *gcm = g_crypto_funcs->ccaes_gcm_encrypt;
 138         if (!gcm) {
 139                 return aes_error;
 140         }
 141
 142         return ccgcm_init(gcm, ctx, key_len, key);
 143 }
 144
 145 aes_rval
 146 aes_encrypt_key_with_iv_gcm(const unsigned char *key, int key_len, const unsigned char *in_iv, ccgcm_ctx *ctx)
 147 {
 148         const struct ccmode_gcm *gcm = g_crypto_funcs->ccaes_gcm_encrypt;
 149         if (!gcm) {
 150                 return aes_error;
 151         }
 152
 153         return g_crypto_funcs->ccgcm_init_with_iv_fn(gcm, ctx, key_len, key, in_iv);
 154 }
 155
 156 aes_rval
 157 aes_encrypt_set_iv_gcm(const unsigned char *in_iv, unsigned int len, ccgcm_ctx *ctx)
 158 {
 159         const struct ccmode_gcm *gcm = g_crypto_funcs->ccaes_gcm_encrypt;
 160         if (!gcm) {
 161                 return aes_error;
 162         }
 163
 164         return ccgcm_set_iv(gcm, ctx, len, in_iv);
 165 }
 166
 167 aes_rval
 168 aes_encrypt_reset_gcm(ccgcm_ctx *ctx)
 169 {
 170         const struct ccmode_gcm *gcm = g_crypto_funcs->ccaes_gcm_encrypt;
 171         if (!gcm) {
 172                 return aes_error;
 173         }
 174
 175         return ccgcm_reset(gcm, ctx);
 176 }
 177
 178 aes_rval
 179 aes_encrypt_inc_iv_gcm(unsigned char *out_iv, ccgcm_ctx *ctx)
 180 {
 181         const struct ccmode_gcm *gcm = g_crypto_funcs->ccaes_gcm_encrypt;
 182         if (!gcm) {
 183                 return aes_error;
 184         }
 185
 186         return g_crypto_funcs->ccgcm_inc_iv_fn(gcm, ctx, out_iv);
 187 }
 188
 189 aes_rval
 190 aes_encrypt_aad_gcm(const unsigned char *aad, unsigned int aad_bytes, ccgcm_ctx *ctx)
 191 {
 192         const struct ccmode_gcm *gcm = g_crypto_funcs->ccaes_gcm_encrypt;
 193         if (!gcm) {
 194                 return aes_error;
 195         }
 196
 197         return ccgcm_gmac(gcm, ctx, aad_bytes, aad);
 198 }
 199
 200 aes_rval
 201 aes_encrypt_gcm(const unsigned char *in_blk, unsigned int num_bytes,
 202     unsigned char *out_blk, ccgcm_ctx *ctx)
 203 {
 204         const struct ccmode_gcm *gcm = g_crypto_funcs->ccaes_gcm_encrypt;
 205         if (!gcm) {
 206                 return aes_error;
 207         }
 208
 209         return ccgcm_update(gcm, ctx, num_bytes, in_blk, out_blk);      //Actually gcm encrypt.
 210 }
 211
 212 aes_rval
 213 aes_encrypt_finalize_gcm(unsigned char *tag, unsigned int tag_bytes, ccgcm_ctx *ctx)
 214 {
 215         int rc;
 216         const struct ccmode_gcm *gcm = g_crypto_funcs->ccaes_gcm_encrypt;
 217         if (!gcm) {
 218                 return aes_error;
 219         }
 220
 221         rc = ccgcm_finalize(gcm, ctx, tag_bytes, tag);
 222         rc |= ccgcm_reset(gcm, ctx);
 223         return rc;
 224 }
 225
 226 aes_rval
 227 aes_decrypt_key_gcm(const unsigned char *key, int key_len, ccgcm_ctx *ctx)
 228 {
 229         const struct ccmode_gcm *gcm = g_crypto_funcs->ccaes_gcm_decrypt;
 230         if (!gcm) {
 231                 return aes_error;
 232         }
 233
 234         return ccgcm_init(gcm, ctx, key_len, key);
 235 }
 236
 237 aes_rval
 238 aes_decrypt_key_with_iv_gcm(const unsigned char *key, int key_len, const unsigned char *in_iv, ccgcm_ctx *ctx)
 239 {
 240         const struct ccmode_gcm *gcm = g_crypto_funcs->ccaes_gcm_decrypt;
 241         if (!gcm) {
 242                 return aes_error;
 243         }
 244
 245         return g_crypto_funcs->ccgcm_init_with_iv_fn(gcm, ctx, key_len, key, in_iv);
 246 }
 247
 248 aes_rval
 249 aes_decrypt_set_iv_gcm(const unsigned char *in_iv, unsigned int len, ccgcm_ctx *ctx)
 250 {
 251         int rc;
 252
 253         const struct ccmode_gcm *gcm = g_crypto_funcs->ccaes_gcm_decrypt;
 254         if (!gcm) {
 255                 return aes_error;
 256         }
 257
 258         rc = ccgcm_reset(gcm, ctx);
 259         rc |= ccgcm_set_iv(gcm, ctx, len, in_iv);
 260         return rc;
 261 }
 262
 263 aes_rval
 264 aes_decrypt_reset_gcm(ccgcm_ctx *ctx)
 265 {
 266         const struct ccmode_gcm *gcm = g_crypto_funcs->ccaes_gcm_decrypt;
 267         if (!gcm) {
 268                 return aes_error;
 269         }
 270
 271         return ccgcm_reset(gcm, ctx);
 272 }
 273
 274 aes_rval
 275 aes_decrypt_inc_iv_gcm(unsigned char *out_iv, ccgcm_ctx *ctx)
 276 {
 277         const struct ccmode_gcm *gcm = g_crypto_funcs->ccaes_gcm_decrypt;
 278         if (!gcm) {
 279                 return aes_error;
 280         }
 281
 282         return g_crypto_funcs->ccgcm_inc_iv_fn(gcm, ctx, out_iv);
 283 }
 284
 285 aes_rval
 286 aes_decrypt_aad_gcm(const unsigned char *aad, unsigned int aad_bytes, ccgcm_ctx *ctx)
 287 {
 288         const struct ccmode_gcm *gcm = g_crypto_funcs->ccaes_gcm_decrypt;
 289         if (!gcm) {
 290                 return aes_error;
 291         }
 292
 293         return ccgcm_gmac(gcm, ctx, aad_bytes, aad);
 294 }
 295
 296 aes_rval
 297 aes_decrypt_gcm(const unsigned char *in_blk, unsigned int num_bytes,
 298     unsigned char *out_blk, ccgcm_ctx *ctx)
 299 {
 300         const struct ccmode_gcm *gcm = g_crypto_funcs->ccaes_gcm_decrypt;
 301         if (!gcm) {
 302                 return aes_error;
 303         }
 304
 305         return ccgcm_update(gcm, ctx, num_bytes, in_blk, out_blk);      //Actually gcm decrypt.
 306 }
 307
 308 aes_rval
 309 aes_decrypt_finalize_gcm(unsigned char *tag, unsigned int tag_bytes, ccgcm_ctx *ctx)
 310 {
 311         int rc;
 312         const struct ccmode_gcm *gcm = g_crypto_funcs->ccaes_gcm_decrypt;
 313         if (!gcm) {
 314                 return aes_error;
 315         }
 316
 317         rc = ccgcm_finalize(gcm, ctx, tag_bytes, tag);
 318         rc |= ccgcm_reset(gcm, ctx);
 319         return rc;
 320 }
 321
 322 unsigned
 323 aes_encrypt_get_ctx_size_gcm(void)
 324 {
 325         const struct ccmode_gcm *gcm = g_crypto_funcs->ccaes_gcm_encrypt;
 326         if (!gcm) {
 327                 return 0;
 328         }
 329         return cc_ctx_sizeof(ccgcm_ctx, gcm->size);
 330 }
 331
 332 unsigned
 333 aes_decrypt_get_ctx_size_gcm(void)
 334 {
 335         const struct ccmode_gcm *gcm = g_crypto_funcs->ccaes_gcm_decrypt;
 336         if (!gcm) {
 337                 return 0;
 338         }
 339         return cc_ctx_sizeof(ccgcm_ctx, gcm->size);
 340 }