ZUC-生成随机序列

问题

ZUC国标上的三个例子生成随机序列

例子1

例子2

例子3

代码1

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

typedef unsigned char uint8;
typedef unsigned int uint32;

uint8 S0[256] = {
    0x3e, 0x72, 0x5b, 0x47, 0xca, 0xe0, 0x00, 0x33, 0x04, 0xd1, 0x54, 0x98, 0x09, 0xb9, 0x6d, 0xcb,
    0x7b, 0x1b, 0xf9, 0x32, 0xaf, 0x9d, 0x6a, 0xa5, 0xb8, 0x2d, 0xfc, 0x1d, 0x08, 0x53, 0x03, 0x90,
    0x4d, 0x4e, 0x84, 0x99, 0xe4, 0xce, 0xd9, 0x91, 0xdd, 0xb6, 0x85, 0x48, 0x8b, 0x29, 0x6e, 0xac,
    0xcd, 0xc1, 0xf8, 0x1e, 0x73, 0x43, 0x69, 0xc6, 0xb5, 0xbd, 0xfd, 0x39, 0x63, 0x20, 0xd4, 0x38,
    0x76, 0x7d, 0xb2, 0xa7, 0xcf, 0xed, 0x57, 0xc5, 0xf3, 0x2c, 0xbb, 0x14, 0x21, 0x06, 0x55, 0x9b,
    0xe3, 0xef, 0x5e, 0x31, 0x4f, 0x7f, 0x5a, 0xa4, 0x0d, 0x82, 0x51, 0x49, 0x5f, 0xba, 0x58, 0x1c,
    0x4a, 0x16, 0xd5, 0x17, 0xa8, 0x92, 0x24, 0x1f, 0x8c, 0xff, 0xd8, 0xae, 0x2e, 0x01, 0xd3, 0xad,
    0x3b, 0x4b, 0xda, 0x46, 0xeb, 0xc9, 0xde, 0x9a, 0x8f, 0x87, 0xd7, 0x3a, 0x80, 0x6f, 0x2f, 0xc8,
    0xb1, 0xb4, 0x37, 0xf7, 0x0a, 0x22, 0x13, 0x28, 0x7c, 0xcc, 0x3c, 0x89, 0xc7, 0xc3, 0x96, 0x56,
    0x07, 0xbf, 0x7e, 0xf0, 0x0b, 0x2b, 0x97, 0x52, 0x35, 0x41, 0x79, 0x61, 0xa6, 0x4c, 0x10, 0xfe,
    0xbc, 0x26, 0x95, 0x88, 0x8a, 0xb0, 0xa3, 0xfb, 0xc0, 0x18, 0x94, 0xf2, 0xe1, 0xe5, 0xe9, 0x5d,
    0xd0, 0xdc, 0x11, 0x66, 0x64, 0x5c, 0xec, 0x59, 0x42, 0x75, 0x12, 0xf5, 0x74, 0x9c, 0xaa, 0x23,
    0x0e, 0x86, 0xab, 0xbe, 0x2a, 0x02, 0xe7, 0x67, 0xe6, 0x44, 0xa2, 0x6c, 0xc2, 0x93, 0x9f, 0xf1,
    0xf6, 0xfa, 0x36, 0xd2, 0x50, 0x68, 0x9e, 0x62, 0x71, 0x15, 0x3d, 0xd6, 0x40, 0xc4, 0xe2, 0x0f,
    0x8e, 0x83, 0x77, 0x6b, 0x25, 0x05, 0x3f, 0x0c, 0x30, 0xea, 0x70, 0xb7, 0xa1, 0xe8, 0xa9, 0x65,
    0x8d, 0x27, 0x1a, 0xdb, 0x81, 0xb3, 0xa0, 0xf4, 0x45, 0x7a, 0x19, 0xdf, 0xee, 0x78, 0x34, 0x60 };

