tequilaOS/platform_bootable_recovery
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Refactor asn1_decoder functions into a class.

Browse source 
Test: mmma bootable/recovery
Test: recovery_unit_test passes.
Test: recovery_component_test passes.
Change-Id: If0bf25993158eaebeedff55ba4f4dd0f6e5f937d
This commit is contained in:
Tao Bao 2017-03-20 17:09:13 -07:00
parent 5b2bf90e13
commit 861c53c6c5
4 changed files with 323 additions and 372 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

255
asn1_decoder.cpp
View file

@ -14,178 +14,145 @@
* limitations under the License. * limitations under the License.
*/ */
#include <malloc.h>
#include <stdint.h>
#include <string.h>
#include "asn1_decoder.h" #include "asn1_decoder.h"
#include <stdint.h>
typedef struct asn1_context { int asn1_context::peek_byte() const {
size_t length; if (length_ <= 0) {
const uint8_t* p; return -1;
int app_type; }
} asn1_context_t; return *p_;
static const int kMaskConstructed = 0xE0;
static const int kMaskTag = 0x7F;
static const int kMaskAppType = 0x1F;
static const int kTagOctetString = 0x04;
static const int kTagOid = 0x06;
static const int kTagSequence = 0x30;
static const int kTagSet = 0x31;
static const int kTagConstructed = 0xA0;
asn1_context_t* asn1_context_new(const uint8_t* buffer, size_t length) {
asn1_context_t* ctx = (asn1_context_t*) calloc(1, sizeof(asn1_context_t));
if (ctx == NULL) {
return NULL;
}
ctx->p = buffer;
ctx->length = length;
return ctx;
} }
void asn1_context_free(asn1_context_t* ctx) { int asn1_context::get_byte() {
free(ctx); if (length_ <= 0) {
return -1;
}
int byte = *p_;
p_++;
length_--;
return byte;
} }
static inline int peek_byte(asn1_context_t* ctx) { bool asn1_context::skip_bytes(size_t num_skip) {
if (ctx->length <= 0) { if (length_ < num_skip) {
return -1; return false;
} }
return *ctx->p; p_ += num_skip;
length_ -= num_skip;
return true;
} }
static inline int get_byte(asn1_context_t* ctx) { bool asn1_context::decode_length(size_t* out_len) {
if (ctx->length <= 0) { int num_octets = get_byte();
return -1; if (num_octets == -1) {
} return false;
int byte = *ctx->p; }
ctx->p++; if ((num_octets & 0x80) == 0x00) {
ctx->length--; *out_len = num_octets;
return byte;
}
static inline bool skip_bytes(asn1_context_t* ctx, size_t num_skip) {
if (ctx->length < num_skip) {
return false;
}
ctx->p += num_skip;
ctx->length -= num_skip;
return true; return true;
} }
num_octets &= kMaskTag;
static bool decode_length(asn1_context_t* ctx, size_t* out_len) { if (static_cast<size_t>(num_octets) >= sizeof(size_t)) {
int num_octets = get_byte(ctx); return false;
if (num_octets == -1) { }
return false; size_t length = 0;
for (int i = 0; i < num_octets; ++i) {
int byte = get_byte();
if (byte == -1) {
return false;
} }
if ((num_octets & 0x80) == 0x00) { length <<= 8;
*out_len = num_octets; length += byte;
return 1; }
} *out_len = length;
num_octets &= kMaskTag; return true;
if ((size_t)num_octets >= sizeof(size_t)) {
return false;
}
size_t length = 0;
for (int i = 0; i < num_octets; ++i) {
int byte = get_byte(ctx);
if (byte == -1) {
return false;
}
length <<= 8;
length += byte;
}
*out_len = length;
return true;
} }
/** /**
* Returns the constructed type and advances the pointer. E.g. A0 -> 0 * Returns the constructed type and advances the pointer. E.g. A0 -> 0
*/ */
asn1_context_t* asn1_constructed_get(asn1_context_t* ctx) { asn1_context* asn1_context::asn1_constructed_get() {
int type = get_byte(ctx); int type = get_byte();
if (type == -1 || (type & kMaskConstructed) != kTagConstructed) { if (type == -1 || (type & kMaskConstructed) != kTagConstructed) {
return NULL; return nullptr;
} }
size_t length;
if (!decode_length(&length) || length > length_) {
return nullptr;
}
asn1_context* app_ctx = new asn1_context(p_, length);
app_ctx->app_type_ = type & kMaskAppType;
return app_ctx;
}
bool asn1_context::asn1_constructed_skip_all() {
int byte = peek_byte();
while (byte != -1 && (byte & kMaskConstructed) == kTagConstructed) {
skip_bytes(1);
size_t length; size_t length;
if (!decode_length(ctx, &length) || length > ctx->length) { if (!decode_length(&length) || !skip_bytes(length)) {
return NULL; return false;
} }
asn1_context_t* app_ctx = asn1_context_new(ctx->p, length); byte = peek_byte();
app_ctx->app_type = type & kMaskAppType; }
return app_ctx; return byte != -1;
} }
bool asn1_constructed_skip_all(asn1_context_t* ctx) { int asn1_context::asn1_constructed_type() const {
int byte = peek_byte(ctx); return app_type_;
while (byte != -1 && (byte & kMaskConstructed) == kTagConstructed) {
skip_bytes(ctx, 1);
size_t length;
if (!decode_length(ctx, &length) || !skip_bytes(ctx, length)) {
return false;
}
byte = peek_byte(ctx);
}
return byte != -1;
} }
int asn1_constructed_type(asn1_context_t* ctx) { asn1_context* asn1_context::asn1_sequence_get() {
return ctx->app_type; if ((get_byte() & kMaskTag) != kTagSequence) {
return nullptr;
}
size_t length;
if (!decode_length(&length) || length > length_) {
return nullptr;
}
return new asn1_context(p_, length);
} }
asn1_context_t* asn1_sequence_get(asn1_context_t* ctx) { asn1_context* asn1_context::asn1_set_get() {
if ((get_byte(ctx) & kMaskTag) != kTagSequence) { if ((get_byte() & kMaskTag) != kTagSet) {
return NULL; return nullptr;
} }
size_t length; size_t length;
if (!decode_length(ctx, &length) || length > ctx->length) { if (!decode_length(&length) || length > length_) {
return NULL; return nullptr;
} }
return asn1_context_new(ctx->p, length); return new asn1_context(p_, length);
} }
asn1_context_t* asn1_set_get(asn1_context_t* ctx) { bool asn1_context::asn1_sequence_next() {
if ((get_byte(ctx) & kMaskTag) != kTagSet) { size_t length;
return NULL; if (get_byte() == -1 || !decode_length(&length) || !skip_bytes(length)) {
} return false;
size_t length; }
if (!decode_length(ctx, &length) || length > ctx->length) { return true;
return NULL;
}
return asn1_context_new(ctx->p, length);
} }
bool asn1_sequence_next(asn1_context_t* ctx) { bool asn1_context::asn1_oid_get(const uint8_t** oid, size_t* length) {
size_t length; if (get_byte() != kTagOid) {
if (get_byte(ctx) == -1 || !decode_length(ctx, &length) || !skip_bytes(ctx, length)) { return false;
return false; }
} if (!decode_length(length) || *length == 0 || *length > length_) {
return true; return false;
}
*oid = p_;
return true;
} }
bool asn1_oid_get(asn1_context_t* ctx, const uint8_t** oid, size_t* length) { bool asn1_context::asn1_octet_string_get(const uint8_t** octet_string, size_t* length) {
if (get_byte(ctx) != kTagOid) { if (get_byte() != kTagOctetString) {
return false; return false;
} }
if (!decode_length(ctx, length) || *length == 0 || *length > ctx->length) { if (!decode_length(length) || *length == 0 || *length > length_) {
return false; return false;
} }
*oid = ctx->p; *octet_string = p_;
return true; return true;
}
bool asn1_octet_string_get(asn1_context_t* ctx, const uint8_t** octet_string, size_t* length) {
if (get_byte(ctx) != kTagOctetString) {
return false;
}
if (!decode_length(ctx, length) || *length == 0 || *length > ctx->length) {
return false;
}
*octet_string = ctx->p;
return true;
} }

