evp_enc.c revision 68651
1/* crypto/evp/evp_enc.c */ 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 "cryptlib.h" 61#include <openssl/evp.h> 62#include <openssl/err.h> 63#include "evp_locl.h" 64 65const char *EVP_version="EVP" OPENSSL_VERSION_PTEXT; 66 67void EVP_CIPHER_CTX_init(EVP_CIPHER_CTX *ctx) 68 { 69 memset(ctx,0,sizeof(EVP_CIPHER_CTX)); 70 /* ctx->cipher=NULL; */ 71 } 72 73int EVP_CipherInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, 74 unsigned char *key, unsigned char *iv, int enc) 75 { 76 if(enc && (enc != -1)) enc = 1; 77 if (cipher) { 78 ctx->cipher=cipher; 79 ctx->key_len = cipher->key_len; 80 if(ctx->cipher->flags & EVP_CIPH_CTRL_INIT) { 81 if(!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_INIT, 0, NULL)) { 82 EVPerr(EVP_F_EVP_CIPHERINIT, EVP_R_INITIALIZATION_ERROR); 83 return 0; 84 } 85 } 86 } else if(!ctx->cipher) { 87 EVPerr(EVP_F_EVP_CIPHERINIT, EVP_R_NO_CIPHER_SET); 88 return 0; 89 } 90 if(!(EVP_CIPHER_CTX_flags(ctx) & EVP_CIPH_CUSTOM_IV)) { 91 switch(EVP_CIPHER_CTX_mode(ctx)) { 92 93 case EVP_CIPH_STREAM_CIPHER: 94 case EVP_CIPH_ECB_MODE: 95 break; 96 97 case EVP_CIPH_CFB_MODE: 98 case EVP_CIPH_OFB_MODE: 99 100 ctx->num = 0; 101 102 case EVP_CIPH_CBC_MODE: 103 104 if(iv) memcpy(ctx->oiv, iv, EVP_CIPHER_CTX_iv_length(ctx)); 105 memcpy(ctx->iv, ctx->oiv, EVP_CIPHER_CTX_iv_length(ctx)); 106 break; 107 108 default: 109 return 0; 110 break; 111 } 112 } 113 114 if(key || (ctx->cipher->flags & EVP_CIPH_ALWAYS_CALL_INIT)) { 115 if(!ctx->cipher->init(ctx,key,iv,enc)) return 0; 116 } 117 if(enc != -1) ctx->encrypt=enc; 118 ctx->buf_len=0; 119 return 1; 120 } 121 122int EVP_CipherUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl, 123 unsigned char *in, int inl) 124 { 125 if (ctx->encrypt) 126 return EVP_EncryptUpdate(ctx,out,outl,in,inl); 127 else return EVP_DecryptUpdate(ctx,out,outl,in,inl); 128 } 129 130int EVP_CipherFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl) 131 { 132 if (ctx->encrypt) 133 return EVP_EncryptFinal(ctx,out,outl); 134 else return(EVP_DecryptFinal(ctx,out,outl)); 135 } 136 137int EVP_EncryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, 138 unsigned char *key, unsigned char *iv) 139 { 140 return EVP_CipherInit(ctx, cipher, key, iv, 1); 141 } 142 143int EVP_DecryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, 144 unsigned char *key, unsigned char *iv) 145 { 146 return EVP_CipherInit(ctx, cipher, key, iv, 0); 147 } 148 149 150int EVP_EncryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl, 151 unsigned char *in, int inl) 152 { 153 int i,j,bl; 154 155 i=ctx->buf_len; 156 bl=ctx->cipher->block_size; 157 *outl=0; 158 if ((inl == 0) && (i != bl)) return 1; 159 if (i != 0) 160 { 161 if (i+inl < bl) 162 { 163 memcpy(&(ctx->buf[i]),in,inl); 164 ctx->buf_len+=inl; 165 return 1; 166 } 167 else 168 { 169 j=bl-i; 170 if (j != 0) memcpy(&(ctx->buf[i]),in,j); 171 if(!ctx->cipher->do_cipher(ctx,out,ctx->buf,bl)) return 0; 172 inl-=j; 173 in+=j; 174 out+=bl; 175 *outl+=bl; 176 } 177 } 178 i=inl%bl; /* how much is left */ 179 inl-=i; 180 if (inl > 0) 181 { 182 if(!ctx->cipher->do_cipher(ctx,out,in,inl)) return 0; 183 *outl+=inl; 184 } 185 186 if (i != 0) 187 memcpy(ctx->buf,&(in[inl]),i); 188 ctx->buf_len=i; 189 return 1; 190 } 191 192int EVP_EncryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl) 193 { 194 int i,n,b,bl; 195 196 b=ctx->cipher->block_size; 197 if (b == 1) 198 { 199 *outl=0; 200 return 1; 201 } 202 bl=ctx->buf_len; 203 n=b-bl; 204 for (i=bl; i<b; i++) 205 ctx->buf[i]=n; 206 if(!ctx->cipher->do_cipher(ctx,out,ctx->buf,b)) return 0; 207 *outl=b; 208 return 1; 209 } 210 211int EVP_DecryptUpdate(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl, 212 unsigned char *in, int inl) 213 { 214 int b,bl,n; 215 int keep_last=0; 216 217 *outl=0; 218 if (inl == 0) return 1; 219 220 b=ctx->cipher->block_size; 221 if (b > 1) 222 { 223 /* Is the input a multiple of the block size? */ 224 bl=ctx->buf_len; 225 n=inl+bl; 226 if (n%b == 0) 227 { 228 if (inl < b) /* must be 'just one' buff */ 229 { 230 memcpy(&(ctx->buf[bl]),in,inl); 231 ctx->buf_len=b; 232 *outl=0; 233 return 1; 234 } 235 keep_last=1; 236 inl-=b; /* don't do the last block */ 237 } 238 } 239 if(!EVP_EncryptUpdate(ctx,out,outl,in,inl)) return 0; 240 241 /* if we have 'decrypted' a multiple of block size, make sure 242 * we have a copy of this last block */ 243 if (keep_last) 244 { 245 memcpy(&(ctx->buf[0]),&(in[inl]),b); 246#ifdef DEBUG 247 if (ctx->buf_len != 0) 248 { 249 abort(); 250 } 251#endif 252 ctx->buf_len=b; 253 } 254 return 1; 255 } 256 257int EVP_DecryptFinal(EVP_CIPHER_CTX *ctx, unsigned char *out, int *outl) 258 { 259 int i,b; 260 int n; 261 262 *outl=0; 263 b=ctx->cipher->block_size; 264 if (b > 1) 265 { 266 if (ctx->buf_len != b) 267 { 268 EVPerr(EVP_F_EVP_DECRYPTFINAL,EVP_R_WRONG_FINAL_BLOCK_LENGTH); 269 return(0); 270 } 271 if(!EVP_EncryptUpdate(ctx,ctx->buf,&n,ctx->buf,0)) return 0; 272 if (n != b) 273 return(0); 274 n=ctx->buf[b-1]; 275 if (n > b) 276 { 277 EVPerr(EVP_F_EVP_DECRYPTFINAL,EVP_R_BAD_DECRYPT); 278 return(0); 279 } 280 for (i=0; i<n; i++) 281 { 282 if (ctx->buf[--b] != n) 283 { 284 EVPerr(EVP_F_EVP_DECRYPTFINAL,EVP_R_BAD_DECRYPT); 285 return(0); 286 } 287 } 288 n=ctx->cipher->block_size-n; 289 for (i=0; i<n; i++) 290 out[i]=ctx->buf[i]; 291 *outl=n; 292 } 293 else 294 *outl=0; 295 return(1); 296 } 297 298int EVP_CIPHER_CTX_cleanup(EVP_CIPHER_CTX *c) 299 { 300 if ((c->cipher != NULL) && (c->cipher->cleanup != NULL)) 301 { 302 if(!c->cipher->cleanup(c)) return 0; 303 } 304 memset(c,0,sizeof(EVP_CIPHER_CTX)); 305 return 1; 306 } 307 308int EVP_CIPHER_CTX_set_key_length(EVP_CIPHER_CTX *c, int keylen) 309 { 310 if(c->cipher->flags & EVP_CIPH_CUSTOM_KEY_LENGTH) 311 return EVP_CIPHER_CTX_ctrl(c, EVP_CTRL_SET_KEY_LENGTH, keylen, NULL); 312 if(c->key_len == keylen) return 1; 313 if((keylen > 0) && (c->cipher->flags & EVP_CIPH_VARIABLE_LENGTH)) 314 { 315 c->key_len = keylen; 316 return 1; 317 } 318 EVPerr(EVP_F_EVP_CIPHER_CTX_SET_KEY_LENGTH,EVP_R_INVALID_KEY_LENGTH); 319 return 0; 320 } 321 322int EVP_CIPHER_CTX_ctrl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr) 323{ 324 int ret; 325 if(!ctx->cipher) { 326 EVPerr(EVP_F_EVP_CIPHER_CTX_CTRL, EVP_R_NO_CIPHER_SET); 327 return 0; 328 } 329 330 if(!ctx->cipher->ctrl) { 331 EVPerr(EVP_F_EVP_CIPHER_CTX_CTRL, EVP_R_CTRL_NOT_IMPLEMENTED); 332 return 0; 333 } 334 335 ret = ctx->cipher->ctrl(ctx, type, arg, ptr); 336 if(ret == -1) { 337 EVPerr(EVP_F_EVP_CIPHER_CTX_CTRL, EVP_R_CTRL_OPERATION_NOT_IMPLEMENTED); 338 return 0; 339 } 340 return ret; 341} 342