diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/lib/libcrypto/evp/e_des3.c | 257 | ||||
| -rw-r--r-- | src/lib/libcrypto/evp/e_idea.c | 162 |
2 files changed, 387 insertions, 32 deletions
diff --git a/src/lib/libcrypto/evp/e_des3.c b/src/lib/libcrypto/evp/e_des3.c index cc01c69b5e..1d843d9c84 100644 --- a/src/lib/libcrypto/evp/e_des3.c +++ b/src/lib/libcrypto/evp/e_des3.c | |||
| @@ -1,4 +1,4 @@ | |||
| 1 | /* $OpenBSD: e_des3.c,v 1.21 2022/09/03 20:12:24 jsing Exp $ */ | 1 | /* $OpenBSD: e_des3.c,v 1.22 2022/09/04 08:54:16 jsing Exp $ */ |
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) |
| 3 | * All rights reserved. | 3 | * All rights reserved. |
| 4 | * | 4 | * |
| @@ -89,7 +89,16 @@ static int | |||
| 89 | des_ede_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, | 89 | des_ede_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, |
| 90 | const unsigned char *in, size_t inl) | 90 | const unsigned char *in, size_t inl) |
| 91 | { | 91 | { |
| 92 | BLOCK_CIPHER_ecb_loop() | 92 | size_t i, bl; |
| 93 | |||
| 94 | bl = ctx->cipher->block_size; | ||
| 95 | |||
| 96 | if (inl < bl) | ||
| 97 | return 1; | ||
| 98 | |||
| 99 | inl -= bl; | ||
| 100 | |||
| 101 | for (i = 0; i <= inl; i += bl) | ||
| 93 | DES_ecb3_encrypt((const_DES_cblock *)(in + i), (DES_cblock *)(out + i), | 102 | DES_ecb3_encrypt((const_DES_cblock *)(in + i), (DES_cblock *)(out + i), |
| 94 | &data(ctx)->ks1, &data(ctx)->ks2, &data(ctx)->ks3, ctx->encrypt); | 103 | &data(ctx)->ks1, &data(ctx)->ks2, &data(ctx)->ks3, ctx->encrypt); |
| 95 | return 1; | 104 | return 1; |
| @@ -195,34 +204,234 @@ des_ede3_cfb8_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, | |||
| 195 | return 1; | 204 | return 1; |
| 196 | } | 205 | } |
| 197 | 206 | ||
| 198 | BLOCK_CIPHER_defs(des_ede, DES_EDE_KEY, NID_des_ede, 8, 16, 8, 64, | 207 | static const EVP_CIPHER des_ede_cbc = { |
| 199 | EVP_CIPH_RAND_KEY, des_ede_init_key, NULL, | 208 | .nid = NID_des_ede_cbc, |
| 200 | EVP_CIPHER_set_asn1_iv, | 209 | .block_size = 8, |
| 201 | EVP_CIPHER_get_asn1_iv, | 210 | .key_len = 16, |
| 202 | des3_ctrl) | 211 | .iv_len = 8, |
| 212 | .flags = EVP_CIPH_RAND_KEY | EVP_CIPH_CBC_MODE, | ||
| 213 | .init = des_ede_init_key, | ||
| 214 | .do_cipher = des_ede_cbc_cipher, | ||
| 215 | .cleanup = NULL, | ||
| 216 | .ctx_size = sizeof(DES_EDE_KEY), | ||
| 217 | .set_asn1_parameters = EVP_CIPHER_set_asn1_iv, | ||
| 218 | .get_asn1_parameters = EVP_CIPHER_get_asn1_iv, | ||
| 219 | .ctrl = des3_ctrl, | ||
| 220 | .app_data = NULL, | ||
| 221 | }; | ||
| 222 | |||
| 223 | const EVP_CIPHER * | ||
| 224 | EVP_des_ede_cbc(void) | ||
| 225 | { | ||
| 226 | return &des_ede_cbc; | ||
| 227 | } | ||
| 228 | |||
| 229 | static const EVP_CIPHER des_ede_cfb64 = { | ||
| 230 | .nid = NID_des_ede_cfb64, | ||
| 231 | .block_size = 1, | ||
| 232 | .key_len = 16, | ||
| 233 | .iv_len = 8, | ||
| 234 | .flags = EVP_CIPH_RAND_KEY | EVP_CIPH_CFB_MODE, | ||
| 235 | .init = des_ede_init_key, | ||
| 236 | .do_cipher = des_ede_cfb64_cipher, | ||
| 237 | .cleanup = NULL, | ||
| 238 | .ctx_size = sizeof(DES_EDE_KEY), | ||
| 239 | .set_asn1_parameters = EVP_CIPHER_set_asn1_iv, | ||
| 240 | .get_asn1_parameters = EVP_CIPHER_get_asn1_iv, | ||
| 241 | .ctrl = des3_ctrl, | ||
| 242 | .app_data = NULL, | ||
| 243 | }; | ||
| 244 | |||
| 245 | const EVP_CIPHER * | ||
| 246 | EVP_des_ede_cfb64(void) | ||
| 247 | { | ||
| 248 | return &des_ede_cfb64; | ||
| 249 | } | ||
| 250 | |||
| 251 | static const EVP_CIPHER des_ede_ofb = { | ||
| 252 | .nid = NID_des_ede_ofb64, | ||
| 253 | .block_size = 1, | ||
| 254 | .key_len = 16, | ||
| 255 | .iv_len = 8, | ||
| 256 | .flags = EVP_CIPH_RAND_KEY | EVP_CIPH_OFB_MODE, | ||
| 257 | .init = des_ede_init_key, | ||
| 258 | .do_cipher = des_ede_ofb_cipher, | ||
| 259 | .cleanup = NULL, | ||
| 260 | .ctx_size = sizeof(DES_EDE_KEY), | ||
| 261 | .set_asn1_parameters = EVP_CIPHER_set_asn1_iv, | ||
| 262 | .get_asn1_parameters = EVP_CIPHER_get_asn1_iv, | ||
| 263 | .ctrl = des3_ctrl, | ||
| 264 | .app_data = NULL, | ||
| 265 | }; | ||
| 266 | |||
| 267 | const EVP_CIPHER * | ||
| 268 | EVP_des_ede_ofb(void) | ||
| 269 | { | ||
| 270 | return &des_ede_ofb; | ||
| 271 | } | ||
| 272 | |||
| 273 | static const EVP_CIPHER des_ede_ecb = { | ||
| 274 | .nid = NID_des_ede_ecb, | ||
| 275 | .block_size = 8, | ||
| 276 | .key_len = 16, | ||
| 277 | .iv_len = 0, | ||
| 278 | .flags = EVP_CIPH_RAND_KEY | EVP_CIPH_ECB_MODE, | ||
| 279 | .init = des_ede_init_key, | ||
| 280 | .do_cipher = des_ede_ecb_cipher, | ||
| 281 | .cleanup = NULL, | ||
| 282 | .ctx_size = sizeof(DES_EDE_KEY), | ||
| 283 | .set_asn1_parameters = EVP_CIPHER_set_asn1_iv, | ||
| 284 | .get_asn1_parameters = EVP_CIPHER_get_asn1_iv, | ||
| 285 | .ctrl = des3_ctrl, | ||
| 286 | .app_data = NULL, | ||
| 287 | }; | ||
| 288 | |||
| 289 | const EVP_CIPHER * | ||
| 290 | EVP_des_ede_ecb(void) | ||
| 291 | { | ||
| 292 | return &des_ede_ecb; | ||
| 293 | } | ||
| 294 | |||
| 203 | 295 | ||
| 204 | #define des_ede3_cfb64_cipher des_ede_cfb64_cipher | 296 | #define des_ede3_cfb64_cipher des_ede_cfb64_cipher |
| 205 | #define des_ede3_ofb_cipher des_ede_ofb_cipher | 297 | #define des_ede3_ofb_cipher des_ede_ofb_cipher |
| 206 | #define des_ede3_cbc_cipher des_ede_cbc_cipher | 298 | #define des_ede3_cbc_cipher des_ede_cbc_cipher |
| 207 | #define des_ede3_ecb_cipher des_ede_ecb_cipher | 299 | #define des_ede3_ecb_cipher des_ede_ecb_cipher |
| 208 | 300 | ||
| 209 | BLOCK_CIPHER_defs(des_ede3, DES_EDE_KEY, NID_des_ede3, 8, 24, 8, 64, | 301 | static const EVP_CIPHER des_ede3_cbc = { |
| 210 | EVP_CIPH_RAND_KEY, des_ede3_init_key, NULL, | 302 | .nid = NID_des_ede3_cbc, |
| 211 | EVP_CIPHER_set_asn1_iv, | 303 | .block_size = 8, |
| 212 | EVP_CIPHER_get_asn1_iv, | 304 | .key_len = 24, |
| 213 | des3_ctrl) | 305 | .iv_len = 8, |
| 214 | 306 | .flags = EVP_CIPH_RAND_KEY | EVP_CIPH_CBC_MODE, | |
| 215 | BLOCK_CIPHER_def_cfb(des_ede3, DES_EDE_KEY, NID_des_ede3, 24, 8, 1, | 307 | .init = des_ede3_init_key, |
| 216 | EVP_CIPH_RAND_KEY, des_ede3_init_key, NULL, | 308 | .do_cipher = des_ede3_cbc_cipher, |
| 217 | EVP_CIPHER_set_asn1_iv, | 309 | .cleanup = NULL, |
| 218 | EVP_CIPHER_get_asn1_iv, | 310 | .ctx_size = sizeof(DES_EDE_KEY), |
| 219 | des3_ctrl) | 311 | .set_asn1_parameters = EVP_CIPHER_set_asn1_iv, |
| 220 | 312 | .get_asn1_parameters = EVP_CIPHER_get_asn1_iv, | |
| 221 | BLOCK_CIPHER_def_cfb(des_ede3, DES_EDE_KEY, NID_des_ede3, 24, 8, 8, | 313 | .ctrl = des3_ctrl, |
| 222 | EVP_CIPH_RAND_KEY, des_ede3_init_key, NULL, | 314 | .app_data = NULL, |
| 223 | EVP_CIPHER_set_asn1_iv, | 315 | }; |
| 224 | EVP_CIPHER_get_asn1_iv, | 316 | |
| 225 | des3_ctrl) | 317 | const EVP_CIPHER * |
| 318 | EVP_des_ede3_cbc(void) | ||
| 319 | { | ||
| 320 | return &des_ede3_cbc; | ||
| 321 | } | ||
| 322 | |||
| 323 | static const EVP_CIPHER des_ede3_cfb64 = { | ||
| 324 | .nid = NID_des_ede3_cfb64, | ||
| 325 | .block_size = 1, | ||
| 326 | .key_len = 24, | ||
| 327 | .iv_len = 8, | ||
| 328 | .flags = EVP_CIPH_RAND_KEY | EVP_CIPH_CFB_MODE, | ||
| 329 | .init = des_ede3_init_key, | ||
| 330 | .do_cipher = des_ede3_cfb64_cipher, | ||
| 331 | .cleanup = NULL, | ||
| 332 | .ctx_size = sizeof(DES_EDE_KEY), | ||
| 333 | .set_asn1_parameters = EVP_CIPHER_set_asn1_iv, | ||
| 334 | .get_asn1_parameters = EVP_CIPHER_get_asn1_iv, | ||
| 335 | .ctrl = des3_ctrl, | ||
| 336 | .app_data = NULL, | ||
| 337 | }; | ||
| 338 | |||
| 339 | const EVP_CIPHER * | ||
| 340 | EVP_des_ede3_cfb64(void) | ||
| 341 | { | ||
| 342 | return &des_ede3_cfb64; | ||
| 343 | } | ||
| 344 | |||
| 345 | static const EVP_CIPHER des_ede3_ofb = { | ||
| 346 | .nid = NID_des_ede3_ofb64, | ||
| 347 | .block_size = 1, | ||
| 348 | .key_len = 24, | ||
| 349 | .iv_len = 8, | ||
| 350 | .flags = EVP_CIPH_RAND_KEY | EVP_CIPH_OFB_MODE, | ||
| 351 | .init = des_ede3_init_key, | ||
| 352 | .do_cipher = des_ede3_ofb_cipher, | ||
| 353 | .cleanup = NULL, | ||
| 354 | .ctx_size = sizeof(DES_EDE_KEY), | ||
| 355 | .set_asn1_parameters = EVP_CIPHER_set_asn1_iv, | ||
| 356 | .get_asn1_parameters = EVP_CIPHER_get_asn1_iv, | ||
| 357 | .ctrl = des3_ctrl, | ||
| 358 | .app_data = NULL, | ||
| 359 | }; | ||
| 360 | |||
| 361 | const EVP_CIPHER * | ||
| 362 | EVP_des_ede3_ofb(void) | ||
| 363 | { | ||
| 364 | return &des_ede3_ofb; | ||
| 365 | } | ||
| 366 | |||
| 367 | static const EVP_CIPHER des_ede3_ecb = { | ||
| 368 | .nid = NID_des_ede3_ecb, | ||
| 369 | .block_size = 8, | ||
| 370 | .key_len = 24, | ||
| 371 | .iv_len = 0, | ||
| 372 | .flags = EVP_CIPH_RAND_KEY | EVP_CIPH_ECB_MODE, | ||
| 373 | .init = des_ede3_init_key, | ||
| 374 | .do_cipher = des_ede3_ecb_cipher, | ||
| 375 | .cleanup = NULL, | ||
| 376 | .ctx_size = sizeof(DES_EDE_KEY), | ||
| 377 | .set_asn1_parameters = EVP_CIPHER_set_asn1_iv, | ||
| 378 | .get_asn1_parameters = EVP_CIPHER_get_asn1_iv, | ||
| 379 | .ctrl = des3_ctrl, | ||
| 380 | .app_data = NULL, | ||
| 381 | }; | ||
| 382 | |||
| 383 | const EVP_CIPHER * | ||
| 384 | EVP_des_ede3_ecb(void) | ||
| 385 | { | ||
| 386 | return &des_ede3_ecb; | ||
| 387 | } | ||
| 388 | |||
| 389 | |||
| 390 | static const EVP_CIPHER des_ede3_cfb1 = { | ||
| 391 | .nid = NID_des_ede3_cfb1, | ||
| 392 | .block_size = 1, | ||
| 393 | .key_len = 24, | ||
| 394 | .iv_len = 8, | ||
| 395 | .flags = EVP_CIPH_RAND_KEY | EVP_CIPH_CFB_MODE, | ||
| 396 | .init = des_ede3_init_key, | ||
| 397 | .do_cipher = des_ede3_cfb1_cipher, | ||
| 398 | .cleanup = NULL, | ||
| 399 | .ctx_size = sizeof(DES_EDE_KEY), | ||
| 400 | .set_asn1_parameters = EVP_CIPHER_set_asn1_iv, | ||
| 401 | .get_asn1_parameters = EVP_CIPHER_get_asn1_iv, | ||
| 402 | .ctrl = des3_ctrl, | ||
| 403 | .app_data = NULL, | ||
| 404 | }; | ||
| 405 | |||
| 406 | const EVP_CIPHER * | ||
| 407 | EVP_des_ede3_cfb1(void) | ||
| 408 | { | ||
| 409 | return &des_ede3_cfb1; | ||
| 410 | } | ||
| 411 | |||
| 412 | |||
| 413 | static const EVP_CIPHER des_ede3_cfb8 = { | ||
| 414 | .nid = NID_des_ede3_cfb8, | ||
| 415 | .block_size = 1, | ||
| 416 | .key_len = 24, | ||
| 417 | .iv_len = 8, | ||
| 418 | .flags = EVP_CIPH_RAND_KEY | EVP_CIPH_CFB_MODE, | ||
| 419 | .init = des_ede3_init_key, | ||
| 420 | .do_cipher = des_ede3_cfb8_cipher, | ||
| 421 | .cleanup = NULL, | ||
| 422 | .ctx_size = sizeof(DES_EDE_KEY), | ||
| 423 | .set_asn1_parameters = EVP_CIPHER_set_asn1_iv, | ||
| 424 | .get_asn1_parameters = EVP_CIPHER_get_asn1_iv, | ||
| 425 | .ctrl = des3_ctrl, | ||
| 426 | .app_data = NULL, | ||
| 427 | }; | ||
| 428 | |||
| 429 | const EVP_CIPHER * | ||
| 430 | EVP_des_ede3_cfb8(void) | ||
| 431 | { | ||
| 432 | return &des_ede3_cfb8; | ||
| 433 | } | ||
| 434 | |||
| 226 | 435 | ||
| 227 | static int | 436 | static int |
| 228 | des_ede_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key, | 437 | des_ede_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key, |
diff --git a/src/lib/libcrypto/evp/e_idea.c b/src/lib/libcrypto/evp/e_idea.c index b2240b3043..d69f200423 100644 --- a/src/lib/libcrypto/evp/e_idea.c +++ b/src/lib/libcrypto/evp/e_idea.c | |||
| @@ -1,4 +1,4 @@ | |||
| 1 | /* $OpenBSD: e_idea.c,v 1.11 2022/09/03 20:12:24 jsing Exp $ */ | 1 | /* $OpenBSD: e_idea.c,v 1.12 2022/09/04 08:57:32 jsing Exp $ */ |
| 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) | 2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) |
| 3 | * All rights reserved. | 3 | * All rights reserved. |
| 4 | * | 4 | * |
| @@ -80,7 +80,16 @@ static int | |||
| 80 | idea_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, | 80 | idea_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, |
| 81 | const unsigned char *in, size_t inl) | 81 | const unsigned char *in, size_t inl) |
| 82 | { | 82 | { |
| 83 | BLOCK_CIPHER_ecb_loop() | 83 | size_t i, bl; |
| 84 | |||
| 85 | bl = ctx->cipher->block_size; | ||
| 86 | |||
| 87 | if (inl < bl) | ||
| 88 | return 1; | ||
| 89 | |||
| 90 | inl -= bl; | ||
| 91 | |||
| 92 | for (i = 0; i <= inl; i += bl) | ||
| 84 | idea_ecb_encrypt(in + i, out + i, ctx->cipher_data); | 93 | idea_ecb_encrypt(in + i, out + i, ctx->cipher_data); |
| 85 | return 1; | 94 | return 1; |
| 86 | } | 95 | } |
| @@ -89,13 +98,150 @@ typedef struct { | |||
| 89 | IDEA_KEY_SCHEDULE ks; | 98 | IDEA_KEY_SCHEDULE ks; |
| 90 | } EVP_IDEA_KEY; | 99 | } EVP_IDEA_KEY; |
| 91 | 100 | ||
| 92 | BLOCK_CIPHER_func_cbc(idea, idea, EVP_IDEA_KEY, ks) | 101 | static int |
| 93 | BLOCK_CIPHER_func_ofb(idea, idea, 64, EVP_IDEA_KEY, ks) | 102 | idea_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl) |
| 94 | BLOCK_CIPHER_func_cfb(idea, idea, 64, EVP_IDEA_KEY, ks) | 103 | { |
| 104 | while (inl >= EVP_MAXCHUNK) { | ||
| 105 | idea_cbc_encrypt(in, out, (long)EVP_MAXCHUNK, &((EVP_IDEA_KEY *)ctx->cipher_data)->ks, ctx->iv, ctx->encrypt); | ||
| 106 | inl -= EVP_MAXCHUNK; | ||
| 107 | in += EVP_MAXCHUNK; | ||
| 108 | out += EVP_MAXCHUNK; | ||
| 109 | } | ||
| 110 | |||
| 111 | if (inl) | ||
| 112 | idea_cbc_encrypt(in, out, (long)inl, &((EVP_IDEA_KEY *)ctx->cipher_data)->ks, ctx->iv, ctx->encrypt); | ||
| 113 | |||
| 114 | return 1; | ||
| 115 | } | ||
| 116 | |||
| 117 | static int | ||
| 118 | idea_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl) | ||
| 119 | { | ||
| 120 | while (inl >= EVP_MAXCHUNK) { | ||
| 121 | idea_ofb64_encrypt(in, out, (long)EVP_MAXCHUNK, &((EVP_IDEA_KEY *)ctx->cipher_data)->ks, ctx->iv, &ctx->num); | ||
| 122 | inl -= EVP_MAXCHUNK; | ||
| 123 | in += EVP_MAXCHUNK; | ||
| 124 | out += EVP_MAXCHUNK; | ||
| 125 | } | ||
| 126 | |||
| 127 | if (inl) | ||
| 128 | idea_ofb64_encrypt(in, out, (long)inl, &((EVP_IDEA_KEY *)ctx->cipher_data)->ks, ctx->iv, &ctx->num); | ||
| 129 | |||
| 130 | return 1; | ||
| 131 | } | ||
| 132 | |||
| 133 | static int | ||
| 134 | idea_cfb64_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, const unsigned char *in, size_t inl) | ||
| 135 | { | ||
| 136 | size_t chunk = EVP_MAXCHUNK; | ||
| 137 | |||
| 138 | if (64 == 1) | ||
| 139 | chunk >>= 3; | ||
| 140 | |||
| 141 | if (inl < chunk) | ||
| 142 | chunk = inl; | ||
| 143 | |||
| 144 | while (inl && inl >= chunk) { | ||
| 145 | idea_cfb64_encrypt(in, out, (long)((64 == 1) && !(ctx->flags & EVP_CIPH_FLAG_LENGTH_BITS) ? inl * 8 : inl), &((EVP_IDEA_KEY *)ctx->cipher_data)->ks, ctx->iv, &ctx->num, ctx->encrypt); | ||
| 146 | inl -= chunk; | ||
| 147 | in += chunk; | ||
| 148 | out += chunk; | ||
| 149 | if (inl < chunk) | ||
| 150 | chunk = inl; | ||
| 151 | } | ||
| 152 | |||
| 153 | return 1; | ||
| 154 | } | ||
| 155 | |||
| 156 | |||
| 157 | static const EVP_CIPHER idea_cbc = { | ||
| 158 | .nid = NID_idea_cbc, | ||
| 159 | .block_size = 8, | ||
| 160 | .key_len = 16, | ||
| 161 | .iv_len = 8, | ||
| 162 | .flags = 0 | EVP_CIPH_CBC_MODE, | ||
| 163 | .init = idea_init_key, | ||
| 164 | .do_cipher = idea_cbc_cipher, | ||
| 165 | .cleanup = NULL, | ||
| 166 | .ctx_size = sizeof(IDEA_KEY_SCHEDULE), | ||
| 167 | .set_asn1_parameters = EVP_CIPHER_set_asn1_iv, | ||
| 168 | .get_asn1_parameters = EVP_CIPHER_get_asn1_iv, | ||
| 169 | .ctrl = NULL, | ||
| 170 | .app_data = NULL, | ||
| 171 | }; | ||
| 172 | |||
| 173 | const EVP_CIPHER * | ||
| 174 | EVP_idea_cbc(void) | ||
| 175 | { | ||
| 176 | return &idea_cbc; | ||
| 177 | } | ||
| 178 | |||
| 179 | static const EVP_CIPHER idea_cfb64 = { | ||
| 180 | .nid = NID_idea_cfb64, | ||
| 181 | .block_size = 1, | ||
| 182 | .key_len = 16, | ||
| 183 | .iv_len = 8, | ||
| 184 | .flags = 0 | EVP_CIPH_CFB_MODE, | ||
| 185 | .init = idea_init_key, | ||
| 186 | .do_cipher = idea_cfb64_cipher, | ||
| 187 | .cleanup = NULL, | ||
| 188 | .ctx_size = sizeof(IDEA_KEY_SCHEDULE), | ||
| 189 | .set_asn1_parameters = EVP_CIPHER_set_asn1_iv, | ||
| 190 | .get_asn1_parameters = EVP_CIPHER_get_asn1_iv, | ||
| 191 | .ctrl = NULL, | ||
| 192 | .app_data = NULL, | ||
| 193 | }; | ||
| 194 | |||
| 195 | const EVP_CIPHER * | ||
| 196 | EVP_idea_cfb64(void) | ||
| 197 | { | ||
| 198 | return &idea_cfb64; | ||
| 199 | } | ||
| 200 | |||
| 201 | static const EVP_CIPHER idea_ofb = { | ||
| 202 | .nid = NID_idea_ofb64, | ||
| 203 | .block_size = 1, | ||
| 204 | .key_len = 16, | ||
| 205 | .iv_len = 8, | ||
| 206 | .flags = 0 | EVP_CIPH_OFB_MODE, | ||
| 207 | .init = idea_init_key, | ||
| 208 | .do_cipher = idea_ofb_cipher, | ||
| 209 | .cleanup = NULL, | ||
| 210 | .ctx_size = sizeof(IDEA_KEY_SCHEDULE), | ||
| 211 | .set_asn1_parameters = EVP_CIPHER_set_asn1_iv, | ||
| 212 | .get_asn1_parameters = EVP_CIPHER_get_asn1_iv, | ||
| 213 | .ctrl = NULL, | ||
| 214 | .app_data = NULL, | ||
| 215 | }; | ||
| 216 | |||
| 217 | const EVP_CIPHER * | ||
| 218 | EVP_idea_ofb(void) | ||
| 219 | { | ||
| 220 | return &idea_ofb; | ||
| 221 | } | ||
| 222 | |||
| 223 | static const EVP_CIPHER idea_ecb = { | ||
| 224 | .nid = NID_idea_ecb, | ||
| 225 | .block_size = 8, | ||
| 226 | .key_len = 16, | ||
| 227 | .iv_len = 0, | ||
| 228 | .flags = 0 | EVP_CIPH_ECB_MODE, | ||
| 229 | .init = idea_init_key, | ||
| 230 | .do_cipher = idea_ecb_cipher, | ||
| 231 | .cleanup = NULL, | ||
| 232 | .ctx_size = sizeof(IDEA_KEY_SCHEDULE), | ||
| 233 | .set_asn1_parameters = EVP_CIPHER_set_asn1_iv, | ||
| 234 | .get_asn1_parameters = EVP_CIPHER_get_asn1_iv, | ||
| 235 | .ctrl = NULL, | ||
| 236 | .app_data = NULL, | ||
| 237 | }; | ||
| 238 | |||
| 239 | const EVP_CIPHER * | ||
| 240 | EVP_idea_ecb(void) | ||
| 241 | { | ||
| 242 | return &idea_ecb; | ||
| 243 | } | ||
| 95 | 244 | ||
| 96 | BLOCK_CIPHER_defs(idea, IDEA_KEY_SCHEDULE, NID_idea, 8, 16, 8, 64, | ||
| 97 | 0, idea_init_key, NULL, | ||
| 98 | EVP_CIPHER_set_asn1_iv, EVP_CIPHER_get_asn1_iv, NULL) | ||
| 99 | 245 | ||
| 100 | static int | 246 | static int |
| 101 | idea_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key, | 247 | idea_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key, |
