Skip to content

Cygwin fix for SM4 (issue #663) #664

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Sep 2, 2024
Merged

Cygwin fix for SM4 (issue #663) #664

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
66 changes: 34 additions & 32 deletions src/ciphers/sm4.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -28,7 +28,7 @@ typedef ulong32 sm4_u32_t;
* S-box defined in section 6.2
* (1) Nonlinear transformation
*/
static const sm4_u8_t sbox_table[16][16] = {
static const sm4_u8_t sm4_sbox_table[16][16] = {
{0xd6, 0x90, 0xe9, 0xfe, 0xcc, 0xe1, 0x3d, 0xb7,
0x16, 0xb6, 0x14, 0xc2, 0x28, 0xfb, 0x2c, 0x05},
{0x2b, 0x67, 0x9a, 0x76, 0x2a, 0xbe, 0x04, 0xc3,
Expand Down Expand Up @@ -67,9 +67,9 @@ static const sm4_u8_t sbox_table[16][16] = {
* S-box
* defined in section 2.6 S-box
*/
LTC_INLINE static sm4_u8_t sbox(sm4_u8_t a)
LTC_INLINE static sm4_u8_t s_sm4_sbox(sm4_u8_t a)
{
return sbox_table[(a >> 4) & 0x0f][a & 0x0f];
return sm4_sbox_table[(a >> 4) & 0x0f][a & 0x0f];
}

/*
Expand All @@ -80,49 +80,49 @@ LTC_INLINE static sm4_u8_t sbox(sm4_u8_t a)
* But we just convert a 32bit word byte by byte.
* So it's OK if we don't convert the endian order
*/
LTC_INLINE static sm4_u32_t t(sm4_u32_t A)
LTC_INLINE static sm4_u32_t s_sm4_t(sm4_u32_t A)
{
sm4_u8_t a[4];
sm4_u8_t b[4];
sm4_u32_t B;

STORE32H(A, a);
b[0] = sbox(a[0]);
b[1] = sbox(a[1]);
b[2] = sbox(a[2]);
b[3] = sbox(a[3]);
b[0] = s_sm4_sbox(a[0]);
b[1] = s_sm4_sbox(a[1]);
b[2] = s_sm4_sbox(a[2]);
b[3] = s_sm4_sbox(a[3]);
LOAD32H(B, b);
return B;
}

/*
* defined in section 6.2 (2) Linear transformation L
*/
LTC_INLINE static sm4_u32_t L(sm4_u32_t B)
LTC_INLINE static sm4_u32_t s_sm4_L62(sm4_u32_t B)
{
return B ^ ROLc(B, 2) ^ ROLc(B, 10) ^ ROLc(B, 18) ^ ROLc(B, 24);
}

/*
* defined in section 6.2 Permutation T
*/
LTC_INLINE static sm4_u32_t T(sm4_u32_t Z)
LTC_INLINE static sm4_u32_t s_sm4_T62(sm4_u32_t Z)
{
return L(t(Z));
return s_sm4_L62(s_sm4_t(Z));
}

/*
* defined in section 7.3 (2) The system parameter FK
*/
static const sm4_u32_t FK[4] = {
static const sm4_u32_t sm4_FK[4] = {
0xa3b1bac6, 0x56aa3350, 0x677d9197, 0xb27022dc
};

/*
* defined in section 7.3 (3) The fixed parameter CK
* The fixed parameter CK is used in the key expansion algorithm
*/
static const sm4_u32_t CK[32] =
static const sm4_u32_t sm4_CK[32] =
{
0x00070e15, 0x1c232a31, 0x383f464d, 0x545b6269,
0x70777e85, 0x8c939aa1, 0xa8afb6bd, 0xc4cbd2d9,
Expand All @@ -137,23 +137,23 @@ static const sm4_u32_t CK[32] =
/*
* defined in section 7.3 (1) L'
*/
LTC_INLINE static sm4_u32_t _L(sm4_u32_t B)
LTC_INLINE static sm4_u32_t s_sm4_L73(sm4_u32_t B)
{
return B ^ ROLc(B, 13) ^ ROLc(B, 23);
}

/*
* defined in section 7.3 (1) T'
*/
LTC_INLINE static sm4_u32_t _T(sm4_u32_t Z)
LTC_INLINE static sm4_u32_t s_sm4_T73(sm4_u32_t Z)
{
return _L(t(Z));
return s_sm4_L73(s_sm4_t(Z));
}

/*
* defined in section 7.3 Key Expansion
*/
LTC_INLINE static void mk2rk(sm4_u32_t rk[32], sm4_u8_t mk[16])
LTC_INLINE static void s_sm4_mk2rk(sm4_u32_t rk[32], sm4_u8_t mk[16])
{
sm4_u32_t MK[4] = { 0 };
sm4_u32_t K[4+32] = { 0 };
Expand All @@ -165,25 +165,25 @@ LTC_INLINE static void mk2rk(sm4_u32_t rk[32], sm4_u8_t mk[16])
LOAD32H(MK[3], mk + 12);

for (i = 0; i < 4; ++i)
K[i] = MK[i] ^ FK[i];
K[i] = MK[i] ^ sm4_FK[i];
for (i = 0; i < 32; ++i)
K[i+4] = K[i] ^ _T(K[i+1] ^ K[i+2] ^ K[i+3] ^ CK[i]);
K[i+4] = K[i] ^ s_sm4_T73(K[i+1] ^ K[i+2] ^ K[i+3] ^ sm4_CK[i]);
for (i = 0; i < 32; ++i)
rk[i] = K[i+4];
}

/*
* defined in section 6 Round Function F
*/
LTC_INLINE static sm4_u32_t F(sm4_u32_t X[4], sm4_u32_t rk)
LTC_INLINE static sm4_u32_t s_sm4_F(sm4_u32_t X[4], sm4_u32_t rk)
{
return X[0] ^ T(X[1] ^ X[2] ^ X[3] ^ rk);
return X[0] ^ s_sm4_T62(X[1] ^ X[2] ^ X[3] ^ rk);
}

/*
* defined in section 7.1 (2) The reverse transformation
*/
LTC_INLINE static void R(sm4_u32_t Y[4], sm4_u32_t X[32+4])
LTC_INLINE static void s_sm4_R(sm4_u32_t Y[4], sm4_u32_t X[32+4])
{
Y[0] = X[35];
Y[1] = X[34];
Expand All @@ -194,20 +194,20 @@ LTC_INLINE static void R(sm4_u32_t Y[4], sm4_u32_t X[32+4])
/*
* defined in section 7.1 (En)cryption
*/
LTC_INLINE static void sm4_crypt(sm4_u32_t Y[4], sm4_u32_t X[4+32], const sm4_u32_t rk[32])
LTC_INLINE static void s_sm4_crypt(sm4_u32_t Y[4], sm4_u32_t X[4+32], const sm4_u32_t rk[32])
{
int i;

for (i = 0; i < 32; ++i)
X[i+4] = F(X+i, rk[i]);
R(Y, X);
X[i+4] = s_sm4_F(X+i, rk[i]);
s_sm4_R(Y, X);
}

LTC_INLINE static void sm4_setkey(struct sm4_key *sm4, const unsigned char *key)
LTC_INLINE static void s_sm4_setkey(struct sm4_key *sm4, const unsigned char *key)
{
int i;

mk2rk(sm4->ek,(void*)key);
s_sm4_mk2rk(sm4->ek,(void*)key);
/*swap key sequence when decrypt cipher*/
for (i = 0; i < 32; ++i)
sm4->dk[i] = sm4->ek[32 - 1 - i];
Expand All @@ -222,14 +222,14 @@ int sm4_setup(const unsigned char *key, int keylen,
return CRYPT_INVALID_ROUNDS;
if (keylen != 16)
return CRYPT_INVALID_KEYSIZE;
sm4_setkey(&(skey->sm4), key);
s_sm4_setkey(&(skey->sm4), key);
return CRYPT_OK;
}

/*
* SM4 encryption.
*/
LTC_INLINE static void sm4_do(void *output, const void *input, const sm4_u32_t rk[32])
LTC_INLINE static void s_sm4_do(void *output, const void *input, const sm4_u32_t rk[32])
{
sm4_u32_t Y[4];
sm4_u32_t X[32+4];
Expand All @@ -239,7 +239,7 @@ LTC_INLINE static void sm4_do(void *output, const void *input, const sm4_u32_t r
LOAD32H(X[2], (sm4_u8_t *)input + 8);
LOAD32H(X[3], (sm4_u8_t *)input + 12);

sm4_crypt(Y, X, rk);
s_sm4_crypt(Y, X, rk);

STORE32H(Y[0], (sm4_u8_t *)output );
STORE32H(Y[1], (sm4_u8_t *)output + 4);
Expand All @@ -253,7 +253,7 @@ int sm4_ecb_encrypt(const unsigned char *pt, unsigned char *ct,
LTC_ARGCHK(pt != NULL);
LTC_ARGCHK(ct != NULL);
LTC_ARGCHK(skey != NULL);
sm4_do(ct, pt, skey->sm4.ek);
s_sm4_do(ct, pt, skey->sm4.ek);
return CRYPT_OK;
}
int sm4_ecb_decrypt(const unsigned char *ct, unsigned char *pt,
Expand All @@ -262,7 +262,7 @@ int sm4_ecb_decrypt(const unsigned char *ct, unsigned char *pt,
LTC_ARGCHK(pt != NULL);
LTC_ARGCHK(ct != NULL);
LTC_ARGCHK(skey != NULL);
sm4_do(pt, ct, skey->sm4.dk);
s_sm4_do(pt, ct, skey->sm4.dk);
return CRYPT_OK;
}

Expand All @@ -284,6 +284,7 @@ int sm4_keysize(int *keysize)
* libtomcrypt interface is used
*/

#ifdef LTC_TEST
static int sm4_self_test_ltc(void)
{
int result;
Expand Down Expand Up @@ -348,6 +349,7 @@ static int sm4_self_test_ltc(void)

return result;
}
#endif

int sm4_test(void)
{
Expand Down