43
asn1_decoder.h
View file

@ -14,23 +14,42 @@
* limitations under the License. * limitations under the License.
*/ */
#ifndef ASN1_DECODER_H_ #ifndef ASN1_DECODER_H_
#define ASN1_DECODER_H_ #define ASN1_DECODER_H_
#include <stdint.h> #include <stdint.h>
typedef struct asn1_context asn1_context_t; class asn1_context {
public:
asn1_context(const uint8_t* buffer, size_t length) : p_(buffer), length_(length), app_type_(0) {}
int asn1_constructed_type() const;
asn1_context* asn1_constructed_get();
bool asn1_constructed_skip_all();
asn1_context* asn1_sequence_get();
asn1_context* asn1_set_get();
bool asn1_sequence_next();
bool asn1_oid_get(const uint8_t** oid, size_t* length);
bool asn1_octet_string_get(const uint8_t** octet_string, size_t* length);
asn1_context_t* asn1_context_new(const uint8_t* buffer, size_t length); private:
void asn1_context_free(asn1_context_t* ctx); static constexpr int kMaskConstructed = 0xE0;
asn1_context_t* asn1_constructed_get(asn1_context_t* ctx); static constexpr int kMaskTag = 0x7F;
bool asn1_constructed_skip_all(asn1_context_t* ctx); static constexpr int kMaskAppType = 0x1F;
int asn1_constructed_type(asn1_context_t* ctx);
asn1_context_t* asn1_sequence_get(asn1_context_t* ctx); static constexpr int kTagOctetString = 0x04;
asn1_context_t* asn1_set_get(asn1_context_t* ctx); static constexpr int kTagOid = 0x06;
bool asn1_sequence_next(asn1_context_t* seq); static constexpr int kTagSequence = 0x30;
bool asn1_oid_get(asn1_context_t* ctx, const uint8_t** oid, size_t* length); static constexpr int kTagSet = 0x31;
bool asn1_octet_string_get(asn1_context_t* ctx, const uint8_t** octet_string, size_t* length); static constexpr int kTagConstructed = 0xA0;
int peek_byte() const;
int get_byte();
bool skip_bytes(size_t num_skip);
bool decode_length(size_t* out_len);
const uint8_t* p_;
size_t length_;
int app_type_;
};
#endif /* ASN1_DECODER_H_ */ #endif /* ASN1_DECODER_H_ */

