lib/libcrypto/evp/evp_lib.c

   1 /* $OpenBSD: evp_lib.c,v 1.15 2017/01/29 17:49:23 beck Exp $ */
   2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
   3  * All rights reserved.
   4  *
   5  * This package is an SSL implementation written
   6  * by Eric Young (eay@cryptsoft.com).
   7  * The implementation was written so as to conform with Netscapes SSL.
   8  *
   9  * This library is free for commercial and non-commercial use as long as
  10  * the following conditions are aheared to.  The following conditions
  11  * apply to all code found in this distribution, be it the RC4, RSA,
  12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
  13  * included with this distribution is covered by the same copyright terms
  14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
  15  *
  16  * Copyright remains Eric Young's, and as such any Copyright notices in
  17  * the code are not to be removed.
  18  * If this package is used in a product, Eric Young should be given attribution
  19  * as the author of the parts of the library used.
  20  * This can be in the form of a textual message at program startup or
  21  * in documentation (online or textual) provided with the package.
  22  *
  23  * Redistribution and use in source and binary forms, with or without
  24  * modification, are permitted provided that the following conditions
  25  * are met:
  26  * 1. Redistributions of source code must retain the copyright
  27  *    notice, this list of conditions and the following disclaimer.
  28  * 2. Redistributions in binary form must reproduce the above copyright
  29  *    notice, this list of conditions and the following disclaimer in the
  30  *    documentation and/or other materials provided with the distribution.
  31  * 3. All advertising materials mentioning features or use of this software
  32  *    must display the following acknowledgement:
  33  *    "This product includes cryptographic software written by
  34  *     Eric Young (eay@cryptsoft.com)"
  35  *    The word 'cryptographic' can be left out if the rouines from the library
  36  *    being used are not cryptographic related :-).
  37  * 4. If you include any Windows specific code (or a derivative thereof) from
  38  *    the apps directory (application code) you must include an acknowledgement:
  39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
  40  *
  41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
  42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  51  * SUCH DAMAGE.
  52  *
  53  * The licence and distribution terms for any publically available version or
  54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
  55  * copied and put under another distribution licence
  56  * [including the GNU Public Licence.]
  57  */
  58
  59 #include <stdio.h>
  60 #include <string.h>
  61
  62 #include <openssl/err.h>
  63 #include <openssl/evp.h>
  64 #include <openssl/objects.h>
  65
  66 int
  67 EVP_CIPHER_param_to_asn1(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
  68 {
  69         int ret;
  70
  71         if (c->cipher->set_asn1_parameters != NULL)
  72                 ret = c->cipher->set_asn1_parameters(c, type);
  73         else if (c->cipher->flags & EVP_CIPH_FLAG_DEFAULT_ASN1)
  74                 ret = EVP_CIPHER_set_asn1_iv(c, type);
  75         else
  76                 ret = -1;
  77         return (ret);
  78 }
  79
  80 int
  81 EVP_CIPHER_asn1_to_param(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
  82 {
  83         int ret;
  84
  85         if (c->cipher->get_asn1_parameters != NULL)
  86                 ret = c->cipher->get_asn1_parameters(c, type);
  87         else if (c->cipher->flags & EVP_CIPH_FLAG_DEFAULT_ASN1)
  88                 ret = EVP_CIPHER_get_asn1_iv(c, type);
  89         else
  90                 ret = -1;
  91         return (ret);
  92 }
  93
  94 int
  95 EVP_CIPHER_get_asn1_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
  96 {
  97         int i = 0;
  98         unsigned int l;
  99
 100         if (type != NULL) {
 101                 l = EVP_CIPHER_CTX_iv_length(c);
 102                 if (l > sizeof(c->iv)) {
 103                         EVPerror(EVP_R_IV_TOO_LARGE);
 104                         return 0;
 105                 }
 106                 i = ASN1_TYPE_get_octetstring(type, c->oiv, l);
 107                 if (i != (int)l)
 108                         return (-1);
 109                 else if (i > 0)
 110                         memcpy(c->iv, c->oiv, l);
 111         }
 112         return (i);
 113 }
 114
 115 int
 116 EVP_CIPHER_set_asn1_iv(EVP_CIPHER_CTX *c, ASN1_TYPE *type)
 117 {
 118         int i = 0;
 119         unsigned int j;
 120
 121         if (type != NULL) {
 122                 j = EVP_CIPHER_CTX_iv_length(c);
 123                 if (j > sizeof(c->iv)) {
 124                         EVPerror(EVP_R_IV_TOO_LARGE);
 125                         return 0;
 126                 }
 127                 i = ASN1_TYPE_set_octetstring(type, c->oiv, j);
 128         }
 129         return (i);
 130 }
 131
 132 /* Convert the various cipher NIDs and dummies to a proper OID NID */
 133 int
 134 EVP_CIPHER_type(const EVP_CIPHER *ctx)
 135 {
 136         int nid;
 137         ASN1_OBJECT *otmp;
 138         nid = EVP_CIPHER_nid(ctx);
 139
 140         switch (nid) {
 141         case NID_rc2_cbc:
 142         case NID_rc2_64_cbc:
 143         case NID_rc2_40_cbc:
 144                 return NID_rc2_cbc;
 145
 146         case NID_rc4:
 147         case NID_rc4_40:
 148                 return NID_rc4;
 149
 150         case NID_aes_128_cfb128:
 151         case NID_aes_128_cfb8:
 152         case NID_aes_128_cfb1:
 153                 return NID_aes_128_cfb128;
 154
 155         case NID_aes_192_cfb128:
 156         case NID_aes_192_cfb8:
 157         case NID_aes_192_cfb1:
 158                 return NID_aes_192_cfb128;
 159
 160         case NID_aes_256_cfb128:
 161         case NID_aes_256_cfb8:
 162         case NID_aes_256_cfb1:
 163                 return NID_aes_256_cfb128;
 164
 165         case NID_des_cfb64:
 166         case NID_des_cfb8:
 167         case NID_des_cfb1:
 168                 return NID_des_cfb64;
 169
 170         case NID_des_ede3_cfb64:
 171         case NID_des_ede3_cfb8:
 172         case NID_des_ede3_cfb1:
 173                 return NID_des_cfb64;
 174
 175         default:
 176                 /* Check it has an OID and it is valid */
 177                 otmp = OBJ_nid2obj(nid);
 178                 if (!otmp || !otmp->data)
 179                         nid = NID_undef;
 180                 ASN1_OBJECT_free(otmp);
 181                 return nid;
 182         }
 183 }
 184
 185 int
 186 EVP_CIPHER_block_size(const EVP_CIPHER *e)
 187 {
 188         return e->block_size;
 189 }
 190
 191 int
 192 EVP_CIPHER_CTX_block_size(const EVP_CIPHER_CTX *ctx)
 193 {
 194         return ctx->cipher->block_size;
 195 }
 196
 197 int
 198 EVP_Cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in,
 199     unsigned int inl)
 200 {
 201         return ctx->cipher->do_cipher(ctx, out, in, inl);
 202 }
 203
 204 const EVP_CIPHER *
 205 EVP_CIPHER_CTX_cipher(const EVP_CIPHER_CTX *ctx)
 206 {
 207         return ctx->cipher;
 208 }
 209
 210 unsigned long
 211 EVP_CIPHER_flags(const EVP_CIPHER *cipher)
 212 {
 213         return cipher->flags;
 214 }
 215
 216 unsigned long
 217 EVP_CIPHER_CTX_flags(const EVP_CIPHER_CTX *ctx)
 218 {
 219         return ctx->cipher->flags;
 220 }
 221
 222 void *
 223 EVP_CIPHER_CTX_get_app_data(const EVP_CIPHER_CTX *ctx)
 224 {
 225         return ctx->app_data;
 226 }
 227
 228 void
 229 EVP_CIPHER_CTX_set_app_data(EVP_CIPHER_CTX *ctx, void *data)
 230 {
 231         ctx->app_data = data;
 232 }
 233
 234 int
 235 EVP_CIPHER_iv_length(const EVP_CIPHER *cipher)
 236 {
 237         return cipher->iv_len;
 238 }
 239
 240 int
 241 EVP_CIPHER_CTX_iv_length(const EVP_CIPHER_CTX *ctx)
 242 {
 243         return ctx->cipher->iv_len;
 244 }
 245
 246 int
 247 EVP_CIPHER_key_length(const EVP_CIPHER *cipher)
 248 {
 249         return cipher->key_len;
 250 }
 251
 252 int
 253 EVP_CIPHER_CTX_key_length(const EVP_CIPHER_CTX *ctx)
 254 {
 255         return ctx->key_len;
 256 }
 257
 258 int
 259 EVP_CIPHER_nid(const EVP_CIPHER *cipher)
 260 {
 261         return cipher->nid;
 262 }
 263
 264 int
 265 EVP_CIPHER_CTX_nid(const EVP_CIPHER_CTX *ctx)
 266 {
 267         return ctx->cipher->nid;
 268 }
 269
 270 int
 271 EVP_MD_block_size(const EVP_MD *md)
 272 {
 273         return md->block_size;
 274 }
 275
 276 int
 277 EVP_MD_type(const EVP_MD *md)
 278 {
 279         return md->type;
 280 }
 281
 282 int
 283 EVP_MD_pkey_type(const EVP_MD *md)
 284 {
 285         return md->pkey_type;
 286 }
 287
 288 int
 289 EVP_MD_size(const EVP_MD *md)
 290 {
 291         if (!md) {
 292                 EVPerror(EVP_R_MESSAGE_DIGEST_IS_NULL);
 293                 return -1;
 294         }
 295         return md->md_size;
 296 }
 297
 298 unsigned long
 299 EVP_MD_flags(const EVP_MD *md)
 300 {
 301         return md->flags;
 302 }
 303
 304 const EVP_MD *
 305 EVP_MD_CTX_md(const EVP_MD_CTX *ctx)
 306 {
 307         if (!ctx)
 308                 return NULL;
 309         return ctx->digest;
 310 }
 311
 312 void
 313 EVP_MD_CTX_set_flags(EVP_MD_CTX *ctx, int flags)
 314 {
 315         ctx->flags |= flags;
 316 }
 317
 318 void
 319 EVP_MD_CTX_clear_flags(EVP_MD_CTX *ctx, int flags)
 320 {
 321         ctx->flags &= ~flags;
 322 }
 323
 324 int
 325 EVP_MD_CTX_test_flags(const EVP_MD_CTX *ctx, int flags)
 326 {
 327         return (ctx->flags & flags);
 328 }
 329
 330 void
 331 EVP_CIPHER_CTX_set_flags(EVP_CIPHER_CTX *ctx, int flags)
 332 {
 333         ctx->flags |= flags;
 334 }
 335
 336 void
 337 EVP_CIPHER_CTX_clear_flags(EVP_CIPHER_CTX *ctx, int flags)
 338 {
 339         ctx->flags &= ~flags;
 340 }
 341
 342 int
 343 EVP_CIPHER_CTX_test_flags(const EVP_CIPHER_CTX *ctx, int flags)
 344 {
 345         return (ctx->flags & flags);
 346 }