providers/implementations/ciphers/cipher_aes_hw_s390x.inc

   1 /*
   2  * Copyright 2001-2019 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 /*
  11  * IBM S390X support for AES modes ecb, cbc, ofb, cfb, ctr.
  12  * This file is included by cipher_aes_hw.c
  13  */
  14
  15 #include "s390x_arch.h"
  16
  17 #define s390x_aes_cbc_initkey    cipher_hw_aes_initkey
  18 #define s390x_aes_cfb1_initkey   cipher_hw_aes_initkey
  19 #define s390x_aes_ctr_initkey    cipher_hw_aes_initkey
  20 #define s390x_aes_cbc_cipher_hw  cipher_hw_generic_cbc
  21 #define s390x_aes_cfb1_cipher_hw cipher_hw_generic_cfb1
  22 #define s390x_aes_ctr_cipher_hw  cipher_hw_generic_ctr
  23
  24 #define S390X_aes_128_ofb128_CAPABLE S390X_aes_128_ofb_CAPABLE
  25 #define S390X_aes_192_ofb128_CAPABLE S390X_aes_192_ofb_CAPABLE
  26 #define S390X_aes_256_ofb128_CAPABLE S390X_aes_256_ofb_CAPABLE
  27 #define S390X_aes_128_cfb128_CAPABLE S390X_aes_128_cfb_CAPABLE
  28 #define S390X_aes_192_cfb128_CAPABLE S390X_aes_192_cfb_CAPABLE
  29 #define S390X_aes_256_cfb128_CAPABLE S390X_aes_256_cfb_CAPABLE
  30
  31 static int s390x_aes_ecb_initkey(PROV_CIPHER_CTX *dat,
  32                                  const unsigned char *key, size_t keylen)
  33 {
  34     PROV_AES_CTX *adat = (PROV_AES_CTX *)dat;
  35
  36     adat->plat.s390x.fc = S390X_AES_FC(keylen);
  37     if (!dat->enc)
  38         adat->plat.s390x.fc |= S390X_DECRYPT;
  39
  40     memcpy(adat->plat.s390x.param.km.k, key, keylen);
  41     return 1;
  42 }
  43
  44 static int s390x_aes_ecb_cipher_hw(PROV_CIPHER_CTX *dat, unsigned char *out,
  45                                    const unsigned char *in, size_t len)
  46 {
  47     PROV_AES_CTX *adat = (PROV_AES_CTX *)dat;
  48
  49     s390x_km(in, len, out, adat->plat.s390x.fc, &adat->plat.s390x.param.km);
  50     return 1;
  51 }
  52
  53 static int s390x_aes_ofb128_initkey(PROV_CIPHER_CTX *dat,
  54                                     const unsigned char *key, size_t keylen)
  55 {
  56     PROV_AES_CTX *adat = (PROV_AES_CTX *)dat;
  57
  58     memcpy(adat->plat.s390x.param.kmo_kmf.cv, dat->iv, dat->ivlen);
  59     memcpy(adat->plat.s390x.param.kmo_kmf.k, key, keylen);
  60     adat->plat.s390x.fc = S390X_AES_FC(keylen);
  61     adat->plat.s390x.res = 0;
  62     return 1;
  63 }
  64
  65 static int s390x_aes_ofb128_cipher_hw(PROV_CIPHER_CTX *dat, unsigned char *out,
  66                                       const unsigned char *in, size_t len)
  67 {
  68     PROV_AES_CTX *adat = (PROV_AES_CTX *)dat;
  69     int n = adat->plat.s390x.res;
  70     int rem;
  71
  72     while (n && len) {
  73         *out = *in ^ adat->plat.s390x.param.kmo_kmf.cv[n];
  74         n = (n + 1) & 0xf;
  75         --len;
  76         ++in;
  77         ++out;
  78     }
  79
  80     rem = len & 0xf;
  81
  82     len &= ~(size_t)0xf;
  83     if (len) {
  84         s390x_kmo(in, len, out, adat->plat.s390x.fc,
  85                   &adat->plat.s390x.param.kmo_kmf);
  86
  87         out += len;
  88         in += len;
  89     }
  90
  91     if (rem) {
  92         s390x_km(adat->plat.s390x.param.kmo_kmf.cv, 16,
  93                  adat->plat.s390x.param.kmo_kmf.cv, adat->plat.s390x.fc,
  94                  adat->plat.s390x.param.kmo_kmf.k);
  95
  96         while (rem--) {
  97             out[n] = in[n] ^ adat->plat.s390x.param.kmo_kmf.cv[n];
  98             ++n;
  99         }
 100     }
 101
 102     adat->plat.s390x.res = n;
 103     return 1;
 104 }
 105
 106 static int s390x_aes_cfb128_initkey(PROV_CIPHER_CTX *dat,
 107                                     const unsigned char *key, size_t keylen)
 108 {
 109     PROV_AES_CTX *adat = (PROV_AES_CTX *)dat;
 110
 111     adat->plat.s390x.fc = S390X_AES_FC(keylen);
 112     adat->plat.s390x.fc |= 16 << 24;   /* 16 bytes cipher feedback */
 113     if (!dat->enc)
 114         adat->plat.s390x.fc |= S390X_DECRYPT;
 115
 116     adat->plat.s390x.res = 0;
 117     memcpy(adat->plat.s390x.param.kmo_kmf.cv, dat->iv, dat->ivlen);
 118     memcpy(adat->plat.s390x.param.kmo_kmf.k, key, keylen);
 119     return 1;
 120 }
 121
 122 static int s390x_aes_cfb128_cipher_hw(PROV_CIPHER_CTX *dat, unsigned char *out,
 123                                       const unsigned char *in, size_t len)
 124 {
 125     PROV_AES_CTX *adat = (PROV_AES_CTX *)dat;
 126     int n = adat->plat.s390x.res;
 127     int rem;
 128     unsigned char tmp;
 129
 130     while (n && len) {
 131         tmp = *in;
 132         *out = adat->plat.s390x.param.kmo_kmf.cv[n] ^ tmp;
 133         adat->plat.s390x.param.kmo_kmf.cv[n] = dat->enc ? *out : tmp;
 134         n = (n + 1) & 0xf;
 135         --len;
 136         ++in;
 137         ++out;
 138     }
 139
 140     rem = len & 0xf;
 141
 142     len &= ~(size_t)0xf;
 143     if (len) {
 144         s390x_kmf(in, len, out, adat->plat.s390x.fc,
 145                   &adat->plat.s390x.param.kmo_kmf);
 146
 147         out += len;
 148         in += len;
 149     }
 150
 151     if (rem) {
 152         s390x_km(adat->plat.s390x.param.kmo_kmf.cv, 16,
 153                  adat->plat.s390x.param.kmo_kmf.cv,
 154                  S390X_AES_FC(dat->keylen), adat->plat.s390x.param.kmo_kmf.k);
 155
 156         while (rem--) {
 157             tmp = in[n];
 158             out[n] = adat->plat.s390x.param.kmo_kmf.cv[n] ^ tmp;
 159             adat->plat.s390x.param.kmo_kmf.cv[n] = dat->enc ? out[n] : tmp;
 160             ++n;
 161         }
 162     }
 163
 164     adat->plat.s390x.res = n;
 165     return 1;
 166 }
 167
 168 static int s390x_aes_cfb8_initkey(PROV_CIPHER_CTX *dat,
 169                                   const unsigned char *key, size_t keylen)
 170 {
 171     PROV_AES_CTX *adat = (PROV_AES_CTX *)dat;
 172
 173     adat->plat.s390x.fc = S390X_AES_FC(keylen);
 174     adat->plat.s390x.fc |= 1 << 24;   /* 1 byte cipher feedback */
 175     if (!dat->enc)
 176         adat->plat.s390x.fc |= S390X_DECRYPT;
 177
 178     memcpy(adat->plat.s390x.param.kmo_kmf.cv, dat->iv, dat->ivlen);
 179     memcpy(adat->plat.s390x.param.kmo_kmf.k, key, keylen);
 180     return 1;
 181 }
 182
 183 static int s390x_aes_cfb8_cipher_hw(PROV_CIPHER_CTX *dat, unsigned char *out,
 184                                     const unsigned char *in, size_t len)
 185 {
 186     PROV_AES_CTX *adat = (PROV_AES_CTX *)dat;
 187
 188     s390x_kmf(in, len, out, adat->plat.s390x.fc,
 189               &adat->plat.s390x.param.kmo_kmf);
 190     return 1;
 191 }
 192
 193 #define PROV_CIPHER_HW_declare(mode)                                           \
 194 static const PROV_CIPHER_HW s390x_aes_##mode = {                               \
 195     s390x_aes_##mode##_initkey,                                                \
 196     s390x_aes_##mode##_cipher_hw                                               \
 197 };
 198 #define PROV_CIPHER_HW_select(mode)                                            \
 199 if ((keybits == 128 && S390X_aes_128_##mode##_CAPABLE)                         \
 200      || (keybits == 192 && S390X_aes_192_##mode##_CAPABLE)                     \
 201      || (keybits == 256 && S390X_aes_256_##mode##_CAPABLE))                    \
 202     return &s390x_aes_##mode;
 203