321
tests/unit/asn1_decoder_test.cpp
View file

@ -14,225 +14,188 @@
* limitations under the License. * limitations under the License.
*/ */
#define LOG_TAG "asn1_decoder_test"
#include <cutils/log.h>
#include <gtest/gtest.h>
#include <stdint.h> #include <stdint.h>
#include <unistd.h>
#include <memory>
#include <gtest/gtest.h>
#include "asn1_decoder.h" #include "asn1_decoder.h"
namespace android { TEST(Asn1DecoderTest, Empty_Failure) {
uint8_t empty[] = {};
asn1_context ctx(empty, sizeof(empty));
class Asn1DecoderTest : public testing::Test { ASSERT_EQ(nullptr, ctx.asn1_constructed_get());
}; ASSERT_FALSE(ctx.asn1_constructed_skip_all());
ASSERT_EQ(0, ctx.asn1_constructed_type());
ASSERT_EQ(nullptr, ctx.asn1_sequence_get());
ASSERT_EQ(nullptr, ctx.asn1_set_get());
ASSERT_FALSE(ctx.asn1_sequence_next());
TEST_F(Asn1DecoderTest, Empty_Failure) { const uint8_t* junk;
uint8_t empty[] = { }; size_t length;
asn1_context_t* ctx = asn1_context_new(empty, sizeof(empty)); ASSERT_FALSE(ctx.asn1_oid_get(&junk, &length));
ASSERT_FALSE(ctx.asn1_octet_string_get(&junk, &length));
EXPECT_EQ(NULL, asn1_constructed_get(ctx));
EXPECT_FALSE(asn1_constructed_skip_all(ctx));
EXPECT_EQ(0, asn1_constructed_type(ctx));
EXPECT_EQ(NULL, asn1_sequence_get(ctx));
EXPECT_EQ(NULL, asn1_set_get(ctx));
EXPECT_FALSE(asn1_sequence_next(ctx));
const uint8_t* junk;
size_t length;
EXPECT_FALSE(asn1_oid_get(ctx, &junk, &length));
EXPECT_FALSE(asn1_octet_string_get(ctx, &junk, &length));
asn1_context_free(ctx);
} }
TEST_F(Asn1DecoderTest, ConstructedGet_TruncatedLength_Failure) { TEST(Asn1DecoderTest, ConstructedGet_TruncatedLength_Failure) {
uint8_t truncated[] = { 0xA0, 0x82, }; uint8_t truncated[] = { 0xA0, 0x82 };
asn1_context_t* ctx = asn1_context_new(truncated, sizeof(truncated)); asn1_context ctx(truncated, sizeof(truncated));
EXPECT_EQ(NULL, asn1_constructed_get(ctx)); ASSERT_EQ(nullptr, ctx.asn1_constructed_get());
asn1_context_free(ctx);
} }
TEST_F(Asn1DecoderTest, ConstructedGet_LengthTooBig_Failure) { TEST(Asn1DecoderTest, ConstructedGet_LengthTooBig_Failure) {
uint8_t truncated[] = { 0xA0, 0x8a, 0xA5, 0x5A, 0xA5, 0x5A, uint8_t truncated[] = { 0xA0, 0x8a, 0xA5, 0x5A, 0xA5, 0x5A, 0xA5, 0x5A, 0xA5, 0x5A, 0xA5, 0x5A };
0xA5, 0x5A, 0xA5, 0x5A, 0xA5, 0x5A, }; asn1_context ctx(truncated, sizeof(truncated));
asn1_context_t* ctx = asn1_context_new(truncated, sizeof(truncated)); ASSERT_EQ(nullptr, ctx.asn1_constructed_get());
EXPECT_EQ(NULL, asn1_constructed_get(ctx));
asn1_context_free(ctx);
} }
TEST_F(Asn1DecoderTest, ConstructedGet_TooSmallForChild_Failure) { TEST(Asn1DecoderTest, ConstructedGet_TooSmallForChild_Failure) {
uint8_t data[] = { 0xA5, 0x02, 0x06, 0x01, 0x01, }; uint8_t data[] = { 0xA5, 0x02, 0x06, 0x01, 0x01 };
asn1_context_t* ctx = asn1_context_new(data, sizeof(data)); asn1_context ctx(data, sizeof(data));
asn1_context_t* ptr = asn1_constructed_get(ctx); std::unique_ptr<asn1_context> ptr(ctx.asn1_constructed_get());
ASSERT_NE((asn1_context_t*)NULL, ptr); ASSERT_NE(nullptr, ptr);
EXPECT_EQ(5, asn1_constructed_type(ptr)); ASSERT_EQ(5, ptr->asn1_constructed_type());
const uint8_t* oid; const uint8_t* oid;
size_t length; size_t length;
EXPECT_FALSE(asn1_oid_get(ptr, &oid, &length)); ASSERT_FALSE(ptr->asn1_oid_get(&oid, &length));
asn1_context_free(ptr);
asn1_context_free(ctx);
} }
TEST_F(Asn1DecoderTest, ConstructedGet_Success) { TEST(Asn1DecoderTest, ConstructedGet_Success) {
uint8_t data[] = { 0xA5, 0x03, 0x06, 0x01, 0x01, }; uint8_t data[] = { 0xA5, 0x03, 0x06, 0x01, 0x01 };
asn1_context_t* ctx = asn1_context_new(data, sizeof(data)); asn1_context ctx(data, sizeof(data));
asn1_context_t* ptr = asn1_constructed_get(ctx); std::unique_ptr<asn1_context> ptr(ctx.asn1_constructed_get());
ASSERT_NE((asn1_context_t*)NULL, ptr); ASSERT_NE(nullptr, ptr);
EXPECT_EQ(5, asn1_constructed_type(ptr)); ASSERT_EQ(5, ptr->asn1_constructed_type());
const uint8_t* oid; const uint8_t* oid;
size_t length; size_t length;
ASSERT_TRUE(asn1_oid_get(ptr, &oid, &length)); ASSERT_TRUE(ptr->asn1_oid_get(&oid, &length));
EXPECT_EQ(1U, length); ASSERT_EQ(1U, length);
EXPECT_EQ(0x01U, *oid); ASSERT_EQ(0x01U, *oid);
asn1_context_free(ptr);
asn1_context_free(ctx);
} }
TEST_F(Asn1DecoderTest, ConstructedSkipAll_TruncatedLength_Failure) { TEST(Asn1DecoderTest, ConstructedSkipAll_TruncatedLength_Failure) {
uint8_t truncated[] = { 0xA2, 0x82, }; uint8_t truncated[] = { 0xA2, 0x82 };
asn1_context_t* ctx = asn1_context_new(truncated, sizeof(truncated)); asn1_context ctx(truncated, sizeof(truncated));
EXPECT_FALSE(asn1_constructed_skip_all(ctx)); ASSERT_FALSE(ctx.asn1_constructed_skip_all());
asn1_context_free(ctx);
} }
TEST_F(Asn1DecoderTest, ConstructedSkipAll_Success) { TEST(Asn1DecoderTest, ConstructedSkipAll_Success) {
uint8_t data[] = { 0xA0, 0x03, 0x02, 0x01, 0x01, uint8_t data[] = { 0xA0, 0x03, 0x02, 0x01, 0x01, 0xA1, 0x03, 0x02, 0x01, 0x01, 0x06, 0x01, 0xA5 };
0xA1, 0x03, 0x02, 0x01, 0x01, asn1_context ctx(data, sizeof(data));
0x06, 0x01, 0xA5, }; ASSERT_TRUE(ctx.asn1_constructed_skip_all());
asn1_context_t* ctx = asn1_context_new(data, sizeof(data)); const uint8_t* oid;
ASSERT_TRUE(asn1_constructed_skip_all(ctx)); size_t length;
const uint8_t* oid; ASSERT_TRUE(ctx.asn1_oid_get(&oid, &length));
size_t length; ASSERT_EQ(1U, length);
ASSERT_TRUE(asn1_oid_get(ctx, &oid, &length)); ASSERT_EQ(0xA5U, *oid);
EXPECT_EQ(1U, length);
EXPECT_EQ(0xA5U, *oid);
asn1_context_free(ctx);
} }
TEST_F(Asn1DecoderTest, SequenceGet_TruncatedLength_Failure) { TEST(Asn1DecoderTest, SequenceGet_TruncatedLength_Failure) {
uint8_t truncated[] = { 0x30, 0x82, }; uint8_t truncated[] = { 0x30, 0x82 };
asn1_context_t* ctx = asn1_context_new(truncated, sizeof(truncated)); asn1_context ctx(truncated, sizeof(truncated));
EXPECT_EQ(NULL, asn1_sequence_get(ctx)); ASSERT_EQ(nullptr, ctx.asn1_sequence_get());
asn1_context_free(ctx);
} }
TEST_F(Asn1DecoderTest, SequenceGet_TooSmallForChild_Failure) { TEST(Asn1DecoderTest, SequenceGet_TooSmallForChild_Failure) {
uint8_t data[] = { 0x30, 0x02, 0x06, 0x01, 0x01, }; uint8_t data[] = { 0x30, 0x02, 0x06, 0x01, 0x01 };
asn1_context_t* ctx = asn1_context_new(data, sizeof(data)); asn1_context ctx(data, sizeof(data));
asn1_context_t* ptr = asn1_sequence_get(ctx); std::unique_ptr<asn1_context> ptr(ctx.asn1_sequence_get());
ASSERT_NE((asn1_context_t*)NULL, ptr); ASSERT_NE(nullptr, ptr);
const uint8_t* oid; const uint8_t* oid;
size_t length; size_t length;
EXPECT_FALSE(asn1_oid_get(ptr, &oid, &length)); ASSERT_FALSE(ptr->asn1_oid_get(&oid, &length));
asn1_context_free(ptr);
asn1_context_free(ctx);
} }
TEST_F(Asn1DecoderTest, SequenceGet_Success) { TEST(Asn1DecoderTest, SequenceGet_Success) {
uint8_t data[] = { 0x30, 0x03, 0x06, 0x01, 0x01, }; uint8_t data[] = { 0x30, 0x03, 0x06, 0x01, 0x01 };
asn1_context_t* ctx = asn1_context_new(data, sizeof(data)); asn1_context ctx(data, sizeof(data));
asn1_context_t* ptr = asn1_sequence_get(ctx); std::unique_ptr<asn1_context> ptr(ctx.asn1_sequence_get());
ASSERT_NE((asn1_context_t*)NULL, ptr); ASSERT_NE(nullptr, ptr);
const uint8_t* oid; const uint8_t* oid;
size_t length; size_t length;
ASSERT_TRUE(asn1_oid_get(ptr, &oid, &length)); ASSERT_TRUE(ptr->asn1_oid_get(&oid, &length));
EXPECT_EQ(1U, length); ASSERT_EQ(1U, length);
EXPECT_EQ(0x01U, *oid); ASSERT_EQ(0x01U, *oid);
asn1_context_free(ptr);
asn1_context_free(ctx);
} }
TEST_F(Asn1DecoderTest, SetGet_TruncatedLength_Failure) { TEST(Asn1DecoderTest, SetGet_TruncatedLength_Failure) {
uint8_t truncated[] = { 0x31, 0x82, }; uint8_t truncated[] = { 0x31, 0x82 };
asn1_context_t* ctx = asn1_context_new(truncated, sizeof(truncated)); asn1_context ctx(truncated, sizeof(truncated));
EXPECT_EQ(NULL, asn1_set_get(ctx)); ASSERT_EQ(nullptr, ctx.asn1_set_get());
asn1_context_free(ctx);
} }
TEST_F(Asn1DecoderTest, SetGet_TooSmallForChild_Failure) { TEST(Asn1DecoderTest, SetGet_TooSmallForChild_Failure) {
uint8_t data[] = { 0x31, 0x02, 0x06, 0x01, 0x01, }; uint8_t data[] = { 0x31, 0x02, 0x06, 0x01, 0x01 };
asn1_context_t* ctx = asn1_context_new(data, sizeof(data)); asn1_context ctx(data, sizeof(data));
asn1_context_t* ptr = asn1_set_get(ctx); std::unique_ptr<asn1_context> ptr(ctx.asn1_set_get());
ASSERT_NE((asn1_context_t*)NULL, ptr); ASSERT_NE(nullptr, ptr);
const uint8_t* oid; const uint8_t* oid;
size_t length; size_t length;
EXPECT_FALSE(asn1_oid_get(ptr, &oid, &length)); ASSERT_FALSE(ptr->asn1_oid_get(&oid, &length));
asn1_context_free(ptr);
asn1_context_free(ctx);
} }
TEST_F(Asn1DecoderTest, SetGet_Success) { TEST(Asn1DecoderTest, SetGet_Success) {
uint8_t data[] = { 0x31, 0x03, 0x06, 0x01, 0xBA, }; uint8_t data[] = { 0x31, 0x03, 0x06, 0x01, 0xBA };
asn1_context_t* ctx = asn1_context_new(data, sizeof(data)); asn1_context ctx(data, sizeof(data));
asn1_context_t* ptr = asn1_set_get(ctx); std::unique_ptr<asn1_context> ptr(ctx.asn1_set_get());
ASSERT_NE((asn1_context_t*)NULL, ptr); ASSERT_NE(nullptr, ptr);
const uint8_t* oid; const uint8_t* oid;
size_t length; size_t length;
ASSERT_TRUE(asn1_oid_get(ptr, &oid, &length)); ASSERT_TRUE(ptr->asn1_oid_get(&oid, &length));
EXPECT_EQ(1U, length); ASSERT_EQ(1U, length);
EXPECT_EQ(0xBAU, *oid); ASSERT_EQ(0xBAU, *oid);
asn1_context_free(ptr);
asn1_context_free(ctx);
} }
TEST_F(Asn1DecoderTest, OidGet_LengthZero_Failure) { TEST(Asn1DecoderTest, OidGet_LengthZero_Failure) {
uint8_t data[] = { 0x06, 0x00, 0x01, }; uint8_t data[] = { 0x06, 0x00, 0x01 };
asn1_context_t* ctx = asn1_context_new(data, sizeof(data)); asn1_context ctx(data, sizeof(data));
const uint8_t* oid; const uint8_t* oid;
size_t length; size_t length;
EXPECT_FALSE(asn1_oid_get(ctx, &oid, &length)); ASSERT_FALSE(ctx.asn1_oid_get(&oid, &length));
asn1_context_free(ctx);
} }
TEST_F(Asn1DecoderTest, OidGet_TooSmall_Failure) { TEST(Asn1DecoderTest, OidGet_TooSmall_Failure) {
uint8_t data[] = { 0x06, 0x01, }; uint8_t data[] = { 0x06, 0x01 };
asn1_context_t* ctx = asn1_context_new(data, sizeof(data)); asn1_context ctx(data, sizeof(data));
const uint8_t* oid; const uint8_t* oid;
size_t length; size_t length;
EXPECT_FALSE(asn1_oid_get(ctx, &oid, &length)); ASSERT_FALSE(ctx.asn1_oid_get(&oid, &length));
asn1_context_free(ctx);
} }
TEST_F(Asn1DecoderTest, OidGet_Success) { TEST(Asn1DecoderTest, OidGet_Success) {
uint8_t data[] = { 0x06, 0x01, 0x99, }; uint8_t data[] = { 0x06, 0x01, 0x99 };
asn1_context_t* ctx = asn1_context_new(data, sizeof(data)); asn1_context ctx(data, sizeof(data));
const uint8_t* oid; const uint8_t* oid;
size_t length; size_t length;
ASSERT_TRUE(asn1_oid_get(ctx, &oid, &length)); ASSERT_TRUE(ctx.asn1_oid_get(&oid, &length));
EXPECT_EQ(1U, length); ASSERT_EQ(1U, length);
EXPECT_EQ(0x99U, *oid); ASSERT_EQ(0x99U, *oid);
asn1_context_free(ctx);
} }
TEST_F(Asn1DecoderTest, OctetStringGet_LengthZero_Failure) { TEST(Asn1DecoderTest, OctetStringGet_LengthZero_Failure) {
uint8_t data[] = { 0x04, 0x00, 0x55, }; uint8_t data[] = { 0x04, 0x00, 0x55 };
asn1_context_t* ctx = asn1_context_new(data, sizeof(data)); asn1_context ctx(data, sizeof(data));
const uint8_t* string; const uint8_t* string;
size_t length; size_t length;
ASSERT_FALSE(asn1_octet_string_get(ctx, &string, &length)); ASSERT_FALSE(ctx.asn1_octet_string_get(&string, &length));
asn1_context_free(ctx);
} }
TEST_F(Asn1DecoderTest, OctetStringGet_TooSmall_Failure) { TEST(Asn1DecoderTest, OctetStringGet_TooSmall_Failure) {
uint8_t data[] = { 0x04, 0x01, }; uint8_t data[] = { 0x04, 0x01 };
asn1_context_t* ctx = asn1_context_new(data, sizeof(data)); asn1_context ctx(data, sizeof(data));
const uint8_t* string; const uint8_t* string;
size_t length; size_t length;
ASSERT_FALSE(asn1_octet_string_get(ctx, &string, &length)); ASSERT_FALSE(ctx.asn1_octet_string_get(&string, &length));
asn1_context_free(ctx);
} }
TEST_F(Asn1DecoderTest, OctetStringGet_Success) { TEST(Asn1DecoderTest, OctetStringGet_Success) {
uint8_t data[] = { 0x04, 0x01, 0xAA, }; uint8_t data[] = { 0x04, 0x01, 0xAA };
asn1_context_t* ctx = asn1_context_new(data, sizeof(data)); asn1_context ctx(data, sizeof(data));
const uint8_t* string; const uint8_t* string;
size_t length; size_t length;
ASSERT_TRUE(asn1_octet_string_get(ctx, &string, &length)); ASSERT_TRUE(ctx.asn1_octet_string_get(&string, &length));
EXPECT_EQ(1U, length); ASSERT_EQ(1U, length);
EXPECT_EQ(0xAAU, *string); ASSERT_EQ(0xAAU, *string);
asn1_context_free(ctx);
} }
} // namespace android