uint8 S1[256] = {
    0x55, 0xc2, 0x63, 0x71, 0x3b, 0xc8, 0x47, 0x86, 0x9f, 0x3c, 0xda, 0x5b, 0x29, 0xaa, 0xfd, 0x77,
    0x8c, 0xc5, 0x94, 0x0c, 0xa6, 0x1a, 0x13, 0x00, 0xe3, 0xa8, 0x16, 0x72, 0x40, 0xf9, 0xf8, 0x42,
    0x44, 0x26, 0x68, 0x96, 0x81, 0xd9, 0x45, 0x3e, 0x10, 0x76, 0xc6, 0xa7, 0x8b, 0x39, 0x43, 0xe1,
    0x3a, 0xb5, 0x56, 0x2a, 0xc0, 0x6d, 0xb3, 0x05, 0x22, 0x66, 0xbf, 0xdc, 0x0b, 0xfa, 0x62, 0x48,
    0xdd, 0x20, 0x11, 0x06, 0x36, 0xc9, 0xc1, 0xcf, 0xf6, 0x27, 0x52, 0xbb, 0x69, 0xf5, 0xd4, 0x87,
    0x7f, 0x84, 0x4c, 0xd2, 0x9c, 0x57, 0xa4, 0xbc, 0x4f, 0x9a, 0xdf, 0xfe, 0xd6, 0x8d, 0x7a, 0xeb,
    0x2b, 0x53, 0xd8, 0x5c, 0xa1, 0x14, 0x17, 0xfb, 0x23, 0xd5, 0x7d, 0x30, 0x67, 0x73, 0x08, 0x09,
    0xee, 0xb7, 0x70, 0x3f, 0x61, 0xb2, 0x19, 0x8e, 0x4e, 0xe5, 0x4b, 0x93, 0x8f, 0x5d, 0xdb, 0xa9,
    0xad, 0xf1, 0xae, 0x2e, 0xcb, 0x0d, 0xfc, 0xf4, 0x2d, 0x46, 0x6e, 0x1d, 0x97, 0xe8, 0xd1, 0xe9,
    0x4d, 0x37, 0xa5, 0x75, 0x5e, 0x83, 0x9e, 0xab, 0x82, 0x9d, 0xb9, 0x1c, 0xe0, 0xcd, 0x49, 0x89,
    0x01, 0xb6, 0xbd, 0x58, 0x24, 0xa2, 0x5f, 0x38, 0x78, 0x99, 0x15, 0x90, 0x50, 0xb8, 0x95, 0xe4,
    0xd0, 0x91, 0xc7, 0xce, 0xed, 0x0f, 0xb4, 0x6f, 0xa0, 0xcc, 0xf0, 0x02, 0x4a, 0x79, 0xc3, 0xde,
    0xa3, 0xef, 0xea, 0x51, 0xe6, 0x6b, 0x18, 0xec, 0x1b, 0x2c, 0x80, 0xf7, 0x74, 0xe7, 0xff, 0x21,
    0x5a, 0x6a, 0x54, 0x1e, 0x41, 0x31, 0x92, 0x35, 0xc4, 0x33, 0x07, 0x0a, 0xba, 0x7e, 0x0e, 0x34,
    0x88, 0xb1, 0x98, 0x7c, 0xf3, 0x3d, 0x60, 0x6c, 0x7b, 0xca, 0xd3, 0x1f, 0x32, 0x65, 0x04, 0x28,
    0x64, 0xbe, 0x85, 0x9b, 0x2f, 0x59, 0x8a, 0xd7, 0xb0, 0x25, 0xac, 0xaf, 0x12, 0x03, 0xe2, 0xf2 };

uint32 D[16] = {
    0x44d7, 0x26bc, 0x626b, 0x135e, 0x5789, 0x35e2, 0x7135, 0x09af,
    0x4d78, 0x2f13, 0x6bc4, 0x1af1, 0x5e26, 0x3c4d, 0x789a, 0x47ac };

uint32 LFSR[16] = { 0 };
uint32 X[4] = { 0 };
uint32 R1 = 0, R2 = 0;
uint32 W = 0;

uint32 mod_add(uint32 a, uint32 b);
uint32 mod_2exp_mul(uint32 x, int exp);
void LFSRWithInitMode(uint32 u);
void LFSRWithWorkMode();
void BitReconstruction();

