1295009Sjkim/* crypto/evp/e_camellia.c */ 2162911Ssimon/* ==================================================================== 3162911Ssimon * Copyright (c) 2006 The OpenSSL Project. All rights reserved. 4162911Ssimon * 5162911Ssimon * Redistribution and use in source and binary forms, with or without 6162911Ssimon * modification, are permitted provided that the following conditions 7162911Ssimon * are met: 8162911Ssimon * 9162911Ssimon * 1. Redistributions of source code must retain the above copyright 10280297Sjkim * notice, this list of conditions and the following disclaimer. 11162911Ssimon * 12162911Ssimon * 2. Redistributions in binary form must reproduce the above copyright 13162911Ssimon * notice, this list of conditions and the following disclaimer in 14162911Ssimon * the documentation and/or other materials provided with the 15162911Ssimon * distribution. 16162911Ssimon * 17162911Ssimon * 3. All advertising materials mentioning features or use of this 18162911Ssimon * software must display the following acknowledgment: 19162911Ssimon * "This product includes software developed by the OpenSSL Project 20162911Ssimon * for use in the OpenSSL Toolkit. (http://www.openssl.org/)" 21162911Ssimon * 22162911Ssimon * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to 23162911Ssimon * endorse or promote products derived from this software without 24162911Ssimon * prior written permission. For written permission, please contact 25162911Ssimon * openssl-core@openssl.org. 26162911Ssimon * 27162911Ssimon * 5. Products derived from this software may not be called "OpenSSL" 28162911Ssimon * nor may "OpenSSL" appear in their names without prior written 29162911Ssimon * permission of the OpenSSL Project. 30162911Ssimon * 31162911Ssimon * 6. Redistributions of any form whatsoever must retain the following 32162911Ssimon * acknowledgment: 33162911Ssimon * "This product includes software developed by the OpenSSL Project 34162911Ssimon * for use in the OpenSSL Toolkit (http://www.openssl.org/)" 35162911Ssimon * 36162911Ssimon * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY 37162911Ssimon * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 38162911Ssimon * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 39162911Ssimon * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR 40162911Ssimon * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 41162911Ssimon * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 42162911Ssimon * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 43162911Ssimon * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 44162911Ssimon * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 45162911Ssimon * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 46162911Ssimon * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 47162911Ssimon * OF THE POSSIBILITY OF SUCH DAMAGE. 48162911Ssimon * ==================================================================== 49162911Ssimon * 50162911Ssimon * This product includes cryptographic software written by Eric Young 51162911Ssimon * (eay@cryptsoft.com). This product includes software written by Tim 52162911Ssimon * Hudson (tjh@cryptsoft.com). 53162911Ssimon * 54162911Ssimon */ 55162911Ssimon 56162911Ssimon#include <openssl/opensslconf.h> 57162911Ssimon#ifndef OPENSSL_NO_CAMELLIA 58280297Sjkim# include <openssl/evp.h> 59280297Sjkim# include <openssl/err.h> 60280297Sjkim# include <string.h> 61280297Sjkim# include <assert.h> 62280297Sjkim# include <openssl/camellia.h> 63280297Sjkim# include "evp_locl.h" 64290207Sjkim# include "modes_lcl.h" 65162911Ssimon 66162911Ssimonstatic int camellia_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key, 67280297Sjkim const unsigned char *iv, int enc); 68162911Ssimon 69162911Ssimon/* Camellia subkey Structure */ 70280297Sjkimtypedef struct { 71280297Sjkim CAMELLIA_KEY ks; 72290207Sjkim block128_f block; 73290207Sjkim union { 74290207Sjkim cbc128_f cbc; 75290207Sjkim ctr128_f ctr; 76290207Sjkim } stream; 77280297Sjkim} EVP_CAMELLIA_KEY; 78162911Ssimon 79290207Sjkim# define MAXBITCHUNK ((size_t)1<<(sizeof(size_t)*8-4)) 80290207Sjkim 81162911Ssimon/* Attribute operation for Camellia */ 82280297Sjkim# define data(ctx) EVP_C_DATA(EVP_CAMELLIA_KEY,ctx) 83162911Ssimon 84290207Sjkim# if defined(AES_ASM) && (defined(__sparc) || defined(__sparc__)) 85290207Sjkim/* ---------^^^ this is not a typo, just a way to detect that 86290207Sjkim * assembler support was in general requested... */ 87290207Sjkim# include "sparc_arch.h" 88162911Ssimon 89290207Sjkimextern unsigned int OPENSSL_sparcv9cap_P[]; 90162911Ssimon 91290207Sjkim# define SPARC_CMLL_CAPABLE (OPENSSL_sparcv9cap_P[1] & CFR_CAMELLIA) 92290207Sjkim 93290207Sjkimvoid cmll_t4_set_key(const unsigned char *key, int bits, CAMELLIA_KEY *ks); 94290207Sjkimvoid cmll_t4_encrypt(const unsigned char *in, unsigned char *out, 95290207Sjkim const CAMELLIA_KEY *key); 96290207Sjkimvoid cmll_t4_decrypt(const unsigned char *in, unsigned char *out, 97290207Sjkim const CAMELLIA_KEY *key); 98290207Sjkim 99290207Sjkimvoid cmll128_t4_cbc_encrypt(const unsigned char *in, unsigned char *out, 100290207Sjkim size_t len, const CAMELLIA_KEY *key, 101290207Sjkim unsigned char *ivec); 102290207Sjkimvoid cmll128_t4_cbc_decrypt(const unsigned char *in, unsigned char *out, 103290207Sjkim size_t len, const CAMELLIA_KEY *key, 104290207Sjkim unsigned char *ivec); 105290207Sjkimvoid cmll256_t4_cbc_encrypt(const unsigned char *in, unsigned char *out, 106290207Sjkim size_t len, const CAMELLIA_KEY *key, 107290207Sjkim unsigned char *ivec); 108290207Sjkimvoid cmll256_t4_cbc_decrypt(const unsigned char *in, unsigned char *out, 109290207Sjkim size_t len, const CAMELLIA_KEY *key, 110290207Sjkim unsigned char *ivec); 111290207Sjkimvoid cmll128_t4_ctr32_encrypt(const unsigned char *in, unsigned char *out, 112290207Sjkim size_t blocks, const CAMELLIA_KEY *key, 113290207Sjkim unsigned char *ivec); 114290207Sjkimvoid cmll256_t4_ctr32_encrypt(const unsigned char *in, unsigned char *out, 115290207Sjkim size_t blocks, const CAMELLIA_KEY *key, 116290207Sjkim unsigned char *ivec); 117290207Sjkim 118290207Sjkimstatic int cmll_t4_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key, 119290207Sjkim const unsigned char *iv, int enc) 120290207Sjkim{ 121290207Sjkim int ret, mode, bits; 122290207Sjkim EVP_CAMELLIA_KEY *dat = (EVP_CAMELLIA_KEY *) ctx->cipher_data; 123290207Sjkim 124290207Sjkim mode = ctx->cipher->flags & EVP_CIPH_MODE; 125290207Sjkim bits = ctx->key_len * 8; 126290207Sjkim 127290207Sjkim cmll_t4_set_key(key, bits, &dat->ks); 128290207Sjkim 129290207Sjkim if ((mode == EVP_CIPH_ECB_MODE || mode == EVP_CIPH_CBC_MODE) 130290207Sjkim && !enc) { 131290207Sjkim ret = 0; 132290207Sjkim dat->block = (block128_f) cmll_t4_decrypt; 133290207Sjkim switch (bits) { 134290207Sjkim case 128: 135290207Sjkim dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ? 136290207Sjkim (cbc128_f) cmll128_t4_cbc_decrypt : NULL; 137290207Sjkim break; 138290207Sjkim case 192: 139290207Sjkim case 256: 140290207Sjkim dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ? 141290207Sjkim (cbc128_f) cmll256_t4_cbc_decrypt : NULL; 142290207Sjkim break; 143290207Sjkim default: 144290207Sjkim ret = -1; 145290207Sjkim } 146290207Sjkim } else { 147290207Sjkim ret = 0; 148290207Sjkim dat->block = (block128_f) cmll_t4_encrypt; 149290207Sjkim switch (bits) { 150290207Sjkim case 128: 151290207Sjkim if (mode == EVP_CIPH_CBC_MODE) 152290207Sjkim dat->stream.cbc = (cbc128_f) cmll128_t4_cbc_encrypt; 153290207Sjkim else if (mode == EVP_CIPH_CTR_MODE) 154290207Sjkim dat->stream.ctr = (ctr128_f) cmll128_t4_ctr32_encrypt; 155290207Sjkim else 156290207Sjkim dat->stream.cbc = NULL; 157290207Sjkim break; 158290207Sjkim case 192: 159290207Sjkim case 256: 160290207Sjkim if (mode == EVP_CIPH_CBC_MODE) 161290207Sjkim dat->stream.cbc = (cbc128_f) cmll256_t4_cbc_encrypt; 162290207Sjkim else if (mode == EVP_CIPH_CTR_MODE) 163290207Sjkim dat->stream.ctr = (ctr128_f) cmll256_t4_ctr32_encrypt; 164290207Sjkim else 165290207Sjkim dat->stream.cbc = NULL; 166290207Sjkim break; 167290207Sjkim default: 168290207Sjkim ret = -1; 169290207Sjkim } 170290207Sjkim } 171290207Sjkim 172290207Sjkim if (ret < 0) { 173290207Sjkim EVPerr(EVP_F_CMLL_T4_INIT_KEY, EVP_R_CAMELLIA_KEY_SETUP_FAILED); 174290207Sjkim return 0; 175290207Sjkim } 176290207Sjkim 177290207Sjkim return 1; 178290207Sjkim} 179290207Sjkim 180290207Sjkim# define cmll_t4_cbc_cipher camellia_cbc_cipher 181290207Sjkimstatic int cmll_t4_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, 182290207Sjkim const unsigned char *in, size_t len); 183290207Sjkim 184290207Sjkim# define cmll_t4_ecb_cipher camellia_ecb_cipher 185290207Sjkimstatic int cmll_t4_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, 186290207Sjkim const unsigned char *in, size_t len); 187290207Sjkim 188290207Sjkim# define cmll_t4_ofb_cipher camellia_ofb_cipher 189290207Sjkimstatic int cmll_t4_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, 190290207Sjkim const unsigned char *in, size_t len); 191290207Sjkim 192290207Sjkim# define cmll_t4_cfb_cipher camellia_cfb_cipher 193290207Sjkimstatic int cmll_t4_cfb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, 194290207Sjkim const unsigned char *in, size_t len); 195290207Sjkim 196290207Sjkim# define cmll_t4_cfb8_cipher camellia_cfb8_cipher 197290207Sjkimstatic int cmll_t4_cfb8_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, 198290207Sjkim const unsigned char *in, size_t len); 199290207Sjkim 200290207Sjkim# define cmll_t4_cfb1_cipher camellia_cfb1_cipher 201290207Sjkimstatic int cmll_t4_cfb1_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, 202290207Sjkim const unsigned char *in, size_t len); 203290207Sjkim 204290207Sjkim# define cmll_t4_ctr_cipher camellia_ctr_cipher 205290207Sjkimstatic int cmll_t4_ctr_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, 206290207Sjkim const unsigned char *in, size_t len); 207290207Sjkim 208290207Sjkim# define BLOCK_CIPHER_generic(nid,keylen,blocksize,ivlen,nmode,mode,MODE,flags) \ 209290207Sjkimstatic const EVP_CIPHER cmll_t4_##keylen##_##mode = { \ 210290207Sjkim nid##_##keylen##_##nmode,blocksize,keylen/8,ivlen, \ 211290207Sjkim flags|EVP_CIPH_##MODE##_MODE, \ 212290207Sjkim cmll_t4_init_key, \ 213290207Sjkim cmll_t4_##mode##_cipher, \ 214290207Sjkim NULL, \ 215290207Sjkim sizeof(EVP_CAMELLIA_KEY), \ 216290207Sjkim NULL,NULL,NULL,NULL }; \ 217290207Sjkimstatic const EVP_CIPHER camellia_##keylen##_##mode = { \ 218290207Sjkim nid##_##keylen##_##nmode,blocksize, \ 219290207Sjkim keylen/8,ivlen, \ 220290207Sjkim flags|EVP_CIPH_##MODE##_MODE, \ 221290207Sjkim camellia_init_key, \ 222290207Sjkim camellia_##mode##_cipher, \ 223290207Sjkim NULL, \ 224290207Sjkim sizeof(EVP_CAMELLIA_KEY), \ 225290207Sjkim NULL,NULL,NULL,NULL }; \ 226290207Sjkimconst EVP_CIPHER *EVP_camellia_##keylen##_##mode(void) \ 227290207Sjkim{ return SPARC_CMLL_CAPABLE?&cmll_t4_##keylen##_##mode:&camellia_##keylen##_##mode; } 228290207Sjkim 229290207Sjkim# else 230290207Sjkim 231290207Sjkim# define BLOCK_CIPHER_generic(nid,keylen,blocksize,ivlen,nmode,mode,MODE,flags) \ 232290207Sjkimstatic const EVP_CIPHER camellia_##keylen##_##mode = { \ 233290207Sjkim nid##_##keylen##_##nmode,blocksize,keylen/8,ivlen, \ 234290207Sjkim flags|EVP_CIPH_##MODE##_MODE, \ 235290207Sjkim camellia_init_key, \ 236290207Sjkim camellia_##mode##_cipher, \ 237290207Sjkim NULL, \ 238290207Sjkim sizeof(EVP_CAMELLIA_KEY), \ 239290207Sjkim NULL,NULL,NULL,NULL }; \ 240290207Sjkimconst EVP_CIPHER *EVP_camellia_##keylen##_##mode(void) \ 241290207Sjkim{ return &camellia_##keylen##_##mode; } 242290207Sjkim 243290207Sjkim# endif 244290207Sjkim 245290207Sjkim# define BLOCK_CIPHER_generic_pack(nid,keylen,flags) \ 246290207Sjkim BLOCK_CIPHER_generic(nid,keylen,16,16,cbc,cbc,CBC,flags|EVP_CIPH_FLAG_DEFAULT_ASN1) \ 247290207Sjkim BLOCK_CIPHER_generic(nid,keylen,16,0,ecb,ecb,ECB,flags|EVP_CIPH_FLAG_DEFAULT_ASN1) \ 248290207Sjkim BLOCK_CIPHER_generic(nid,keylen,1,16,ofb128,ofb,OFB,flags|EVP_CIPH_FLAG_DEFAULT_ASN1) \ 249290207Sjkim BLOCK_CIPHER_generic(nid,keylen,1,16,cfb128,cfb,CFB,flags|EVP_CIPH_FLAG_DEFAULT_ASN1) \ 250290207Sjkim BLOCK_CIPHER_generic(nid,keylen,1,16,cfb1,cfb1,CFB,flags) \ 251290207Sjkim BLOCK_CIPHER_generic(nid,keylen,1,16,cfb8,cfb8,CFB,flags) 252290207Sjkim# if 0 /* not yet, missing NID */ 253290207SjkimBLOCK_CIPHER_generic(nid, keylen, 1, 16, ctr, ctr, CTR, flags) 254290207Sjkim# endif 255280297Sjkim/* The subkey for Camellia is generated. */ 256162911Ssimonstatic int camellia_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key, 257280297Sjkim const unsigned char *iv, int enc) 258280297Sjkim{ 259290207Sjkim int ret, mode; 260290207Sjkim EVP_CAMELLIA_KEY *dat = (EVP_CAMELLIA_KEY *) ctx->cipher_data; 261162911Ssimon 262290207Sjkim ret = Camellia_set_key(key, ctx->key_len * 8, &dat->ks); 263280297Sjkim if (ret < 0) { 264280297Sjkim EVPerr(EVP_F_CAMELLIA_INIT_KEY, EVP_R_CAMELLIA_KEY_SETUP_FAILED); 265280297Sjkim return 0; 266280297Sjkim } 267162911Ssimon 268290207Sjkim mode = ctx->cipher->flags & EVP_CIPH_MODE; 269290207Sjkim if ((mode == EVP_CIPH_ECB_MODE || mode == EVP_CIPH_CBC_MODE) 270290207Sjkim && !enc) { 271290207Sjkim dat->block = (block128_f) Camellia_decrypt; 272290207Sjkim dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ? 273290207Sjkim (cbc128_f) Camellia_cbc_encrypt : NULL; 274290207Sjkim } else { 275290207Sjkim dat->block = (block128_f) Camellia_encrypt; 276290207Sjkim dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ? 277290207Sjkim (cbc128_f) Camellia_cbc_encrypt : NULL; 278290207Sjkim } 279290207Sjkim 280280297Sjkim return 1; 281280297Sjkim} 282162911Ssimon 283290207Sjkimstatic int camellia_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, 284290207Sjkim const unsigned char *in, size_t len) 285290207Sjkim{ 286290207Sjkim EVP_CAMELLIA_KEY *dat = (EVP_CAMELLIA_KEY *) ctx->cipher_data; 287290207Sjkim 288290207Sjkim if (dat->stream.cbc) 289290207Sjkim (*dat->stream.cbc) (in, out, len, &dat->ks, ctx->iv, ctx->encrypt); 290290207Sjkim else if (ctx->encrypt) 291290207Sjkim CRYPTO_cbc128_encrypt(in, out, len, &dat->ks, ctx->iv, dat->block); 292290207Sjkim else 293290207Sjkim CRYPTO_cbc128_decrypt(in, out, len, &dat->ks, ctx->iv, dat->block); 294290207Sjkim 295290207Sjkim return 1; 296290207Sjkim} 297290207Sjkim 298290207Sjkimstatic int camellia_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, 299290207Sjkim const unsigned char *in, size_t len) 300290207Sjkim{ 301290207Sjkim size_t bl = ctx->cipher->block_size; 302290207Sjkim size_t i; 303290207Sjkim EVP_CAMELLIA_KEY *dat = (EVP_CAMELLIA_KEY *) ctx->cipher_data; 304290207Sjkim 305290207Sjkim if (len < bl) 306290207Sjkim return 1; 307290207Sjkim 308290207Sjkim for (i = 0, len -= bl; i <= len; i += bl) 309290207Sjkim (*dat->block) (in + i, out + i, &dat->ks); 310290207Sjkim 311290207Sjkim return 1; 312290207Sjkim} 313290207Sjkim 314290207Sjkimstatic int camellia_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, 315290207Sjkim const unsigned char *in, size_t len) 316290207Sjkim{ 317290207Sjkim EVP_CAMELLIA_KEY *dat = (EVP_CAMELLIA_KEY *) ctx->cipher_data; 318290207Sjkim 319290207Sjkim CRYPTO_ofb128_encrypt(in, out, len, &dat->ks, 320290207Sjkim ctx->iv, &ctx->num, dat->block); 321290207Sjkim return 1; 322290207Sjkim} 323290207Sjkim 324290207Sjkimstatic int camellia_cfb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, 325290207Sjkim const unsigned char *in, size_t len) 326290207Sjkim{ 327290207Sjkim EVP_CAMELLIA_KEY *dat = (EVP_CAMELLIA_KEY *) ctx->cipher_data; 328290207Sjkim 329290207Sjkim CRYPTO_cfb128_encrypt(in, out, len, &dat->ks, 330290207Sjkim ctx->iv, &ctx->num, ctx->encrypt, dat->block); 331290207Sjkim return 1; 332290207Sjkim} 333290207Sjkim 334290207Sjkimstatic int camellia_cfb8_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, 335290207Sjkim const unsigned char *in, size_t len) 336290207Sjkim{ 337290207Sjkim EVP_CAMELLIA_KEY *dat = (EVP_CAMELLIA_KEY *) ctx->cipher_data; 338290207Sjkim 339290207Sjkim CRYPTO_cfb128_8_encrypt(in, out, len, &dat->ks, 340290207Sjkim ctx->iv, &ctx->num, ctx->encrypt, dat->block); 341290207Sjkim return 1; 342290207Sjkim} 343290207Sjkim 344290207Sjkimstatic int camellia_cfb1_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, 345290207Sjkim const unsigned char *in, size_t len) 346290207Sjkim{ 347290207Sjkim EVP_CAMELLIA_KEY *dat = (EVP_CAMELLIA_KEY *) ctx->cipher_data; 348290207Sjkim 349290207Sjkim if (ctx->flags & EVP_CIPH_FLAG_LENGTH_BITS) { 350290207Sjkim CRYPTO_cfb128_1_encrypt(in, out, len, &dat->ks, 351290207Sjkim ctx->iv, &ctx->num, ctx->encrypt, dat->block); 352290207Sjkim return 1; 353290207Sjkim } 354290207Sjkim 355290207Sjkim while (len >= MAXBITCHUNK) { 356290207Sjkim CRYPTO_cfb128_1_encrypt(in, out, MAXBITCHUNK * 8, &dat->ks, 357290207Sjkim ctx->iv, &ctx->num, ctx->encrypt, dat->block); 358290207Sjkim len -= MAXBITCHUNK; 359290207Sjkim } 360290207Sjkim if (len) 361290207Sjkim CRYPTO_cfb128_1_encrypt(in, out, len * 8, &dat->ks, 362290207Sjkim ctx->iv, &ctx->num, ctx->encrypt, dat->block); 363290207Sjkim 364290207Sjkim return 1; 365290207Sjkim} 366290207Sjkim 367290207Sjkim# if 0 /* not yet, missing NID */ 368290207Sjkimstatic int camellia_ctr_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out, 369290207Sjkim const unsigned char *in, size_t len) 370290207Sjkim{ 371290207Sjkim unsigned int num = ctx->num; 372290207Sjkim EVP_CAMELLIA_KEY *dat = (EVP_CAMELLIA_KEY *) ctx->cipher_data; 373290207Sjkim 374290207Sjkim if (dat->stream.ctr) 375290207Sjkim CRYPTO_ctr128_encrypt_ctr32(in, out, len, &dat->ks, 376290207Sjkim ctx->iv, ctx->buf, &num, dat->stream.ctr); 377290207Sjkim else 378290207Sjkim CRYPTO_ctr128_encrypt(in, out, len, &dat->ks, 379290207Sjkim ctx->iv, ctx->buf, &num, dat->block); 380290207Sjkim ctx->num = (size_t)num; 381290207Sjkim return 1; 382290207Sjkim} 383290207Sjkim# endif 384290207Sjkim 385290207SjkimBLOCK_CIPHER_generic_pack(NID_camellia, 128, 0) 386290207Sjkim BLOCK_CIPHER_generic_pack(NID_camellia, 192, 0) 387290207Sjkim BLOCK_CIPHER_generic_pack(NID_camellia, 256, 0) 388162911Ssimon#else 389162911Ssimon 390162911Ssimon# ifdef PEDANTIC 391280297Sjkimstatic void *dummy = &dummy; 392162911Ssimon# endif 393162911Ssimon 394162911Ssimon#endif 395