76
verifier.cpp
View file

@ -66,48 +66,50 @@ static bool read_pkcs7(const uint8_t* pkcs7_der, size_t pkcs7_der_len,
CHECK(sig_der != nullptr); CHECK(sig_der != nullptr);
sig_der->clear(); sig_der->clear();
asn1_context_t* ctx = asn1_context_new(pkcs7_der, pkcs7_der_len); asn1_context ctx(pkcs7_der, pkcs7_der_len);
if (ctx == NULL) {
std::unique_ptr<asn1_context> pkcs7_seq(ctx.asn1_sequence_get());
if (pkcs7_seq == nullptr || !pkcs7_seq->asn1_sequence_next()) {
return false; return false;
} }
asn1_context_t* pkcs7_seq = asn1_sequence_get(ctx); std::unique_ptr<asn1_context> signed_data_app(pkcs7_seq->asn1_constructed_get());
if (pkcs7_seq != NULL && asn1_sequence_next(pkcs7_seq)) { if (signed_data_app == nullptr) {
asn1_context_t *signed_data_app = asn1_constructed_get(pkcs7_seq); return false;
if (signed_data_app != NULL) {
asn1_context_t* signed_data_seq = asn1_sequence_get(signed_data_app);
if (signed_data_seq != NULL
&& asn1_sequence_next(signed_data_seq)
&& asn1_sequence_next(signed_data_seq)
&& asn1_sequence_next(signed_data_seq)
&& asn1_constructed_skip_all(signed_data_seq)) {
asn1_context_t *sig_set = asn1_set_get(signed_data_seq);
if (sig_set != NULL) {
asn1_context_t* sig_seq = asn1_sequence_get(sig_set);
if (sig_seq != NULL
&& asn1_sequence_next(sig_seq)
&& asn1_sequence_next(sig_seq)
&& asn1_sequence_next(sig_seq)
&& asn1_sequence_next(sig_seq)) {
const uint8_t* sig_der_ptr;
size_t sig_der_length;
if (asn1_octet_string_get(sig_seq, &sig_der_ptr, &sig_der_length)) {
sig_der->resize(sig_der_length);
std::copy(sig_der_ptr, sig_der_ptr + sig_der_length, sig_der->begin());
}
asn1_context_free(sig_seq);
}
asn1_context_free(sig_set);
}
asn1_context_free(signed_data_seq);
}
asn1_context_free(signed_data_app);
}
asn1_context_free(pkcs7_seq);
} }
asn1_context_free(ctx);
return !sig_der->empty(); std::unique_ptr<asn1_context> signed_data_seq(signed_data_app->asn1_sequence_get());
if (signed_data_seq == nullptr ||
!signed_data_seq->asn1_sequence_next() ||
!signed_data_seq->asn1_sequence_next() ||
!signed_data_seq->asn1_sequence_next() ||
!signed_data_seq->asn1_constructed_skip_all()) {
return false;
}
std::unique_ptr<asn1_context> sig_set(signed_data_seq->asn1_set_get());
if (sig_set == nullptr) {
return false;
}
std::unique_ptr<asn1_context> sig_seq(sig_set->asn1_sequence_get());
if (sig_seq == nullptr ||
!sig_seq->asn1_sequence_next() ||
!sig_seq->asn1_sequence_next() ||
!sig_seq->asn1_sequence_next() ||
!sig_seq->asn1_sequence_next()) {
return false;
}
const uint8_t* sig_der_ptr;
size_t sig_der_length;
if (!sig_seq->asn1_octet_string_get(&sig_der_ptr, &sig_der_length)) {
return false;
}
sig_der->resize(sig_der_length);
std::copy(sig_der_ptr, sig_der_ptr + sig_der_length, sig_der->begin());
return true;
} }
/* /*