uint32 mod_add(uint32 a, uint32 b)
{
    uint32 c = a + b;
    c = (c & 0x7fffffff) + (c >> 31);
    return c;
}

uint32 mod_2exp_mul(uint32 x, int exp)
{
    return ((x << exp) | (x >> (31 - exp))) & 0x7fffffff;
}

uint32 Rot(uint32 x, int move)
{
    return ((x << move) | (x >> (32 - move)));
}

void LFSRWithInitMode(uint32 u)
{
    uint32 v = 0, tmp = 0, i = 0;

    v = LFSR[0];
    tmp = mod_2exp_mul(LFSR[0], 8);
    v = mod_add(v, tmp);

    tmp = mod_2exp_mul(LFSR[4], 20);
    v = mod_add(v, tmp);

    tmp = mod_2exp_mul(LFSR[10], 21);
    v = mod_add(v, tmp);

    tmp = mod_2exp_mul(LFSR[13], 17);
    v = mod_add(v, tmp);

    tmp = mod_2exp_mul(LFSR[15], 15);
    v = mod_add(v, tmp);

    v = mod_add(v, u);
    if (v == 0)
        v = 0x7fffffff;

    for (i = 0; i < 15; i++)
        LFSR[i] = LFSR[i + 1];
    LFSR[15] = v;
}

void LFSRWithWorkMode()
{
    uint32 v = 0, tmp = 0, i = 0;

    v = LFSR[0];
    tmp = mod_2exp_mul(LFSR[0], 8);
    v = mod_add(v, tmp);

    tmp = mod_2exp_mul(LFSR[4], 20);
    v = mod_add(v, tmp);

    tmp = mod_2exp_mul(LFSR[10], 21);
    v = mod_add(v, tmp);

    tmp = mod_2exp_mul(LFSR[13], 17);
    v = mod_add(v, tmp);

    tmp = mod_2exp_mul(LFSR[15], 15);
    v = mod_add(v, tmp);

    if (v == 0)
        v = 0x7fffffff;

    for (i = 0; i < 15; i++)
        LFSR[i] = LFSR[i + 1];
    LFSR[15] = v;
}

void BitReconstruction()
{
    X[0] = ((LFSR[15] & 0x7fff8000) << 1) | (LFSR[14] & 0xffff);
    X[1] = (LFSR[11] << 16) | (LFSR[9] >> 15);
    X[2] = (LFSR[7] << 16) | (LFSR[5] >> 15);
    X[3] = (LFSR[2] << 16) | (LFSR[0] >> 15);
}

uint32 L1(uint32 x)
{
    return (x ^ Rot(x, 2) ^ Rot(x, 10) ^ Rot(x, 18) ^ Rot(x, 24));
}

uint32 L2(uint32 x)
{
    return (x ^ Rot(x, 8) ^ Rot(x, 14) ^ Rot(x, 22) ^ Rot(x, 30));
}

uint32 S(uint32 a)
{
    uint8 x[4] = { 0 }, y[4] = { 0 };
    uint32 b = 0;
    int i = 0, row = 0, line = 0;
    x[0] = a >> 24;
    x[1] = (a >> 16) & 0xff;
    x[2] = (a >> 8) & 0xff;
    x[3] = a & 0xff;
    for (i = 0; i < 4; i++)
    {
        //row = x[i] >> 4;
        //line = x[i] & 0xf;
        if (i == 0 || i == 2)
            y[i] = S0[x[i]];
        else
            y[i] = S1[x[i]];
    }
    b = (y[0] << 24) | (y[1] << 16) | (y[2] << 8) | y[3];
    return b;
}

void F()
{
    uint32 W1 = 0, W2 = 0;
    uint32 tmp1 = 0, tmp2 = 0;
    W = (X[0] ^ R1) + R2;
    W1 = R1 + X[1];
    W2 = R2 ^ X[2];
    R1 = S(L1((W1 << 16) | (W2 >> 16)));
    R2 = S(L2((W2 << 16) | (W1 >> 16)));
}

