Merge "Refactor asn1_decoder functions into a class." (d7846b73) · Commits · e / tools / etwrp

asn1_decoder.cpp

+110 −143

Original line number	Original line	Diff line number	Diff line
	@@ -14,86 +14,53 @@
	* 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;
	int app_type;
	} asn1_context_t;


	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) {
	free(ctx);
	}

	static inline int peek_byte(asn1_context_t* ctx) {
	if (ctx->length <= 0) {
	return -1;		return -1;
	}		}
	return *ctx->p;		return *p_;
	}		}

	static inline int get_byte(asn1_context_t* ctx) {		int asn1_context::get_byte() {
	if (ctx->length <= 0) {		if (length_ <= 0) {
	return -1;		return -1;
	}		}
	int byte = *ctx->p;
	ctx->p++;		int byte = *p_;
	ctx->length--;		p_++;
			length_--;
	return byte;		return byte;
	}		}

	static inline bool skip_bytes(asn1_context_t* ctx, size_t num_skip) {		bool asn1_context::skip_bytes(size_t num_skip) {
	if (ctx->length < num_skip) {		if (length_ < num_skip) {
	return false;		return false;
	}		}
	ctx->p += num_skip;		p_ += num_skip;
	ctx->length -= num_skip;		length_ -= num_skip;
	return true;		return true;
	}		}

	static bool decode_length(asn1_context_t* ctx, size_t* out_len) {		bool asn1_context::decode_length(size_t* out_len) {
	int num_octets = get_byte(ctx);		int num_octets = get_byte();
	if (num_octets == -1) {		if (num_octets == -1) {
	return false;		return false;
	}		}
	if ((num_octets & 0x80) == 0x00) {		if ((num_octets & 0x80) == 0x00) {
	*out_len = num_octets;		*out_len = num_octets;
	return 1;		return true;
	}		}
	num_octets &= kMaskTag;		num_octets &= kMaskTag;
	if ((size_t)num_octets >= sizeof(size_t)) {		if (static_cast<size_t>(num_octets) >= sizeof(size_t)) {
	return false;		return false;
	}		}
	size_t length = 0;		size_t length = 0;
	for (int i = 0; i < num_octets; ++i) {		for (int i = 0; i < num_octets; ++i) {
	int byte = get_byte(ctx);		int byte = get_byte();
	if (byte == -1) {		if (byte == -1) {
	return false;		return false;
	}		}
	@@ -107,85 +74,85 @@ static bool decode_length(asn1_context_t* ctx, size_t* out_len) {
	/**		/**
	* 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;		size_t length;
	if (!decode_length(ctx, &length) \|\| length > ctx->length) {		if (!decode_length(&length) \|\| length > length_) {
	return NULL;		return nullptr;
	}		}
	asn1_context_t* app_ctx = asn1_context_new(ctx->p, length);		asn1_context* app_ctx = new asn1_context(p_, length);
	app_ctx->app_type = type & kMaskAppType;		app_ctx->app_type_ = type & kMaskAppType;
	return app_ctx;		return app_ctx;
	}		}

	bool asn1_constructed_skip_all(asn1_context_t* ctx) {		bool asn1_context::asn1_constructed_skip_all() {
	int byte = peek_byte(ctx);		int byte = peek_byte();
	while (byte != -1 && (byte & kMaskConstructed) == kTagConstructed) {		while (byte != -1 && (byte & kMaskConstructed) == kTagConstructed) {
	skip_bytes(ctx, 1);		skip_bytes(1);
	size_t length;		size_t length;
	if (!decode_length(ctx, &length) \|\| !skip_bytes(ctx, length)) {		if (!decode_length(&length) \|\| !skip_bytes(length)) {
	return false;		return false;
	}		}
	byte = peek_byte(ctx);		byte = peek_byte();
	}		}
	return byte != -1;		return byte != -1;
	}		}

	int asn1_constructed_type(asn1_context_t* ctx) {		int asn1_context::asn1_constructed_type() const {
	return ctx->app_type;		return app_type_;
	}		}

	asn1_context_t* asn1_sequence_get(asn1_context_t* ctx) {		asn1_context* asn1_context::asn1_sequence_get() {
	if ((get_byte(ctx) & kMaskTag) != kTagSequence) {		if ((get_byte() & kMaskTag) != kTagSequence) {
	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) {		asn1_context* asn1_context::asn1_set_get() {
	if ((get_byte(ctx) & kMaskTag) != kTagSet) {		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);
	}		}

	bool asn1_sequence_next(asn1_context_t* ctx) {		bool asn1_context::asn1_sequence_next() {
	size_t length;		size_t length;
	if (get_byte(ctx) == -1 \|\| !decode_length(ctx, &length) \|\| !skip_bytes(ctx, length)) {		if (get_byte() == -1 \|\| !decode_length(&length) \|\| !skip_bytes(length)) {
	return false;		return false;
	}		}
	return true;		return true;
	}		}

	bool asn1_oid_get(asn1_context_t* ctx, const uint8_t** oid, size_t* length) {		bool asn1_context::asn1_oid_get(const uint8_t** oid, size_t* length) {
	if (get_byte(ctx) != kTagOid) {		if (get_byte() != kTagOid) {
	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;		*oid = p_;
	return true;		return true;
	}		}

	bool asn1_octet_string_get(asn1_context_t* ctx, const uint8_t** octet_string, size_t* length) {		bool asn1_context::asn1_octet_string_get(const uint8_t** octet_string, size_t* length) {
	if (get_byte(ctx) != kTagOctetString) {		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;
	}		}
	*octet_string = ctx->p;		*octet_string = p_;
	return true;		return true;
	}		}

asn1_decoder.h

+32 −13

Original line number	Original line	Diff line number	Diff line
	@@ -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_t* asn1_context_new(const uint8_t* buffer, size_t length);		asn1_context(const uint8_t* buffer, size_t length) : p_(buffer), length_(length), app_type_(0) {}
	void asn1_context_free(asn1_context_t* ctx);		int asn1_constructed_type() const;
	asn1_context_t* asn1_constructed_get(asn1_context_t* ctx);		asn1_context* asn1_constructed_get();
	bool asn1_constructed_skip_all(asn1_context_t* ctx);		bool asn1_constructed_skip_all();
	int asn1_constructed_type(asn1_context_t* ctx);		asn1_context* asn1_sequence_get();
	asn1_context_t* asn1_sequence_get(asn1_context_t* ctx);		asn1_context* asn1_set_get();
	asn1_context_t* asn1_set_get(asn1_context_t* ctx);		bool asn1_sequence_next();
	bool asn1_sequence_next(asn1_context_t* seq);		bool asn1_oid_get(const uint8_t** oid, size_t* length);
	bool asn1_oid_get(asn1_context_t* ctx, const uint8_t** oid, size_t* length);		bool asn1_octet_string_get(const uint8_t** octet_string, size_t* length);
	bool asn1_octet_string_get(asn1_context_t* ctx, const uint8_t** octet_string, size_t* length);
			private:
			static constexpr int kMaskConstructed = 0xE0;
			static constexpr int kMaskTag = 0x7F;
			static constexpr int kMaskAppType = 0x1F;

			static constexpr int kTagOctetString = 0x04;
			static constexpr int kTagOid = 0x06;
			static constexpr int kTagSequence = 0x30;
			static constexpr int kTagSet = 0x31;
			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_ */

tests/unit/asn1_decoder_test.cpp

+180 −217

Original line number	Original line	Diff line number	Diff line
	@@ -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 "asn1_decoder.h"		#include <memory>

	namespace android {		#include <gtest/gtest.h>

	class Asn1DecoderTest : public testing::Test {		#include "asn1_decoder.h"
	};

	TEST_F(Asn1DecoderTest, Empty_Failure) {		TEST(Asn1DecoderTest, Empty_Failure) {
	uint8_t empty[] = {};		uint8_t empty[] = {};
	asn1_context_t* ctx = asn1_context_new(empty, sizeof(empty));		asn1_context ctx(empty, sizeof(empty));

	EXPECT_EQ(NULL, asn1_constructed_get(ctx));		ASSERT_EQ(nullptr, ctx.asn1_constructed_get());
	EXPECT_FALSE(asn1_constructed_skip_all(ctx));		ASSERT_FALSE(ctx.asn1_constructed_skip_all());
	EXPECT_EQ(0, asn1_constructed_type(ctx));		ASSERT_EQ(0, ctx.asn1_constructed_type());
	EXPECT_EQ(NULL, asn1_sequence_get(ctx));		ASSERT_EQ(nullptr, ctx.asn1_sequence_get());
	EXPECT_EQ(NULL, asn1_set_get(ctx));		ASSERT_EQ(nullptr, ctx.asn1_set_get());
	EXPECT_FALSE(asn1_sequence_next(ctx));		ASSERT_FALSE(ctx.asn1_sequence_next());

	const uint8_t* junk;		const uint8_t* junk;
	size_t length;		size_t length;
	EXPECT_FALSE(asn1_oid_get(ctx, &junk, &length));		ASSERT_FALSE(ctx.asn1_oid_get(&junk, &length));
	EXPECT_FALSE(asn1_octet_string_get(ctx, &junk, &length));		ASSERT_FALSE(ctx.asn1_octet_string_get(&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(Asn1DecoderTest, ConstructedSkipAll_TruncatedLength_Failure) {
			uint8_t truncated[] = { 0xA2, 0x82 };
	TEST_F(Asn1DecoderTest, ConstructedSkipAll_TruncatedLength_Failure) {		asn1_context ctx(truncated, sizeof(truncated));
	uint8_t truncated[] = { 0xA2, 0x82, };		ASSERT_FALSE(ctx.asn1_constructed_skip_all());
	asn1_context_t* ctx = asn1_context_new(truncated, sizeof(truncated));		}
	EXPECT_FALSE(asn1_constructed_skip_all(ctx));
	asn1_context_free(ctx);		TEST(Asn1DecoderTest, ConstructedSkipAll_Success) {
	}		uint8_t data[] = { 0xA0, 0x03, 0x02, 0x01, 0x01, 0xA1, 0x03, 0x02, 0x01, 0x01, 0x06, 0x01, 0xA5 };
			asn1_context ctx(data, sizeof(data));
	TEST_F(Asn1DecoderTest, ConstructedSkipAll_Success) {		ASSERT_TRUE(ctx.asn1_constructed_skip_all());
	uint8_t data[] = { 0xA0, 0x03, 0x02, 0x01, 0x01,
	0xA1, 0x03, 0x02, 0x01, 0x01,
	0x06, 0x01, 0xA5, };
	asn1_context_t* ctx = asn1_context_new(data, sizeof(data));
	ASSERT_TRUE(asn1_constructed_skip_all(ctx));
	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(0xA5U, *oid);		ASSERT_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

verifier.cpp

+39 −37

Original line number	Original line	Diff line number	Diff line
	@@ -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);
			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;
	}		}
	asn1_context_free(signed_data_seq);
			std::unique_ptr<asn1_context> sig_set(signed_data_seq->asn1_set_get());
			if (sig_set == nullptr) {
			return false;
	}		}
	asn1_context_free(signed_data_app);
			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;
	}		}
	asn1_context_free(pkcs7_seq);
			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;
	}		}
	asn1_context_free(ctx);

	return !sig_der->empty();		sig_der->resize(sig_der_length);
			std::copy(sig_der_ptr, sig_der_ptr + sig_der_length, sig_der->begin());
			return true;
	}		}

	/*		/*