static int sm4_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
const unsigned char *iv, int enc)
{
- SM4_set_key(key, EVP_CIPHER_CTX_get_cipher_data(ctx));
+ ossl_sm4_set_key(key, EVP_CIPHER_CTX_get_cipher_data(ctx));
return 1;
}
{
if (enc)
CRYPTO_cbc128_encrypt(in, out, len, key, ivec,
- (block128_f)SM4_encrypt);
+ (block128_f)ossl_sm4_encrypt);
else
CRYPTO_cbc128_decrypt(in, out, len, key, ivec,
- (block128_f)SM4_decrypt);
+ (block128_f)ossl_sm4_decrypt);
}
static void sm4_cfb128_encrypt(const unsigned char *in, unsigned char *out,
unsigned char *ivec, int *num, const int enc)
{
CRYPTO_cfb128_encrypt(in, out, length, key, ivec, num, enc,
- (block128_f)SM4_encrypt);
+ (block128_f)ossl_sm4_encrypt);
}
static void sm4_ecb_encrypt(const unsigned char *in, unsigned char *out,
const SM4_KEY *key, const int enc)
{
if (enc)
- SM4_encrypt(in, out, key);
+ ossl_sm4_encrypt(in, out, key);
else
- SM4_decrypt(in, out, key);
+ ossl_sm4_decrypt(in, out, key);
}
static void sm4_ofb128_encrypt(const unsigned char *in, unsigned char *out,
unsigned char *ivec, int *num)
{
CRYPTO_ofb128_encrypt(in, out, length, key, ivec, num,
- (block128_f)SM4_encrypt);
+ (block128_f)ossl_sm4_encrypt);
}
IMPLEMENT_BLOCK_CIPHER(sm4, ks, sm4, EVP_SM4_KEY, NID_sm4,
CRYPTO_ctr128_encrypt(in, out, len, &dat->ks, ctx->iv,
EVP_CIPHER_CTX_buf_noconst(ctx), &num,
- (block128_f)SM4_encrypt);
+ (block128_f)ossl_sm4_encrypt);
EVP_CIPHER_CTX_set_num(ctx, num);
return 1;
}
#include "../evp/legacy_meth.h"
#include "internal/sm3.h"
-IMPLEMENT_LEGACY_EVP_MD_METH_LC(sm3_int, sm3)
+IMPLEMENT_LEGACY_EVP_MD_METH_LC(sm3_int, ossl_sm3)
static const EVP_MD sm3_md = {
NID_sm3,
#include <openssl/e_os2.h>
#include "sm3_local.h"
-int sm3_init(SM3_CTX *c)
+int ossl_sm3_init(SM3_CTX *c)
{
memset(c, 0, sizeof(*c));
c->A = SM3_A;
return 1;
}
-void sm3_block_data_order(SM3_CTX *ctx, const void *p, size_t num)
+void ossl_sm3_block_data_order(SM3_CTX *ctx, const void *p, size_t num)
{
const unsigned char *data = p;
register unsigned MD32_REG_T A, B, C, D, E, F, G, H;
ctx->H ^= H;
}
}
-
#define HASH_LONG SM3_WORD
#define HASH_CTX SM3_CTX
#define HASH_CBLOCK SM3_CBLOCK
-#define HASH_UPDATE sm3_update
-#define HASH_TRANSFORM sm3_transform
-#define HASH_FINAL sm3_final
+#define HASH_UPDATE ossl_sm3_update
+#define HASH_TRANSFORM ossl_sm3_transform
+#define HASH_FINAL ossl_sm3_final
#define HASH_MAKE_STRING(c, s) \
do { \
unsigned long ll; \
ll=(c)->G; (void)HOST_l2c(ll, (s)); \
ll=(c)->H; (void)HOST_l2c(ll, (s)); \
} while (0)
-#define HASH_BLOCK_DATA_ORDER sm3_block_data_order
+#define HASH_BLOCK_DATA_ORDER ossl_sm3_block_data_order
-void sm3_block_data_order(SM3_CTX *c, const void *p, size_t num);
-void sm3_transform(SM3_CTX *c, const unsigned char *data);
+void ossl_sm3_block_data_order(SM3_CTX *c, const void *p, size_t num);
+void ossl_sm3_transform(SM3_CTX *c, const unsigned char *data);
#include "crypto/md32_common.h"
rotl(SM4_SBOX_T[(uint8_t)X], 8);
}
-int SM4_set_key(const uint8_t *key, SM4_KEY *ks)
+int ossl_sm4_set_key(const uint8_t *key, SM4_KEY *ks)
{
/*
* Family Key
B3 ^= F(B0 ^ B1 ^ B2 ^ ks->rk[k3]); \
} while(0)
-void SM4_encrypt(const uint8_t *in, uint8_t *out, const SM4_KEY *ks)
+void ossl_sm4_encrypt(const uint8_t *in, uint8_t *out, const SM4_KEY *ks)
{
uint32_t B0 = load_u32_be(in, 0);
uint32_t B1 = load_u32_be(in, 1);
store_u32_be(B0, out + 12);
}
-void SM4_decrypt(const uint8_t *in, uint8_t *out, const SM4_KEY *ks)
+void ossl_sm4_decrypt(const uint8_t *in, uint8_t *out, const SM4_KEY *ks)
{
uint32_t B0 = load_u32_be(in, 0);
uint32_t B1 = load_u32_be(in, 1);
uint32_t rk[SM4_KEY_SCHEDULE];
} SM4_KEY;
-int SM4_set_key(const uint8_t *key, SM4_KEY *ks);
+int ossl_sm4_set_key(const uint8_t *key, SM4_KEY *ks);
-void SM4_encrypt(const uint8_t *in, uint8_t *out, const SM4_KEY *ks);
+void ossl_sm4_encrypt(const uint8_t *in, uint8_t *out, const SM4_KEY *ks);
-void SM4_decrypt(const uint8_t *in, uint8_t *out, const SM4_KEY *ks);
+void ossl_sm4_decrypt(const uint8_t *in, uint8_t *out, const SM4_KEY *ks);
#endif
unsigned int num;
} SM3_CTX;
-int sm3_init(SM3_CTX *c);
-int sm3_update(SM3_CTX *c, const void *data, size_t len);
-int sm3_final(unsigned char *md, SM3_CTX *c);
+int ossl_sm3_init(SM3_CTX *c);
+int ossl_sm3_update(SM3_CTX *c, const void *data, size_t len);
+int ossl_sm3_final(unsigned char *md, SM3_CTX *c);
#endif /* OSSL_INTERNAL_SM3_H */
PROV_SM4_CTX *sctx = (PROV_SM4_CTX *)ctx;
SM4_KEY *ks = &sctx->ks.ks;
- SM4_set_key(key, ks);
+ ossl_sm4_set_key(key, ks);
ctx->ks = ks;
if (ctx->enc
|| (ctx->mode != EVP_CIPH_ECB_MODE
&& ctx->mode != EVP_CIPH_CBC_MODE))
- ctx->block = (block128_f)SM4_encrypt;
+ ctx->block = (block128_f)ossl_sm4_encrypt;
else
- ctx->block = (block128_f)SM4_decrypt;
+ ctx->block = (block128_f)ossl_sm4_decrypt;
return 1;
}
/* ossl_sm3_functions */
IMPLEMENT_digest_functions(sm3, SM3_CTX,
SM3_CBLOCK, SM3_DIGEST_LENGTH, 0,
- sm3_init, sm3_update, sm3_final)
+ ossl_sm3_init, ossl_sm3_update, ossl_sm3_final)
SM4_KEY key;
uint8_t block[SM4_BLOCK_SIZE];
- SM4_set_key(k, &key);
+ ossl_sm4_set_key(k, &key);
memcpy(block, input, SM4_BLOCK_SIZE);
- SM4_encrypt(block, block, &key);
+ ossl_sm4_encrypt(block, block, &key);
if (!TEST_mem_eq(block, SM4_BLOCK_SIZE, expected, SM4_BLOCK_SIZE))
return 0;
for (i = 0; i != 999999; ++i)
- SM4_encrypt(block, block, &key);
+ ossl_sm4_encrypt(block, block, &key);
if (!TEST_mem_eq(block, SM4_BLOCK_SIZE, expected_iter, SM4_BLOCK_SIZE))
return 0;
for (i = 0; i != 1000000; ++i)
- SM4_decrypt(block, block, &key);
+ ossl_sm4_decrypt(block, block, &key);
if (!TEST_mem_eq(block, SM4_BLOCK_SIZE, input, SM4_BLOCK_SIZE))
return 0;