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 <stdint.h> 18 #include <string.h> 19 20 #include "asn1_decoder.h" 21 22 23 typedef struct asn1_context { 24 size_t length; 25 uint8_t* p; 26 int app_type; 27 } asn1_context_t; 28 29 30 static const int kMaskConstructed = 0xE0; 31 static const int kMaskTag = 0x7F; 32 static const int kMaskAppType = 0x1F; 33 34 static const int kTagOctetString = 0x04; 35 static const int kTagOid = 0x06; 36 static const int kTagSequence = 0x30; 37 static const int kTagSet = 0x31; 38 static const int kTagConstructed = 0xA0; 39 40 asn1_context_t* asn1_context_new(uint8_t* buffer, size_t length) { 41 asn1_context_t* ctx = (asn1_context_t*) calloc(1, sizeof(asn1_context_t)); 42 if (ctx == NULL) { 43 return NULL; 44 } 45 ctx->p = buffer; 46 ctx->length = length; 47 return ctx; 48 } 49 50 void asn1_context_free(asn1_context_t* ctx) { 51 free(ctx); 52 } 53 54 static inline int peek_byte(asn1_context_t* ctx) { 55 if (ctx->length <= 0) { 56 return -1; 57 } 58 return *ctx->p; 59 } 60 61 static inline int get_byte(asn1_context_t* ctx) { 62 if (ctx->length <= 0) { 63 return -1; 64 } 65 int byte = *ctx->p; 66 ctx->p++; 67 ctx->length--; 68 return byte; 69 } 70 71 static inline bool skip_bytes(asn1_context_t* ctx, size_t num_skip) { 72 if (ctx->length < num_skip) { 73 return false; 74 } 75 ctx->p += num_skip; 76 ctx->length -= num_skip; 77 return true; 78 } 79 80 static bool decode_length(asn1_context_t* ctx, size_t* out_len) { 81 int num_octets = get_byte(ctx); 82 if (num_octets == -1) { 83 return false; 84 } 85 if ((num_octets & 0x80) == 0x00) { 86 *out_len = num_octets; 87 return 1; 88 } 89 num_octets &= kMaskTag; 90 if ((size_t)num_octets >= sizeof(size_t)) { 91 return false; 92 } 93 size_t length = 0; 94 for (int i = 0; i < num_octets; ++i) { 95 int byte = get_byte(ctx); 96 if (byte == -1) { 97 return false; 98 } 99 length <<= 8; 100 length += byte; 101 } 102 *out_len = length; 103 return true; 104 } 105 106 /** 107 * Returns the constructed type and advances the pointer. E.g. A0 -> 0 108 */ 109 asn1_context_t* asn1_constructed_get(asn1_context_t* ctx) { 110 int type = get_byte(ctx); 111 if (type == -1 || (type & kMaskConstructed) != kTagConstructed) { 112 return NULL; 113 } 114 size_t length; 115 if (!decode_length(ctx, &length) || length > ctx->length) { 116 return NULL; 117 } 118 asn1_context_t* app_ctx = asn1_context_new(ctx->p, length); 119 app_ctx->app_type = type & kMaskAppType; 120 return app_ctx; 121 } 122 123 bool asn1_constructed_skip_all(asn1_context_t* ctx) { 124 int byte = peek_byte(ctx); 125 while (byte != -1 && (byte & kMaskConstructed) == kTagConstructed) { 126 skip_bytes(ctx, 1); 127 size_t length; 128 if (!decode_length(ctx, &length) || !skip_bytes(ctx, length)) { 129 return false; 130 } 131 byte = peek_byte(ctx); 132 } 133 return byte != -1; 134 } 135 136 int asn1_constructed_type(asn1_context_t* ctx) { 137 return ctx->app_type; 138 } 139 140 asn1_context_t* asn1_sequence_get(asn1_context_t* ctx) { 141 if ((get_byte(ctx) & kMaskTag) != kTagSequence) { 142 return NULL; 143 } 144 size_t length; 145 if (!decode_length(ctx, &length) || length > ctx->length) { 146 return NULL; 147 } 148 return asn1_context_new(ctx->p, length); 149 } 150 151 asn1_context_t* asn1_set_get(asn1_context_t* ctx) { 152 if ((get_byte(ctx) & kMaskTag) != kTagSet) { 153 return NULL; 154 } 155 size_t length; 156 if (!decode_length(ctx, &length) || length > ctx->length) { 157 return NULL; 158 } 159 return asn1_context_new(ctx->p, length); 160 } 161 162 bool asn1_sequence_next(asn1_context_t* ctx) { 163 size_t length; 164 if (get_byte(ctx) == -1 || !decode_length(ctx, &length) || !skip_bytes(ctx, length)) { 165 return false; 166 } 167 return true; 168 } 169 170 bool asn1_oid_get(asn1_context_t* ctx, uint8_t** oid, size_t* length) { 171 if (get_byte(ctx) != kTagOid) { 172 return false; 173 } 174 if (!decode_length(ctx, length) || *length == 0 || *length > ctx->length) { 175 return false; 176 } 177 *oid = ctx->p; 178 return true; 179 } 180 181 bool asn1_octet_string_get(asn1_context_t* ctx, uint8_t** octet_string, size_t* length) { 182 if (get_byte(ctx) != kTagOctetString) { 183 return false; 184 } 185 if (!decode_length(ctx, length) || *length == 0 || *length > ctx->length) { 186 return false; 187 } 188 *octet_string = ctx->p; 189 return true; 190 } 191