1 /*
2  * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *    http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "dcm_asn1.h"
17 #include "hks_log.h"
18 #include "hks_template.h"
19 #include "securec.h"
20 
21 #define BIT_NUM_OF_UINT8 8
22 #define ASN_1_EXPLICIT_TAG_LEN 3
23 #define ASN_1_EXPLICIT_TAG_TYPE_BOOL 0xA0
24 #define ASN_1_TAG_TYPE_EXTRA_IDENTIFIER 0x1F
25 #define TLV_HEADER_TYPE_2_LEN 4
26 #define BASE128_ENCODE_BIT_LEN 7
27 
BuildTlvHeader(struct HksAsn1Blob * header,const struct HksAsn1Blob * tlv)28 static void BuildTlvHeader(struct HksAsn1Blob *header, const struct HksAsn1Blob *tlv)
29 {
30     uint32_t len = tlv->size;
31     uint8_t *hptr = header->data;
32     HKS_ASN1_ENCODE_BYTE(hptr, tlv->type);
33 
34     uint32_t pad = 0;
35     if ((tlv->type == ASN_1_TAG_TYPE_BIT_STR) || ((tlv->type == ASN_1_TAG_TYPE_INT) &&
36         (tlv->data[0] > ASN_1_MAX_VAL_NO_EXTRA_LEN_BYTE))) {
37             pad++;
38             len++;
39     }
40 
41     if (len < ASN_1_MIN_VAL_1_EXTRA_LEN_BYTE) {
42         HKS_ASN1_ENCODE_BYTE(hptr, len);
43     } else if (len < ASN_1_MIN_VAL_2_EXTRA_LEN_BYTE) {
44         HKS_ASN1_ENCODE_BYTE(hptr, ASN_1_TAG_TYPE_1_BYTE_LEN);
45         HKS_ASN1_ENCODE_BYTE(hptr, len);
46     } else {
47         HKS_ASN1_ENCODE_BYTE(hptr, ASN_1_TAG_TYPE_2_BYTE_LEN);
48         HKS_ASN1_ENCODE_TWO_BYTE(hptr, len);
49     }
50 
51     if (pad != 0) {
52         HKS_ASN1_ENCODE_BYTE(hptr, 0);
53     }
54 
55     header->size = hptr - header->data;
56 }
57 
Asn1InsertValue(struct HksBlob * buf,struct HksAsn1Obj * obj,const struct HksAsn1Blob * tlv)58 static int32_t Asn1InsertValue(struct HksBlob *buf, struct HksAsn1Obj *obj, const struct HksAsn1Blob *tlv)
59 {
60     struct HksAsn1Blob value = *tlv;
61     if ((tlv->type != ASN_1_TAG_TYPE_OCT_STR) && (tlv->type != ASN_1_TAG_TYPE_BIT_STR)) {
62         while ((value.size > 1) && (value.data[0] == 0)) {
63             value.data++;
64             value.size--;
65         }
66     }
67 
68     uint8_t headerBuf[ASN_1_MAX_HEADER_LEN] = {0};
69     struct HksAsn1Blob header = { 0, ASN_1_MAX_HEADER_LEN, headerBuf };
70     BuildTlvHeader(&header, &value);
71 
72     uint32_t outSize = header.size + value.size;
73     if (buf->size < outSize) {
74         HKS_LOG_E("output buffer too small: %" LOG_PUBLIC "u. expected%" LOG_PUBLIC "u", buf->size, outSize);
75         return HKS_ERROR_BUFFER_TOO_SMALL;
76     }
77 
78     if (memmove_s(buf->data + header.size, buf->size - header.size, value.data, value.size) != EOK) {
79         HKS_LOG_E("memmove_s failed");
80         return HKS_ERROR_BUFFER_TOO_SMALL;
81     }
82     (void)memcpy_s(buf->data, buf->size, header.data, header.size);
83     buf->data += outSize;
84     buf->size -= outSize;
85     if (obj != NULL) {
86         obj->header.type = tlv->type;
87         obj->header.data = buf->data;
88         obj->header.size = header.size;
89         obj->value.type = tlv->type;
90         obj->value.data = buf->data + header.size;
91         obj->value.size = value.size;
92     }
93 
94     return HKS_SUCCESS;
95 }
96 
DcmAsn1InsertValue(struct HksBlob * buf,struct HksAsn1Obj * obj,const struct HksAsn1Blob * tlv)97 int32_t DcmAsn1InsertValue(struct HksBlob *buf, struct HksAsn1Obj *obj, const struct HksAsn1Blob *tlv)
98 {
99     if ((CheckBlob(buf) != HKS_SUCCESS) || (CheckAsn1Blob(tlv) != HKS_SUCCESS) || (tlv->size > ASN_1_MAX_SIZE)) {
100         HKS_LOG_E("invalid buf or tlv.");
101         return HKS_ERROR_INVALID_ARGUMENT;
102     }
103 
104     if (tlv->type == ASN_1_TAG_TYPE_RAW) {
105         if (memcpy_s(buf->data, buf->size, tlv->data, tlv->size) != EOK) {
106             HKS_LOG_E("copy raw data fail");
107             return HKS_ERROR_BUFFER_TOO_SMALL;
108         }
109         buf->data += tlv->size;
110         buf->size -= tlv->size;
111         return HKS_SUCCESS;
112     }
113 
114     return Asn1InsertValue(buf, obj, tlv);
115 }
116 
DcmAsn1WriteFinal(struct HksBlob * final,const struct HksAsn1Blob * tlv)117 int32_t DcmAsn1WriteFinal(struct HksBlob *final, const struct HksAsn1Blob *tlv)
118 {
119     HKS_IF_NOT_SUCC_LOGE_RETURN(CheckBlob(final), HKS_ERROR_INVALID_ARGUMENT, "invalid asn1 final buf.")
120 
121     struct HksBlob tmp = { final->size, final->data };
122     int32_t ret = DcmAsn1InsertValue(&tmp, NULL, tlv);
123     HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "insert value fail\n")
124 
125     final->size -= tmp.size;
126     return HKS_SUCCESS;
127 }
128 
Asn1GetObj(struct HksBlob * next,struct HksAsn1Obj * obj,const struct HksBlob * data)129 static int32_t Asn1GetObj(struct HksBlob *next, struct HksAsn1Obj *obj, const struct HksBlob *data)
130 {
131     uint8_t *buf = data->data;
132     uint32_t length = 0;
133     obj->header.data = buf;
134     HKS_ASN1_DECODE_BYTE(buf, obj->header.type);
135     if (buf[0] < ASN_1_MIN_VAL_1_EXTRA_LEN_BYTE) {
136         HKS_ASN1_DECODE_BYTE(buf, length);
137     } else {
138         uint32_t b;
139         HKS_ASN1_DECODE_BYTE(buf, b);
140 
141         switch (b) {
142             case ASN_1_TAG_TYPE_1_BYTE_LEN:
143                 HKS_ASN1_DECODE_BYTE(buf, length);
144                 break;
145             case ASN_1_TAG_TYPE_2_BYTE_LEN:
146                 if (data->size < ASN_1_MIN_HEADER_LEN + 1) {
147                     HKS_LOG_E("invalid data to decode two bytes.\n");
148                     return HKS_ERROR_INSUFFICIENT_DATA;
149                 }
150                 HKS_ASN1_DECODE_TWO_BYTE(buf, length);
151                 break;
152             default:
153                 HKS_LOG_E("Object length does not make sense.\n");
154                 return HKS_ERROR_INVALID_ARGUMENT;
155         }
156     }
157     obj->header.size = buf - data->data;
158     if (length > data->size - obj->header.size) {
159         HKS_LOG_E("data buffer is not big enough to hold %" LOG_PUBLIC "u bytes.\n", length);
160         return HKS_ERROR_INSUFFICIENT_DATA;
161     }
162 
163     obj->value.type = obj->header.type;
164     obj->value.size = length;
165     obj->value.data = buf;
166     next->data = data->data + obj->header.size + obj->value.size;
167     next->size = data->size - obj->header.size - obj->value.size;
168     return HKS_SUCCESS;
169 }
170 
DcmAsn1ExtractTag(struct HksBlob * next,struct HksAsn1Obj * obj,const struct HksBlob * data,uint32_t expectedTag)171 int32_t DcmAsn1ExtractTag(struct HksBlob *next, struct HksAsn1Obj *obj, const struct HksBlob *data,
172     uint32_t expectedTag)
173 {
174     if ((next == NULL) || (obj == NULL) || (data == NULL) || (data->size < ASN_1_MIN_HEADER_LEN)) {
175         HKS_LOG_E("invalid params");
176         return HKS_ERROR_INVALID_ARGUMENT;
177     }
178 
179     int32_t ret = Asn1GetObj(next, obj, data);
180     HKS_IF_NOT_SUCC_LOGE_RETURN(ret, ret, "get asn1 obj fail.\n")
181 
182     if (obj->header.type != expectedTag) {
183         HKS_LOG_E("tag %" LOG_PUBLIC "u does not match expected: %" LOG_PUBLIC "u\n", obj->header.type, expectedTag);
184         return HKS_ERROR_INVALID_ARGUMENT;
185     }
186     return HKS_SUCCESS;
187 }