1 /*
2 * Copyright 2014-2022 The GmSSL Project. All Rights Reserved.
3 *
4 * Licensed under the Apache License, Version 2.0 (the License); you may
5 * not use this file except in compliance with the License.
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 */
9
10
11
12 #include <stdio.h>
13 #include <string.h>
14 #include <stdlib.h>
15 #include <gmssl/zuc.h>
16 #include <gmssl/error.h>
17 #include <gmssl/endian.h>
18
19
zuc_set_eea_key(ZUC_STATE * key,const uint8_t user_key[16],ZUC_UINT32 count,ZUC_UINT5 bearer,ZUC_BIT direction)20 static void zuc_set_eea_key(ZUC_STATE *key, const uint8_t user_key[16],
21 ZUC_UINT32 count, ZUC_UINT5 bearer, ZUC_BIT direction)
22 {
23 uint8_t iv[16] = {0};
24 iv[0] = iv[8] = count >> 24;
25 iv[1] = iv[9] = count >> 16;
26 iv[2] = iv[10] = count >> 8;
27 iv[3] = iv[11] = count;
28 iv[4] = iv[12] = ((bearer << 1) | (direction & 1)) << 2;
29 zuc_init(key, user_key, iv);
30 }
31
zuc_eea_encrypt(const ZUC_UINT32 * in,ZUC_UINT32 * out,size_t nbits,const uint8_t key[16],ZUC_UINT32 count,ZUC_UINT5 bearer,ZUC_BIT direction)32 void zuc_eea_encrypt(const ZUC_UINT32 *in, ZUC_UINT32 *out, size_t nbits,
33 const uint8_t key[16], ZUC_UINT32 count, ZUC_UINT5 bearer,
34 ZUC_BIT direction)
35 {
36 ZUC_STATE zuc_key;
37 size_t nwords = (nbits + 31)/32;
38 size_t i;
39
40 zuc_set_eea_key(&zuc_key, key, count, bearer, direction);
41 zuc_generate_keystream(&zuc_key, nwords, out);
42 for (i = 0; i < nwords; i++) {
43 out[i] ^= in[i];
44 }
45
46 if (nbits % 32 != 0) {
47 out[nwords - 1] |= (0xffffffff << (32 - (nbits%32)));
48 }
49 }
50
zuc_set_eia_iv(uint8_t iv[16],ZUC_UINT32 count,ZUC_UINT5 bearer,ZUC_BIT direction)51 static void zuc_set_eia_iv(uint8_t iv[16], ZUC_UINT32 count, ZUC_UINT5 bearer,
52 ZUC_BIT direction)
53 {
54 memset(iv, 0, 16);
55 iv[0] = count >> 24;
56 iv[1] = iv[9] = count >> 16;
57 iv[2] = iv[10] = count >> 8;
58 iv[3] = iv[11] = count;
59 iv[4] = iv[12] = bearer << 3;
60 iv[8] = iv[0] ^ (direction << 7);
61 iv[14] = (direction << 7);
62 }
63
zuc_eia_generate_mac(const ZUC_UINT32 * data,size_t nbits,const uint8_t key[16],ZUC_UINT32 count,ZUC_UINT5 bearer,ZUC_BIT direction)64 ZUC_UINT32 zuc_eia_generate_mac(const ZUC_UINT32 *data, size_t nbits,
65 const uint8_t key[16], ZUC_UINT32 count, ZUC_UINT5 bearer,
66 ZUC_BIT direction)
67 {
68 ZUC_MAC_CTX ctx;
69 uint8_t iv[16];
70 uint8_t mac[4];
71 zuc_set_eia_iv(iv, count, bearer, direction);
72 zuc_mac_init(&ctx, key, iv);
73 zuc_mac_finish(&ctx, (uint8_t *)data, nbits, mac);
74 return GETU32(mac);
75 }
76
77 #define ZUC_BLOCK_SIZE 4
78
zuc_encrypt_init(ZUC_CTX * ctx,const uint8_t key[ZUC_KEY_SIZE],const uint8_t iv[ZUC_IV_SIZE])79 int zuc_encrypt_init(ZUC_CTX *ctx, const uint8_t key[ZUC_KEY_SIZE], const uint8_t iv[ZUC_IV_SIZE])
80 {
81 if (!ctx || !key || !iv) {
82 error_print();
83 return -1;
84 }
85 zuc_init(&ctx->zuc_state, key, iv);
86 memset(ctx->block, 0, ZUC_BLOCK_SIZE);
87 ctx->block_nbytes = 0;
88 return 1;
89 }
90
zuc_encrypt_update(ZUC_CTX * ctx,const uint8_t * in,size_t inlen,uint8_t * out,size_t * outlen)91 int zuc_encrypt_update(ZUC_CTX *ctx, const uint8_t *in, size_t inlen, uint8_t *out, size_t *outlen)
92 {
93 size_t left;
94 size_t nblocks;
95 size_t len;
96
97 if (ctx->block_nbytes >= ZUC_BLOCK_SIZE) {
98 error_print();
99 return -1;
100 }
101 *outlen = 0;
102 if (ctx->block_nbytes) {
103 left = ZUC_BLOCK_SIZE - ctx->block_nbytes;
104 if (inlen < left) {
105 memcpy(ctx->block + ctx->block_nbytes, in, inlen);
106 ctx->block_nbytes += inlen;
107 return 1;
108 }
109 memcpy(ctx->block + ctx->block_nbytes, in, left);
110 zuc_encrypt(&ctx->zuc_state, ctx->block, ZUC_BLOCK_SIZE, out);
111 in += left;
112 inlen -= left;
113 out += ZUC_BLOCK_SIZE;
114 *outlen += ZUC_BLOCK_SIZE;
115 }
116 if (inlen >= ZUC_BLOCK_SIZE) {
117 nblocks = inlen / ZUC_BLOCK_SIZE;
118 len = nblocks * ZUC_BLOCK_SIZE;
119 zuc_encrypt(&ctx->zuc_state, in, len, out);
120 in += len;
121 inlen -= len;
122 out += len;
123 *outlen += len;
124 }
125 if (inlen) {
126 memcpy(ctx->block, in, inlen);
127 }
128 ctx->block_nbytes = inlen;
129 return 1;
130 }
131
zuc_encrypt_finish(ZUC_CTX * ctx,uint8_t * out,size_t * outlen)132 int zuc_encrypt_finish(ZUC_CTX *ctx, uint8_t *out, size_t *outlen)
133 {
134 size_t left;
135 if (ctx->block_nbytes >= ZUC_BLOCK_SIZE) {
136 error_print();
137 return -1;
138 }
139 zuc_encrypt(&ctx->zuc_state, ctx->block, ctx->block_nbytes, out);
140 *outlen = ctx->block_nbytes;
141 return 1;
142 }
143