void Key_IV_Insert(uint8* k, uint8* iv)
{
    int i = 0;
    printf("
initial state of LFSR: S[0]-S[15]
");
    for (i = 0; i < 16; i++)
    {
        LFSR[i] = (k[i] << 23) | (D[i] << 8) | iv[i];
        printf("%08x  ", LFSR[i]);
    }
}

void Init(uint8* k, uint8* iv)
{
    Key_IV_Insert(k, iv);
    R1 = R2 = 0;
    uint32 i = 0;
    for (i = 0; i < 32; i++)
    {
        BitReconstruction();
        F(X[0], X[1], X[2]);
        LFSRWithInitMode(W >> 1);
    }
    printf("
------------------------------------------------------------
state of LFSR after executing initialization: S[0]-S[15]
");
    for (i = 0; i < 16; i++)
    {
        printf("%08x  ", LFSR[i]);
    }
    printf("
------------------------------------------------------------
internal state of Finite State Machine:
");
    printf("R1=%08x
", R1);
    printf("R2=%08x
", R2);
}

uint32* KeyStream_Generator(int keylen)
{
    uint32 Z = 0, i = 0;
    uint32* keystream = (uint32*)malloc(keylen * sizeof(uint32));
    BitReconstruction();
    F(X[0], X[1], X[2]);
    LFSRWithWorkMode();
    for (i = 0; i < keylen; i++)
    {
        BitReconstruction();
        F(X[0], X[1], X[2]);
        keystream[i] = W ^ X[3]; //一次密钥流生成
        LFSRWithWorkMode();
    }
    return keystream;
}

int main()
{
    int i = 0, keylen = 0;
    uint8 key[16] = { 0 };
    uint8 iv[16] = { 0 };

    char k[50] = { 0 };
    char v[50] = { 0 };
    char tmp[2] = { 0 };
    printf("key: ");
    scanf("%s", k);
    printf("iv: ");
    scanf("%s", v);
    printf("keylen : ");
    scanf("%d", &keylen);
    for (i = 0; i < 16; i++)
    {
        key[i] = (((k[2 * i] <= '9') ? (k[2 * i] - '0') : (k[2 * i] - 'a' + 10)) << 4) +
            ((k[2 * i + 1] <= '9') ? (k[2 * i + 1] - '0') : (k[2 * i + 1] - 'a' + 10));
        iv[i] = (((v[2 * i] <= '9') ? (v[2 * i] - '0') : (v[2 * i] - 'a' + 10)) << 4) +
            ((v[2 * i + 1] <= '9') ? (v[2 * i + 1] - '0') : (v[2 * i + 1] - 'a' + 10));
    }

    Init(key, iv);
    uint32* keylist = KeyStream_Generator(keylen);
    printf("
输出密钥流：
");
    for (i = 0; i < keylen; i++)
    {
        printf("KeyStream[%d]=%08x
",i,keylist[i]);
    }
    printf("
");
    system("pause");
    return 0;
}

代码2

#include "zuc.h"

unsigned int AddMod(unsigned int a, unsigned int b)
{
    unsigned int c = a + b;
    if (c >> 31)
    {
        c = (c & 0x7fffffff) + 1;
    }
    return c;
}


unsigned int PowMod(unsigned int x, unsigned int k)
{
    return (((x << k) | (x >> (31 - k))) & 0x7fffffff);
}


unsigned int L1(unsigned int X)
{
    return X ^ ZUC_rotl32(X, 2) ^ ZUC_rotl32(X, 10) ^ ZUC_rotl32(X, 18) ^ ZUC_rotl32(X, 24);
}
unsigned int L2(unsigned int X)
{
    return X ^ ZUC_rotl32(X, 8) ^ ZUC_rotl32(X, 14) ^ ZUC_rotl32(X, 22) ^ ZUC_rotl32(X, 30);
}

unsigned char BitValue(unsigned int M[], unsigned int i)
{
    int j, k;
    j = i >> 5;
    k = i & 0x1f;
    if (M[j] & (0x1 << (31 - k)))
        return 1;
    else
        return 0;
}

unsigned int GetWord(unsigned int k[], unsigned int i)             //获取字串中的从第i个比特值开始的字
{
    int j, m;
    unsigned int word;
    j = i >> 5;
    m = i & 0x1f;
    if (m == 0)
        word = k[j];
    else
        word = (k[j] << m) | (k[j + 1] >> (32 - m));
    return word;
}
void LFSRWithInitMode(unsigned int LFSR_S[], unsigned int u)
{
    unsigned int v = LFSR_S[0], i;
    v = AddMod(v, PowMod(LFSR_S[15], 15));
    v = AddMod(v, PowMod(LFSR_S[13], 17));
    v = AddMod(v, PowMod(LFSR_S[10], 21));
    v = AddMod(v, PowMod(LFSR_S[4], 20));
    v = AddMod(v, PowMod(LFSR_S[0], 8));

    for (i = 0; i < 15; i++)
    {
        LFSR_S[i] = LFSR_S[i + 1];
    }
    LFSR_S[15] = AddMod(v, u);

    if (!LFSR_S[15])
    {
        LFSR_S[15] = 0x7fffffff;
    }
}

void LFSRWithWorkMode(unsigned int LFSR_S[])
{
    unsigned int v = LFSR_S[0], i;
    v = AddMod(v, PowMod(LFSR_S[15], 15));
    v = AddMod(v, PowMod(LFSR_S[13], 17));
    v = AddMod(v, PowMod(LFSR_S[10], 21));
    v = AddMod(v, PowMod(LFSR_S[4], 20));
    v = AddMod(v, PowMod(LFSR_S[0], 8));

    for (i = 0; i < 15; i++)
    {
        LFSR_S[i] = LFSR_S[i + 1];
    }
    LFSR_S[15] = v;

    if (!LFSR_S[15])
    {
        LFSR_S[15] = 0x7fffffff;
    }
}

void BR(unsigned int LFSR_S[], unsigned int BR_X[])
{
    BR_X[0] = ((LFSR_S[15] & 0x7fff8000) << 1) | (LFSR_S[14] & 0x0000ffff);
    BR_X[1] = ((LFSR_S[11] & 0x0000ffff) << 16) | ((LFSR_S[9] & 0x7fff8000) >> 15);
    BR_X[2] = ((LFSR_S[7] & 0x0000ffff) << 16) | ((LFSR_S[5] & 0x7fff8000) >> 15);
    BR_X[3] = ((LFSR_S[2] & 0x0000ffff) << 16) | ((LFSR_S[0] & 0x7fff8000) >> 15);
}

unsigned int F(unsigned int BR_X[], unsigned int F_R[])
{
    unsigned int W, W1, W2;

    W = (BR_X[0] ^ F_R[0]) + F_R[1];
    W1 = F_R[0] + BR_X[1];
    W2 = F_R[1] ^ BR_X[2];
    F_R[0] = L1((W1 << 16) | (W2 >> 16));
    F_R[0] = (ZUC_S0[(F_R[0] >> 24) & 0xFF]) << 24 | (ZUC_S1[(F_R[0] >> 16) & 0xFF]) << 16 | (ZUC_S0[(F_R[0] >> 8) & 0xFF]) << 8 | (ZUC_S1[F_R[0] & 0xFF]);
    F_R[1] = L2((W2 << 16) | (W1 >> 16));
    F_R[1] = (ZUC_S0[(F_R[1] >> 24) & 0xFF]) << 24 | (ZUC_S1[(F_R[1] >> 16) & 0xFF]) << 16  | (ZUC_S0[(F_R[1] >> 8) & 0xFF]) << 8 | (ZUC_S1[F_R[1] & 0xFF]);

    return W;
}

void ZUC_Init(unsigned int k[], unsigned int iv[], unsigned int LFSR_S[], unsigned int BR_X[], unsigned int F_R[])
{
    unsigned char count = 32;
    int i;

    //loading key to the LFSR s0,s1,s2....s15 
    printf("
initial state of LFSR: S[0]-S[15]
");
    for (i = 0; i < 16; i++)
    {
        LFSR_S[i] = ZUC_LinkToS(k[i], ZUC_d[i], iv[i]);
        printf("%08x  ", LFSR_S[i]);
    }

    F_R[0] = 0x00;    //R1 
    F_R[1] = 0x00;    //R2 

    // 初始变量和秘钥状态完毕后，开始32轮初始化
    while (count)         //32 times 
    {
        unsigned int W;
        BR(LFSR_S, BR_X); //BitReconstruction 
        W = F(BR_X, F_R);   //nonlinear function 
        LFSRWithInitMode(LFSR_S, W >> 1);
        count--;
    }
}

void ZUC_Work(unsigned int LFSR_S[], unsigned int BR_X[], unsigned int F_R[], unsigned int pKeyStream[], int KeyStreamLen)
{
    int i = 0;
    BR(LFSR_S, BR_X);
    F(BR_X, F_R);
    LFSRWithWorkMode(LFSR_S);
    printf("------------------------------------------------------------
输出密钥流：
");
    while (i < KeyStreamLen)
    {
        BR(LFSR_S, BR_X);
        pKeyStream[i] = F(BR_X, F_R) ^ BR_X[3];
        printf("pKeyStream[%d]=%08x
", i,pKeyStream[i]);
        LFSRWithWorkMode(LFSR_S);
        i++;
    }
}

void ZUC_GenKeyStream(unsigned int k[], unsigned int iv[], unsigned int KeyStream[], int KeyStreamLen)
{

    unsigned int LFSR_S[16]; //LFSR state s0,s1,s2,...s15 
    unsigned int BR_X[4];    //Bit Reconstruction X0,X1,X2,X3 
    unsigned int F_R[2];     //R1,R2,variables of nonlinear function F 
    int i;

    //Initialisation 
    ZUC_Init(k, iv, LFSR_S, BR_X, F_R);
    printf("
------------------------------------------------------------
state of LFSR after executing initialization: S[0]-S[15]
");
    for (i = 0; i < 16; i++)
    {
        printf("%08x  ", LFSR_S[i]);
    }
    printf("
------------------------------------------------------------
internal state of Finite State Machine:
");
    printf("R1=%08x
", F_R[0]);
    printf("R2=%08x
", F_R[1]);

    //Working 
    ZUC_Work(LFSR_S, BR_X, F_R, KeyStream, KeyStreamLen);
}

int main()
{
    int KeystreamLen, i;
    unsigned int key[16] = {0};
    unsigned int iv[16] = {0};

    char k[50] = { 0 };
    char v[50] = { 0 };

    printf("key: ");
    scanf("%s", k);
    printf("IV : ");
    scanf("%s", v);
    printf("KeystreamLen : ");
    scanf("%d", &KeystreamLen);
    for (i = 0; i < 16; i++)
    {
        key[i] = (((k[2 * i] <= '9') ? (k[2 * i] - '0') : (k[2 * i] - 'a' + 10)) << 4) +
            ((k[2 * i + 1] <= '9') ? (k[2 * i + 1] - '0') : (k[2 * i + 1] - 'a' + 10));
        iv[i] = (((v[2 * i] <= '9') ? (v[2 * i] - '0') : (v[2 * i] - 'a' + 10)) << 4) +
            ((v[2 * i + 1] <= '9') ? (v[2 * i + 1] - '0') : (v[2 * i + 1] - 'a' + 10));
    }
   
    printf("
开始生成秘钥流：
------------------------------------------------------------");
    ZUC_GenKeyStream(key, iv,Keystream, KeystreamLen);
}

生成结果

例子1

例子2

例子3

测试用例

key:00000000000000000000000000000000
iv:00000000000000000000000000000000

key:ffffffffffffffffffffffffffffffff
iv:ffffffffffffffffffffffffffffffff

key:3d4c4be96a82fdaeb58f641db17b455b
iv:84319aa8de6915ca1f6bda6bfbd87c66

参考

1、ZUC国标

2、商用密码检测中心ZUC源码下载

源码见github