1 /*
2 * Copyright (C) 2013 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <malloc.h>
18 #include <stdint.h>
19 #include <string.h>
20
21 #include "asn1_decoder.h"
22
23
24 typedef struct asn1_context {
25 size_t length;
26 uint8_t* p;
27 int app_type;
28 } asn1_context_t;
29
30
31 static const int kMaskConstructed = 0xE0;
32 static const int kMaskTag = 0x7F;
33 static const int kMaskAppType = 0x1F;
34
35 static const int kTagOctetString = 0x04;
36 static const int kTagOid = 0x06;
37 static const int kTagSequence = 0x30;
38 static const int kTagSet = 0x31;
39 static const int kTagConstructed = 0xA0;
40
asn1_context_new(uint8_t * buffer,size_t length)41 asn1_context_t* asn1_context_new(uint8_t* buffer, size_t length) {
42 asn1_context_t* ctx = (asn1_context_t*) calloc(1, sizeof(asn1_context_t));
43 if (ctx == NULL) {
44 return NULL;
45 }
46 ctx->p = buffer;
47 ctx->length = length;
48 return ctx;
49 }
50
asn1_context_free(asn1_context_t * ctx)51 void asn1_context_free(asn1_context_t* ctx) {
52 free(ctx);
53 }
54
peek_byte(asn1_context_t * ctx)55 static inline int peek_byte(asn1_context_t* ctx) {
56 if (ctx->length <= 0) {
57 return -1;
58 }
59 return *ctx->p;
60 }
61
get_byte(asn1_context_t * ctx)62 static inline int get_byte(asn1_context_t* ctx) {
63 if (ctx->length <= 0) {
64 return -1;
65 }
66 int byte = *ctx->p;
67 ctx->p++;
68 ctx->length--;
69 return byte;
70 }
71
skip_bytes(asn1_context_t * ctx,size_t num_skip)72 static inline bool skip_bytes(asn1_context_t* ctx, size_t num_skip) {
73 if (ctx->length < num_skip) {
74 return false;
75 }
76 ctx->p += num_skip;
77 ctx->length -= num_skip;
78 return true;
79 }
80
decode_length(asn1_context_t * ctx,size_t * out_len)81 static bool decode_length(asn1_context_t* ctx, size_t* out_len) {
82 int num_octets = get_byte(ctx);
83 if (num_octets == -1) {
84 return false;
85 }
86 if ((num_octets & 0x80) == 0x00) {
87 *out_len = num_octets;
88 return 1;
89 }
90 num_octets &= kMaskTag;
91 if ((size_t)num_octets >= sizeof(size_t)) {
92 return false;
93 }
94 size_t length = 0;
95 for (int i = 0; i < num_octets; ++i) {
96 int byte = get_byte(ctx);
97 if (byte == -1) {
98 return false;
99 }
100 length <<= 8;
101 length += byte;
102 }
103 *out_len = length;
104 return true;
105 }
106
107 /**
108 * Returns the constructed type and advances the pointer. E.g. A0 -> 0
109 */
asn1_constructed_get(asn1_context_t * ctx)110 asn1_context_t* asn1_constructed_get(asn1_context_t* ctx) {
111 int type = get_byte(ctx);
112 if (type == -1 || (type & kMaskConstructed) != kTagConstructed) {
113 return NULL;
114 }
115 size_t length;
116 if (!decode_length(ctx, &length) || length > ctx->length) {
117 return NULL;
118 }
119 asn1_context_t* app_ctx = asn1_context_new(ctx->p, length);
120 app_ctx->app_type = type & kMaskAppType;
121 return app_ctx;
122 }
123
asn1_constructed_skip_all(asn1_context_t * ctx)124 bool asn1_constructed_skip_all(asn1_context_t* ctx) {
125 int byte = peek_byte(ctx);
126 while (byte != -1 && (byte & kMaskConstructed) == kTagConstructed) {
127 skip_bytes(ctx, 1);
128 size_t length;
129 if (!decode_length(ctx, &length) || !skip_bytes(ctx, length)) {
130 return false;
131 }
132 byte = peek_byte(ctx);
133 }
134 return byte != -1;
135 }
136
asn1_constructed_type(asn1_context_t * ctx)137 int asn1_constructed_type(asn1_context_t* ctx) {
138 return ctx->app_type;
139 }
140
asn1_sequence_get(asn1_context_t * ctx)141 asn1_context_t* asn1_sequence_get(asn1_context_t* ctx) {
142 if ((get_byte(ctx) & kMaskTag) != kTagSequence) {
143 return NULL;
144 }
145 size_t length;
146 if (!decode_length(ctx, &length) || length > ctx->length) {
147 return NULL;
148 }
149 return asn1_context_new(ctx->p, length);
150 }
151
asn1_set_get(asn1_context_t * ctx)152 asn1_context_t* asn1_set_get(asn1_context_t* ctx) {
153 if ((get_byte(ctx) & kMaskTag) != kTagSet) {
154 return NULL;
155 }
156 size_t length;
157 if (!decode_length(ctx, &length) || length > ctx->length) {
158 return NULL;
159 }
160 return asn1_context_new(ctx->p, length);
161 }
162
asn1_sequence_next(asn1_context_t * ctx)163 bool asn1_sequence_next(asn1_context_t* ctx) {
164 size_t length;
165 if (get_byte(ctx) == -1 || !decode_length(ctx, &length) || !skip_bytes(ctx, length)) {
166 return false;
167 }
168 return true;
169 }
170
asn1_oid_get(asn1_context_t * ctx,uint8_t ** oid,size_t * length)171 bool asn1_oid_get(asn1_context_t* ctx, uint8_t** oid, size_t* length) {
172 if (get_byte(ctx) != kTagOid) {
173 return false;
174 }
175 if (!decode_length(ctx, length) || *length == 0 || *length > ctx->length) {
176 return false;
177 }
178 *oid = ctx->p;
179 return true;
180 }
181
asn1_octet_string_get(asn1_context_t * ctx,uint8_t ** octet_string,size_t * length)182 bool asn1_octet_string_get(asn1_context_t* ctx, uint8_t** octet_string, size_t* length) {
183 if (get_byte(ctx) != kTagOctetString) {
184 return false;
185 }
186 if (!decode_length(ctx, length) || *length == 0 || *length > ctx->length) {
187 return false;
188 }
189 *octet_string = ctx->p;
190 return true;
191 }
192